Réponse.

Dans le langage Go, le développeur peut créer ses propres types sur la base de types existants ou déclarer des alias pour améliorer la lisibilité du code et l'intégration avec des bibliothèques externes.

Historique de la question :

Go simplifie fondamentalement le système de types en séparant les concepts de création d'un nouveau type (type MyInt int) et d'alias (type MyIntAlias = int). Une confusion fréquente est susceptible de survenir entre eux, ce qui impacte la compatibilité des données entre différentes parties du système.

Problématique :

Si le moyen de déclaration du type est mal choisi, on peut se retrouver avec une multitude d'erreurs implicites : impossibilité de transmettre des données entre les paquets, fonctionnement incorrect avec des bibliothèques externes ou perte de tous les méthodes lors de l'utilisation d'un alias.

Solution :

Un nouveau type (type Foo T) crée réellement un nouveau type avec sa propre identité, même s'il est basé sur un type existant (comme int, struct).
Un alias de type (type Foo = T) donne un nom alternatif à un type existant, conservant complètement ses méthodes et comportant les correspondances d'interface.

Exemple de code :

package main
import "fmt"

type MyInt int           // nouveau type
func (m MyInt) Double() int { return int(m) * 2 }

type MyIntAlias = int    // alias de type

func main() {
    var a MyInt = 5
    var b MyIntAlias = 10
    fmt.Println(a.Double()) // fonctionne
    //fmt.Println(b.Double()) // erreur : méthode non définie sur int
}

Caractéristiques clés :

Un nouveau type est complètement séparé de son type de base
Un alias ne crée pas de nouveau type, seulement un nouveau nom
Les méthodes déclarées pour un nouveau type ne sont pas applicables à un alias

Questions pièges.

Peut-on faire un alias de structure et lui ajouter des méthodes différentes de celles de la structure de base ?

Non. Les méthodes ne peuvent être déclarées que pour un nouveau type, pas pour un alias. Un alias est simplement un autre nom pour le même type, une partie du programme ne saura pas « l’extension » du type.

type MyStructAlias = SomeStruct
// func (s MyStructAlias) NewMethod() {} // Erreur

Les méthodes du type de base peuvent-elles automatiquement « s'attacher » à l'alias ?

Oui, car pour le compilateur, c'est le même type. Mais on ne peut pas travailler avec de nouvelles méthodes : vous ne pouvez pas ajouter de méthodes uniques à un alias.

type MyString = string // toutes les méthodes et fonctions pour string fonctionnent

Quelle est la différence entre la conversion en type et en alias ?

Lors de la déclaration d'un nouveau type, une conversion explicite est nécessaire : MyInt(x) où x — int. Pour un alias, la conversion n'est pas nécessaire — les types sont complètement interchangeables.

type A int
type B = int
var x int = 3
var a A = A(x)      // conversion explicite
var b B = x         // implicite, équivalent à int

Erreurs typiques et anti-patrons

Embrouiller la structure du code en mélangeant nouveaux types et alias
Absence inattendue de méthodes sur un alias
Utilisation d'aliases pour isoler des données — ils ne sont pas adaptés à cet usage (de meilleurs nouveaux types)

Exemple de la vie réelle

Cas négatif

Un développeur crée un alias de type pour une bibliothèque externe, croyant à tort qu'il est possible d'ajouter ses propres méthodes à ce type et d'encapsuler la logique de transition.

Avantages :

S'intègre facilement avec une API externe

Inconvénients :

Les méthodes ne s'ajoutent pas, le comportement n'est pas étendu, ce qui entraîne une logique des données imprévisible

Cas positif

L'équipe crée un nouveau type basé sur int pour représenter les identifiants d'utilisateur, afin de protéger la logique métier d'une confusion accidentelle avec d'autres valeurs entières, et ajoute des méthodes spéciales (validateurs, transformateurs).