Magie de Go : string → []byte — 3 façons de transformer une chaîne en tableau d'octets

Introduction : pourquoi la question "How to assign string to bytes array" est-elle si populaire ?

Si vous avez déjà programmé en Go (Golang) et avez eu besoin de transformer une chaîne ordinaire en tableau d'octets ([]byte), vous n'êtes pas seul. La question "How to assign string to bytes array" sur Stack Overflow recueille des dizaines de milliers de vues. Cela semble simple, non ? Il suffit de prendre et d'assigner. Mais Go est un langage à typage strict, et on ne peut pas simplement assigner une chaîne à une slice d'octets. Il faut connaître les bonnes techniques.

Dans cet article, nous allons examiner la conversion de string en bytes array en Go. Je vais vous montrer trois approches principales : de la plus simple à la plus rapide, mais dangereuse. Vous apprendrez quelle méthode choisir en fonction de la tâche, et vous ne serez plus jamais confus face à ces conversions.

C'est parti !

Un peu de théorie : pourquoi une chaîne n'est-elle pas un tableau d'octets ?

Avant de plonger dans le code, comprenons pourquoi Go distingue ces deux types. Cette connaissance vous évitera des dizaines de bugs.

\n
• string en Go est une séquence immuable (immutable) d'octets. Vous ne pouvez pas modifier un caractère d'une chaîne par index. La chaîne est toujours stockée comme un bloc mémoire en lecture seule.
\n
• []byte est une slice d'octets mutable (mutable). Vous pouvez modifier son contenu, ajouter de nouveaux éléments, etc.
\n

C'est précisément à cause de cette différence d'"immuabilité" que Go exige une conversion explicite. Si le compilateur permettait simplement d'assigner une chaîne à un tableau d'octets, vous pourriez accidentellement modifier les données "protégées" de la chaîne. Par conséquent, assign string to bytes array nécessite toujours une action consciente de votre part.

Approche n°1 : Conversion de type explicite (La plus simple)

C'est la première méthode qui vient à l'esprit de tout débutant. Et elle fonctionne !

package main\n\nimport "fmt"\n\nfunc main() {\n    myString := "Bonjour, Go!"\n    myBytes := []byte(myString)\n\n    fmt.Println(myBytes) // [208 159 209 128 ...] — octets en UTF-8\n    fmt.Println(string(myBytes)) // Retour inverse : "Bonjour, Go!"\n}\n

Avantages :

\n
• Extrêmement simple et lisible.
\n
• Méthode standard, compréhensible par tout développeur Go.
\n

Inconvénients :

\n
• Crée une nouvelle copie des données en mémoire. Si la chaîne est très volumineuse (par exemple, 10 Mo), cela peut être coûteux en mémoire et en temps.
\n
• Ne convient pas aux systèmes à haute charge où chaque nanoseconde compte.
\n

Quand l'utiliser : Dans 90 % des cas. Pour les applications classiques, les services web et les scripts, c'est amplement suffisant. N'optimisez pas là où ce n'est pas nécessaire.

Approche n°2 : Utilisation de copy() (Contrôlée)

Parfois, vous avez déjà un tableau d'octets pré-alloué et vous souhaitez le remplir avec les données d'une chaîne. C'est là que la fonction copy vient à la rescousse.

package main\n\nimport "fmt"\n\nfunc main() {\n    myString := "Go est génial"\n    \n    // Créer une slice d'octets de la longueur nécessaire\n    myBytes := make([]byte, len(myString))\n    \n    // Copier les données de la chaîne dans la slice\n    n := copy(myBytes, myString)\n    \n    fmt.Printf("Octets copiés : %d\\n", n) // 13\n    fmt.Println(string(myBytes)) // "Go est génial"\n}\n

Notez que copy ne copie que le nombre d'octets qui tient dans la slice cible. Si la slice cible est plus courte que la chaîne, seule sa longueur sera copiée. C'est plus sûr que la conversion explicite si vous n'êtes pas sûr de la taille.

Avantages :

\n
• Contrôle total du processus de copie.
\n
• Sécurité : vous ne dépassez pas les limites du tableau.
\n
• Peut être utilisé pour une copie partielle (sous-chaîne).
\n

Inconvénients :

\n
• Nécessite une allocation mémoire préalable (make).
\n
• Crée toujours une copie des données.