Raccourcis secrets de Go : que sont les struct tags et à quoi servent-ils

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction : les guillemets magiques dans le code Go

Si vous avez déjà écrit des structures Go pour travailler avec du JSON, vous avez sûrement vu ces constructions étranges :

type User struct {    Name string `json:"name"`    Age  int    `json:"age,omitempty"`}

Ces mystérieux guillemets inversés (`json:"name"`) sont appelés struct tags (balises de structures). Pour un débutant, ils ressemblent à de la magie ou à du bruit inutile. Mais en réalité, c'est l'une des fonctionnalités les plus puissantes et élégantes de Go, qui permet de méta-programmer sans macros complexes.

Dans cet article, nous allons voir ce que sont les struct tags en Go, à quoi ils servent, quels types existent, et comment les utiliser dans des projets réels. Vous cesserez d'avoir peur de ces « chaînes magiques » et commencerez à les utiliser en toute connaissance de cause.

Que sont les struct tags ? Explication simple

Les struct tags sont des littéraux de chaîne qui sont écrits après le type d'un champ dans une structure. Ils sont entourés de guillemets inversés (`) et représentent des paires clé:"valeur".

Du point de vue du langage, les balises de structures en Go ne sont que du texte. Le compilateur Go ne les analyse ni ne les vérifie. Leur sens n'apparaît que lorsque vous (ou une bibliothèque) les lisez via le package reflect.

En termes simples : les balises sont des métadonnées que vous attachez aux champs d'une structure. D'autres parties de votre programme peuvent lire ces métadonnées et modifier leur comportement.

À quoi servent les struct tags ? 3 scénarios principaux

1. Sérialisation/Désérialisation (JSON, XML, YAML)

C'est le cas d'utilisation le plus courant et le plus compréhensible. Imaginez que vous ayez une structure Go et que vous souhaitiez la transformer en JSON (ou l'inverse).

type User struct {    ID        int    `json:"id"`    FirstName string `json:"first_name"`    LastName  string `json:"last_name"`    Password  string `json:"-"`}

func main() {    user := User{ID: 1, FirstName: "Иван", LastName: "Петров", Password: "secret"}    jsonData, _ := json.Marshal(user)    fmt.Println(string(jsonData))    // Sortie : {"id":1,"first_name":"Иван","last_name":"Петров"}    // Le mot de passe n'apparaît pas dans le JSON, car la balise json:"-"}

Sans balises, les champs s'appelleraient ID, FirstName, etc., ce qui ne correspond pas au style JSON (camelCase vs snake_case). Les struct tags Golang pour JSON permettent de contrôler :

Le nom du champ en JSON
L'omission des champs vides (omitempty)
L'exclusion d'un champ de la sortie (-)
Les options imbriquées

2. Validation des données

Des bibliothèques populaires comme go-playground/validator utilisent les balises de structures Go pour la validation. Vous écrivez simplement les règles directement dans la structure :

type SignUpRequest struct {    Email    string `validate:"required,email"`    Password string `validate:"required,min=8,max=32"`    Age      int    `validate:"gte=18,lte=120"`}

func validateUser(user SignUpRequest) error {    validate := validator.New()    err := validate.Struct(user)    return err}

C'est incroyablement pratique : les règles de validation se trouvent à côté des données, et non dispersées dans le code. Les struct tags pour la validation rendent le code auto-documenté.

3. Travail avec les bases de données (ORM)

Les bibliothèques ORM (GORM, Ent, SQLBoiler) utilisent activement les struct tags pour ORM. Par exemple, dans GORM :

type Product struct {    gorm.Model    Code  string `gorm:"uniqueIndex;not null"`    Price uint   `gorm:"default:0"`    UserID uint  `gorm:"foreignKey:UserID"`}

Les balises gorm définissent les index, les contraintes, les clés étrangères et d'autres paramètres de table. Cela évite d'avoir à écrire des migrations séparées.