Comment déterminer le type d'un objet en Go : 5 erreurs fatales de débutant et comment les éviter

Introduction : « Mais quelle est cette bête ? »

Imaginez : vous écrivez en Go une fonction qui accepte interface{}. À l'intérieur de cette fonction, vous voulez comprendre quelles données vous sont parvenues. Un nombre ? Une chaîne ? Ou peut-être une structure personnalisée ? Si vous venez de Python ou JavaScript, où le type peut être déterminé en une ligne (type() ou typeof), alors en Go, une petite surprise vous attend. Go est un langage à typage strict, et il n'est pas possible de « tâter » le type d'un objet aussi simplement.

La question « How to find the type of an object in Go? » sur Stack Overflow a recueilli des dizaines de milliers de vues. Cela signifie que même les développeurs expérimentés se trompent parfois. Dans cet article, nous allons passer en revue les meilleures erreurs que commettent les débutants (et pas seulement) lors de la détermination du type en Go, et montrer comment les éviter. Vous découvrirez reflect.TypeOf, fmt.Sprintf avec %T, type assertion et type switch.

Méthode n°1 : La plus simple — fmt et %T (mais avec un piège)

Le moyen le plus rapide de connaître le type est d'utiliser le package fmt et le format %T. Cela fonctionne, mais beaucoup oublient que fmt n'est pas une baguette magique, mais simplement une enveloppe autour de reflect.

package main\n\nimport "fmt"\n\nfunc main() {\n    var x interface{} = 42\n    fmt.Printf("Type : %T\\n", x) // Type : int\n\n    var s interface{} = "hello"\n    fmt.Printf("Type : %T\\n", s) // Type : string\n}\n

C'est simple, non ? Mais voici l'erreur : %T renvoie une chaîne, pas un type. Vous ne pourrez effectuer aucune opération avec elle, sauf l'afficher. Si vous devez vérifier si un objet est un nombre et faire quelque chose — %T ne vous aidera pas. C'est la première erreur : utiliser %T là où une logique de branchement est nécessaire.

Comment l'éviter

Utilisez %T uniquement pour le débogage ou la sortie de logs. Pour la vérification des types dans le code, utilisez type assertion ou type switch (voir ci-dessous).

Méthode n°2 : Le package reflect — puissant, mais dangereux

Le package reflect est la boîte à outils de la réflexion en Go. La méthode la plus populaire est reflect.TypeOf().

package main\n\nimport (\n    "fmt"\n    "reflect"\n)\n\nfunc main() {\n    var x interface{} = 42\n    t := reflect.TypeOf(x)\n    fmt.Println(t) // int\n    fmt.Println(t.Name()) // int\n    fmt.Println(t.Kind()) // int\n}\n

Cela semble être la solution idéale. Mais ici, les débutants commettent la deuxième erreur : confondre Kind() et Name().

\n
• Name() — renvoie le nom du type (par exemple, int, string, MyStruct).
\n
• Kind() — renvoie la « catégorie » de base (par exemple, int, struct, slice).
\n

Pour les types intégrés, ils coïncident, mais pour les types personnalisés, non. Par exemple, si vous déclarez type MyInt int, alors Name() renverra MyInt, et Kind() renverra int. Si vous ne vérifiez que Kind(), vous risquez de manquer le type personnalisé.

Comment l'éviter

Demandez-vous toujours : « Est-ce que le type exact est important ou seulement la catégorie ? » Si le type exact est nécessaire (par exemple, pour la sérialisation) — utilisez Name(). Si vous avez simplement besoin de comprendre qu'il s'agit d'un nombre — utilisez Kind().

Méthode n°3 : Type Assertion — un classique (et une erreur de panique)

Type assertion (assertion de type) est un moyen d'« extraire » un type spécifique de interface{}. Cela ressemble à ceci :

package main\n\nimport "fmt"\n\nfunc main() {\n    var x interface{} = 42\n    value := x.(int) // nous affirmons que x est un int\n    fmt.Println(value + 10) // 52\n}\n

Quelle est l'erreur ? Si x s'avère