Réponse.

Historique de la question :

L'apparition des alias de type en Go est liée à la nécessité d'assurer une transition plus fluide entre les versions de l'API, lorsque un type passe d'un paquet à un autre. Avant Go 1.9, seuls de nouveaux types étaient déclarés, maintenant, les alias de type sont supportés.

Problème :

Beaucoup confondent les alias et les nouveaux types — pensant à tort qu'ils sont identiques, ce qui entraîne des erreurs de conversion, des méthodes, et des passages dans les interfaces.

Solution :

L'alias de type crée un nom alternatif pour un type existant, tandis que la déclaration d'un nouveau type est la création d'un nouveau type unique basé sur un existant. Les alias permettent de maintenir la compatibilité descendante et d'intégrer les anciens et nouveaux types sans conversion.

Exemple de code :

// Nouveau type
type MyString string
// Alias de type
type MyStringAlias = string

Caractéristiques clés :

L'alias et le type d'origine sont complètement interchangeables
Le nouveau type est autonome, il est possible d'ajouter des méthodes et la conversion implicite n'est pas possible
L'alias est pratique pour les migrations et le réexportation de types entre paquets

Questions piégeuses.

Peut-on ajouter des méthodes à un type par le biais de l'alias ?

Non, on peut ajouter des méthodes uniquement à des nouveaux types, et l'alias n'est pas un nouveau type, c'est la même chose que le type d'origine.

type Alias = int
// func (a Alias) Method() {} // erreur !

Quelle est la différence entre les types alias et les nouveaux types ?

L'alias est comparable au type de base et accepte sa valeur sans conversion. Le nouveau type n'est pas compatible même s'il est basé sur le même type.

type T1 = int
var a T1 = 10 // ok
var b int = a // ok

type T2 int
var c T2 = 10
// var d int = c // erreur de compilation

Quand l'alias est-il préférable au type nouveau ?

Lorsqu'il est nécessaire de réexporter un type entre paquets ou d'assurer une migration transparente de l'API sans recompilation du code client. Par exemple :

type OldType = NewType // l'alias est plus pratique pour le maintien des anciennes versions de l'API

Erreurs typiques et anti-patrons

Confusion entre alias et nouveau type par le nom
Réutilisation d'un alias avec une tentative d'étendre la fonctionnalité
Utilisation d'un alias là où un type encapsulé avec méthodes est nécessaire

Exemple de la vie réelle

Cas négatif

Dans le projet, un type est renommé avec un nouveau type plutôt qu'un alias, ce qui casse la compatibilité

type OldType int

Avantages :

Possibilité de définir ses propres méthodes

Inconvénients :

Nécessite une conversion manuelle des types lors de la migration, cassant la compatibilité descendante

Cas positif

Utilisation d'un alias de type pour une migration transparente de l'API

type OldType = NewType