Go Academy · Leçon

Slices : listes dynamiques

make, append, copy, len et cap

Slices : listes dynamiques est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 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 tranche ?

Une tranche est une vue de taille dynamique sur un tableau sous-jacent. Elle comporte trois composants : un pointeur vers le tableau, une longueur et une capacité.

Les tranches sont des types référence — plusieurs tranches peuvent partager le même tableau sous-jacent
La plupart des opérations de type liste en Go utilisent des tranches plutôt que des tableaux

Littéraux de tranche et make

Créez des tranches avec un littéral ou make :

package main
import "fmt"

func main() {
    nums := []int{1, 2, 3, 4, 5}      // literal
    strs := make([]string, 3)          // len=3, cap=3, zero values
    buf  := make([]byte, 0, 64)        // len=0, cap=64
    fmt.Println(nums, strs, len(buf), cap(buf))
}

len et cap

len renvoie le nombre d’éléments actuellement présents dans la tranche. cap renvoie la capacité du tableau sous-jacent à partir du pointeur de début de la tranche.

package main
import "fmt"

func main() {
    s := make([]int, 3, 8)
    fmt.Println(len(s)) // 3
    fmt.Println(cap(s)) // 8
}

append : agrandir une tranche

append ajoute des éléments à une tranche, en allouant un nouveau tableau sous-jacent lorsque la capacité est dépassée :

package main
import "fmt"

func main() {
    s := []int{1, 2, 3}
    s = append(s, 4, 5)
    s = append(s, []int{6, 7, 8}...)
    fmt.Println(s) // [1 2 3 4 5 6 7 8]
}

Découper une tranche

Utilisez la syntaxe [low:high] pour créer une sous-tranche (qui partage le tableau sous-jacent) :

package main
import "fmt"

func main() {
    a := []int{0, 1, 2, 3, 4, 5}
    b := a[1:4]   // [1 2 3]
    c := a[:3]    // [0 1 2]
    d := a[3:]    // [3 4 5]
    fmt.Println(b, c, d)
}

copy : tranches indépendantes

copy copie des éléments entre des tranches et renvoie le nombre d’éléments copiés. La destination et la source ne partagent pas la mémoire :

package main
import "fmt"

func main() {
    src := []int{1, 2, 3}
    dst := make([]int, len(src))
    n := copy(dst, src)
    dst[0] = 99
    fmt.Println(src, dst, n) // [1 2 3] [99 2 3] 3
}

Tranche nil ou tranche vide

Une tranche nil n’a pas de tableau sous-jacent. Une tranche vide possède un tableau sous-jacent, mais sa longueur vaut 0. Toutes deux ont len == 0 :

package main
import "fmt"

func main() {
    var nilSlice []int
    emptySlice  := []int{}
    fmt.Println(nilSlice  == nil) // true
    fmt.Println(emptySlice == nil) // false
    fmt.Println(len(nilSlice), len(emptySlice)) // 0 0
    nilSlice = append(nilSlice, 1) // safe!
}

Supprimer un élément

Go ne possède aucune fonction intégrée delete pour les tranches. L’approche idiomatique utilise append :

package main
import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    i := 2 // delete index 2
    s = append(s[:i], s[i+1:]...)
    fmt.Println(s) // [1 2 4 5]
}

Insérer un élément

Insérez à la position i en combinant append et le découpage en tranches :

package main
import "fmt"

func main() {
    s := []int{1, 2, 4, 5}
    i := 2
    s = append(s[:i+1], s[i:]...)
    s[i] = 3
    fmt.Println(s) // [1 2 3 4 5]
}

Piège des tranches : tableau sous-jacent partagé

Les sous-tranches partagent le tableau sous-jacent — modifier l’une modifie l’autre jusqu’à ce qu’une réallocation ait lieu :

package main
import "fmt"

func main() {
    a := []int{1, 2, 3, 4}
    b := a[:2]   // shares backing array
    b[0] = 99
    fmt.Println(a) // [99 2 3 4] — a is changed!
}

Vérification rapide

Que renvoie append ?

Récapitulatif : tranches

Points essentiels :

Les tranches = pointeur + len + cap ; elles encapsulent des tableaux
Utilisez make pour préallouer la capacité
Affectez toujours le résultat de append
copy crée des tranches indépendantes
Tenez compte des tableaux sous-jacents partagés par les sous-tranches

Exercice pratique

Créez une tranche de 5 entiers avec make, ajoutez trois valeurs, puis copiez-la dans une nouvelle tranche et modifiez la copie sans modifier l’originale. Affichez les deux.

Questions Fréquemment Posées

La leçon « Slices : listes dynamiques » est-elle gratuite ?

Oui — le texte complet de « Slices : listes dynamiques » 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 « Slices : listes dynamiques » ?

make, append, copy, len et cap 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 2 sur 4.

Combien de temps prend la leçon « Slices : listes dynamiques » ?

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