Comprendre Passer à travers le prisme de TypeScript/JavaScript

Si vous venez d'un milieu TypeScript/JavaScript et que vous plongez dans Go, il peut être utile de faire des parallèles entre les deux langages pour accélérer votre apprentissage. Bien qu'ils soient fondamentalement différents à bien des égards (Go étant un langage compilé à typage statique, et TypeScript/JavaScript étant des langages typés, interprétés ou transpilés dynamiquement), il existe quelques analogies utiles qui contribueront à rendre Go plus intuitif.

1. Structs en Go ≈ Types en TypeScript

Dans TypeScript, vous définissez des types et des interfaces pour décrire la forme des objets. De même, Go possède des structures utilisées pour définir des types personnalisés. Une structure peut contenir des champs de différents types, de la même manière qu'un type ou une interface TypeScript peut contenir différentes propriétés.

TypeScript :

type Book = {
  title: string;
  pages: number;
  read(): void;
}

Aller :

type Book struct {
    Title string
    Pages int
}

func (b Book) Read() {
    fmt.Println("Reading", b.Title)
}

Dans les deux cas, vous définissez la structure d'un objet. Cependant, les structures de Go sont plus rigides et ne prennent pas en charge l'héritage, contrairement à TypeScript, qui permet un comportement plus dynamique avec les interfaces et l'héritage de classe.

2. Méthodes en Go : Récepteurs ≈ Prototypes en JavaScript

En JavaScript, lorsque vous définissez une méthode sur le prototype d'un objet, elle est associée aux instances de cet objet. Go utilise un concept similaire avec des fonctions de récepteur qui sont liées à une structure spécifique. Cela ressemble à la façon dont les fonctions sont attachées aux objets en JavaScript via des prototypes.

JavaScript :

function Book(title, pages) {
    this.title = title;
    this.pages = pages;
}

Book.prototype.read = function() {
    console.log("Reading", this.title);
}

Aller :

type Book struct {
    Title string
    Pages int
}

func (b Book) Read() {
    fmt.Println("Reading", b.Title)
}

Dans Go, la méthode Read possède un récepteur (b Book), qui agit de la même manière que les méthodes sont associées aux prototypes en JavaScript. Il vous donne l'instance de l'objet (b ici), vous permettant d'accéder aux champs et d'utiliser la méthode.

3. let, var, const en TypeScript ≈ Déclaration de variable en Go

La façon dont vous déclarez les variables dans Go rappelle les let, var et const de JavaScript. Dans Go, les variables sont déclarées avec var et les constantes avec const, un peu comme TypeScript.

TypeScript :

let name: string = "TypeScript";
const maxItems: number = 100;

Aller :

var name string = "Go"
const maxItems int = 100

Le raccourci := dans Go ressemble un peu à celui de JavaScript en ce sens qu'il permet une déclaration rapide de variable :

type Book = {
  title: string;
  pages: number;
  read(): void;
}

En Go, il n'y a pas de distinction entre let et const comme en JavaScript. Par défaut, toutes les variables de Go sont mutables lorsqu'elles sont déclarées avec var, ce qui signifie que leurs valeurs peuvent être modifiées ultérieurement. Si vous souhaitez rendre une variable immuable dans Go, vous devez utiliser explicitement le mot-clé const. Contrairement à JavaScript, où vous avez à la fois let pour les variables mutables et const pour les variables immuables, dans Go, tout est mutable sauf si vous le déclarez comme const.

4. Interfaces Go ≈ Interfaces TypeScript (avec différences)

Les interfaces TypeScript définissent la forme des objets, tandis que les interfaces Go définissent le comportement (c'est-à-dire un ensemble de méthodes qu'un objet doit avoir). Dans Go, un objet "implémente" implicitement une interface en disposant de toutes les méthodes requises, ce qui contraste avec l'implémentation explicite de TypeScript.

TypeScript :

type Book struct {
    Title string
    Pages int
}

func (b Book) Read() {
    fmt.Println("Reading", b.Title)
}

Aller :

function Book(title, pages) {
    this.title = title;
    this.pages = pages;
}

Book.prototype.read = function() {
    console.log("Reading", this.title);
}

En Go, tout type qui implémente la méthode Read est considéré comme implémentant l'interface Reader, même sans la déclarer explicitement.

5. Gestion des erreurs dans Go ≈ Try-Catch en JavaScript (mais différent)

La gestion des erreurs dans Go est très différente de celle du try-catch de JavaScript. Dans Go, la gestion des erreurs se fait explicitement avec des valeurs de retour, tandis que JavaScript utilise des exceptions.

JavaScript :

type Book struct {
    Title string
    Pages int
}

func (b Book) Read() {
    fmt.Println("Reading", b.Title)
}

Aller :

let name: string = "TypeScript";
const maxItems: number = 100;

Dans Go, les erreurs sont renvoyées par les fonctions et doivent être vérifiées explicitement, ce qui conduit à un flux de contrôle plus prévisible mais nécessite une gestion manuelle des erreurs plus importante que le mécanisme try-catch de JavaScript.

6. Système de packages en Go ≈ Modules ES en TypeScript

Dans TypeScript, vous organisez votre code en modules qui peuvent importer/exporter d'autres fonctionnalités. Go dispose d'un système de packages similaire dans lequel chaque fichier fait partie d'un package et les packages peuvent importer des fonctionnalités à partir d'autres packages.

TypeScript :

var name string = "Go"
const maxItems int = 100

Aller :

name := "Go" // type inference, like in TypeScript

Dans Go, le package main est le point d'entrée de votre application, de la même manière qu'un fichier principal peut servir de point d'entrée pour un projet TypeScript utilisant des modules ES.

7. Concurrence en Go : Goroutines ≈ Programmation asynchrone

La programmation asynchrone de JavaScript avec async/await et promises ressemble quelque peu aux goroutines de Go. Les Goroutines permettent aux fonctions de s'exécuter simultanément, ce qui rend le modèle de concurrence de Go très puissant.

JavaScript :

interface Reader {
  read(): void;
}

class Book implements Reader {
  read() {
    console.log("Reading a book");
  }
}

Aller :

type Reader interface {
    Read()
}

type Book struct {
    Title string
}

func (b Book) Read() {
    fmt.Println("Reading", b.Title)
}

Avec les goroutines de Go, vous pouvez lancer des fonctions simultanément avec le mot-clé go, tandis que TypeScript y parvient via async/await et promises.

Conclusion

Passer de TypeScript/JavaScript à Go peut sembler intimidant au début, mais établir ces comparaisons peut aider à rendre la transition plus fluide. Comprendre le système de types plus strict de Go, les interfaces explicites et le modèle de concurrence rendra votre voyage enrichissant. Une fois que vous aurez compris la nature plus explicite et structurée de Go, vous apprécierez ses performances et sa fiabilité dans la construction de systèmes robustes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!