Go Academy · Leçon

Runes et octets

Comprendre le fonctionnement interne des chaînes Go

Runes et octets est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Qu’est-ce qu’une chaîne Go ?

Dans Go, une string est une séquence immuable d’octets. Ces octets contiennent généralement du texte encodé en UTF-8, mais Go ne l’impose jamais.

Vous ne pouvez pas modifier une chaîne sur place.
Sa len compte les octets, et non les caractères.

package main

import "fmt"

func main() {
    s := "Go"
    fmt.Println(s)
    fmt.Println(len(s))
}

Les octets en coulisses

L’indexation d’une chaîne avec s[i] renvoie un seul octet (de type byte, alias de uint8).

Pour du texte ASCII simple, chaque caractère occupe exactement un octet.

package main

import "fmt"

func main() {
    s := "ABC"
    fmt.Println(s[0])
    fmt.Println(s[1])
    fmt.Println(s[2])
}

Un octet est un nombre

Comme un octet n’est qu’un nombre, l’affichage de s[0] montre 65 (le code ASCII de A), et non la lettre.

Pour voir le caractère, reconvertissez l’octet en chaîne.

package main

import "fmt"

func main() {
    s := "ABC"
    fmt.Println(string(s[0]))
}

Qu’est-ce qu’un rune ?

Un rune est un alias de int32 et représente un seul point de code Unicode.

Un rune peut occuper plusieurs octets lorsqu’il est encodé en UTF-8.
Utilisez des runes lorsque vous vous intéressez aux caractères plutôt qu’aux octets bruts.

package main

import "fmt"

func main() {
    var r rune = 'A'
    fmt.Println(r)
    fmt.Println(string(r))
}

Caractères multioctets

Les caractères non ASCII occupent plusieurs octets en UTF-8. Une chaîne comme "héllo" contient plus d’octets que de lettres.

Remarquez que len indique le nombre d’octets, qui est supérieur à la longueur visible.

package main

import "fmt"

func main() {
    s := "héllo"
    fmt.Println(len(s))
}

Parcourir une chaîne

Une boucle for range sur une chaîne décode automatiquement l’UTF-8. Chaque itération fournit :

l’index en octets où commence le rune,
le rune lui-même.

package main

import "fmt"

func main() {
    for i, r := range "héllo" {
        fmt.Println(i, string(r))
    }
}

Compter correctement les caractères

Pour compter les caractères plutôt que les octets, convertissez la chaîne en []rune et récupérez sa longueur.

Vous obtenez ainsi le nombre de points de code.

package main

import "fmt"

func main() {
    s := "héllo"
    runes := []rune(s)
    fmt.Println(len(runes))
}

Indexer par rune

Une fois que vous disposez d’un []rune, vous pouvez l’indexer pour obtenir de manière fiable le énième caractère, même dans un texte multioctet.

package main

import "fmt"

func main() {
    runes := []rune("héllo")
    fmt.Println(string(runes[1]))
}

Convertir des chaînes en octets et inversement

Vous pouvez convertir librement une chaîne en []byte et inversement.

[]byte(s) fournit les octets bruts.
string(b) reconstruit le texte.

package main

import "fmt"

func main() {
    b := []byte("Go")
    fmt.Println(b)
    fmt.Println(string(b))
}

Construire une chaîne à partir de runes

Une tranche de runes se reconvertit en chaîne de la même manière. C’est pratique après avoir modifié les caractères individuellement.

package main

import "fmt"

func main() {
    runes := []rune{'G', 'o', '!'}
    fmt.Println(string(runes))
}

Résumé : octets et runes

Modèle mental rapide :

byte = un octet brut (uint8), len(s) les compte.
rune = un point de code Unicode (int32), range les fournit.
Utilisez []rune pour compter ou indexer les caractères.

package main

import "fmt"

func main() {
    s := "café"
    fmt.Println(len(s))
    fmt.Println(len([]rune(s)))
}

Vérification rapide

Vérifiez votre compréhension des runes et des octets.

Récapitulatif : runes et octets

Vous avez appris que les chaînes Go sont des séquences d’octets immuables, généralement encodées en UTF-8.

byte est un octet brut ; len compte les octets.
rune est un point de code Unicode ; range les décode.
Convertissez avec []byte(s) et []rune(s) pour travailler au niveau approprié.

package main

import "fmt"

func main() {
    s := "Go語"
    fmt.Println("bytes:", len(s))
    fmt.Println("runes:", len([]rune(s)))
}

Questions Fréquemment Posées

La leçon « Runes et octets » est-elle gratuite ?

Oui — le texte complet de « Runes et octets » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Runes et octets » ?

Comprendre le fonctionnement interne des chaînes Go Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Runes et octets » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy