Structures en

À propos de Structures

En Go, une 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 de la struct. On peut comparer les struct aux classes du paradigme de la programmation orientée objet.

Définir une struct

On crée une nouvelle struct à l'aide des mots-clés type et struct, en définissant explicitement le nom et le type de ses champs. Par exemple, on définit ici la struct Shape, qui contient le nom d'une forme et sa taille :

type Shape struct {
    name string
    size int
}

Les noms de champs d'une struct suivent la convention de Go : les champs dont le nom commence par une lettre minuscule ne sont visibles que pour le code du même package, tandis que ceux dont le nom commence par une lettre majuscule sont visibles depuis les autres packages.

Créer des instances d'une struct

Une fois la struct définie, il faut créer une nouvelle instance en indiquant 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

Tu peux créer une instance de struct sans indiquer le nom 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 agréable de disposer de fonctions qui aident à créer des instances de struct. Par convention, ces fonctions s'appellent généralement New ou portent 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 faire penser aux constructeurs d'autres langages, mais en Go, ce ne sont que des fonctions ordinaires.

Dans l'exemple suivant, l'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 fournies
• la gestion des valeurs par défaut
• comme les fonctions New sont souvent déclarées dans le même package que les struct qu'elles initialisent, elles peuvent même initialiser des champs privés de la struct

Pour aller plus loin sur ce type, tu peux consulter ces ressources : Go by Example: Structs, A Tour of Go: Structs ou Structures in Go (structs)

La fonction intégrée new

Une autre façon de créer une nouvelle instance de struct consiste à utiliser la fonction intégrée new :

s := new(Shape) // s will be of type *Shape (pointer to shape)
fmt.Printf("name: %s size: %d\n", s.name, s.size)
// Output: name:  size: 0

Dans cet exemple, new crée une instance de la struct Shape dont toutes les valeurs sont initialisées à la valeur zéro de leur type, et renvoie un pointeur vers celle-ci.