En Go, un struct est une suite d'éléments nommés appelés champs, et chaque champ possède un nom et un type.
Le nom d'un champ doit être unique au sein du struct.
On peut rapprocher les struct des classes de la programmation orientée objet.
Définis un struct
Pour créer un nouveau struct, on utilise les mots-clés type et struct, et on définit explicitement le nom et le type des champs.
Par exemple, on définit ici le struct Shape, qui contient le nom d'une forme et sa taille :
type Shape struct {
name string
size int
}
Les noms de champs dans les struct suivent la convention de Go : les champs dont le nom commence par une minuscule ne sont visibles que par le code du même paquet, tandis que ceux dont le nom commence par une majuscule sont visibles depuis les autres paquets.
Crée des instances d'un struct
Une fois le struct défini, il faut créer une nouvelle instance en définissant les champs par leur nom, dans n'importe quel ordre :
s := Shape {
name: "Square",
size: 25,
}
Pour lire ou modifier les champs d'une instance, on utilise la notation . :
// Update the name and the size
s.name = "Circle"
s.size = 35
fmt.Printf("name: %s size: %d\n", s.name, s.size)
// Output: name: Circle size: 35
Les champs auxquels aucune valeur initiale n'est affectée prennent leur valeur zéro.
Par exemple :
s := Shape{name: "Circle"}
fmt.Printf("name: %s size: %d\n", s.name, s.size)
// Output: name: Circle size: 0
On peut créer une instance d'un struct sans utiliser les noms des champs, à condition de définir les champs dans l'ordre :
s := Shape {
"Oval",
20,
}
Cependant, cette syntaxe est considérée comme du code fragile, car elle peut casser quand on ajoute un champ, surtout si le nouveau champ est d'un type différent.
Dans l'exemple suivant, on ajoute un champ supplémentaire à Shape :
type Shape struct {
name string
description string // new field 'description' added
size int
}
s := Shape{
"Circle",
20,
}
// Since the second field of the struct is now a string and not an int,
// the compiler will throw an error when compiling the program:
// Output: cannot use 20 (type untyped int) as type string in field value
// Output: too few values in Shape{...}
Les fonctions « New »
Il est parfois pratique de disposer de fonctions qui nous aident à créer des instances de struct.
Par convention, ces fonctions s'appellent généralement New ou ont un nom qui commence par New, mais comme ce sont de simples fonctions ordinaires, tu peux leur donner le nom que tu veux.
Elles peuvent te rappeler les constructeurs d'autres langages, mais en Go, ce ne sont que des fonctions ordinaires.
Dans l'exemple suivant, une de ces fonctions New sert à créer une nouvelle instance de Shape et à définir automatiquement une valeur par défaut pour la size de la forme :
func NewShape(name string) Shape {
return Shape{
name: name,
size: 100, //default-value for size is 100
}
}
NewShape("Triangle")
// => Shape { name: "Triangle", size: 100 }
Utiliser des fonctions New présente les avantages suivants :
- la validation des valeurs données
- la gestion des valeurs par défaut
- comme les fonctions
New sont souvent déclarées dans le même paquet que les struct qu'elles initialisent, elles peuvent même initialiser des champs privés du struct
Exercice d'apprentissage
