Très bien, plongeons dans l'une des fonctionnalités les plus polyvalentes et les plus essentielles de Go - des tranches. Si vous venez d'une autre langue, vous pourriez considérer les tranches comme similaires aux tableaux. Et, oui, ils ont des similitudes, mais les tranches apportent beaucoup plus de puissance, de flexibilité et de magie spécifique à la table! ?

Qu'est-ce qu'une tranche de toute façon? ?

Dans Go, les tranches sont un type qui vous permet de travailler avec des listes d'éléments (comme un tableau), mais ils sont dynamiques, ce qui signifie qu'ils peuvent grandir et rétrécir au besoin. Pas besoin de spécifier une longueur fixe à l'avance comme vous le feriez avec un tableau. Ils sont soutenus par des tableaux sous le capot, mais vous obtenez tellement plus de contrôle. Considérez-les comme des frères et sœurs plus frais et plus flexibles des tableaux.

Donc, une tranche dans Go est en fait une "fenêtre" sur un tableau sous-jacent. Vous pouvez modifier la taille de cette fenêtre en le poussant ou en le rétrécissant - et il est aussi lisse que de trancher un morceau de gâteau. ?

Création d'une tranche?
La création d'une tranche est assez simple:

// Using a literal
numbers := []int{1, 2, 3, 4, 5}

// Using the make function
sliceOfStrings := make([]string, 5) // a slice of 5 strings, each 

initialisé en une chaîne vide
Avec Make, vous dites à créer une tranche d'une certaine longueur mais soutenue par un tableau qu'il gère pour vous. Vous n'avez donc pas à vous soucier des détails de l'allocation de la mémoire. ?

Longueur et capacité?

Deux concepts cruciaux en tranches sont la longueur et la capacité. La longueur est le nombre d'éléments actuellement dans la tranche, tandis que la capacité est le nombre total d'éléments qu'il peut contenir avant de redimensionner.

numbers := []int{1, 2, 3}
fmt.Println(len(numbers)) // 3
fmt.Println(cap(numbers)) // 3 (same as length here)

Lorsque vous commencez à ajouter des éléments, GO doublera la capacité chaque fois qu'il se remplit, vous n'avez donc pas à vous soucier de frapper un plafond.

numbers = append(numbers, 4)
fmt.Println(len(numbers)) // 4
fmt.Println(cap(numbers)) // probably 6 now, depending on Go’s growth 

modèle
Ajout de tranches: go’s intégrée de la magie? ✨
L'ajout d'éléments à une tranche est aussi simple que la tarte avec la fonction d'ajout de Go. Vous pouvez ajouter un ou plusieurs éléments à la fois, et GO géra tous les trucs de redimensionnement et de mémoire pour vous.

numbers := []int{1, 2, 3}
numbers = append(numbers, 4, 5, 6) // Adding multiple elements at once
fmt.Println(numbers) // [1 2 3 4 5 6]

Cette fonctionnalité de révision automatique rend les tranches super à portée de main, surtout si vous ne savez pas à quel point votre liste sera grande.

Trancher une tranche ??

Sinsifier en go est en fait là où les choses deviennent vraiment amusantes. Vous pouvez créer un "sous-tranche" d'une tranche existante sans copier les éléments.

numbers := []int{10, 20, 30, 40, 50}
subSlice := numbers[1:4] // Just takes a "slice" of the original slice
fmt.Println(subSlice) // [20 30 40]

Dans les nombres [1: 4], le premier index (1) est inclusif, et le dernier index (4) est exclusif. Vous vous retrouvez avec les éléments aux positions 1, 2 et 3, mais pas 4.

Ce sous-flux partage toujours le même tableau sous-jacent avec la tranche d'origine, donc les modifications à l'un affecteront l'autre:

subSlice[0] = 25
fmt.Println(numbers) // [10 25 30 40 50]
fmt.Println(subSlice) // [25 30 40]

Pour éviter toute modification involontaire, vous pouvez utiliser Copy pour créer une version indépendante de la tranche:

newSlice := make([]int, len(subSlice))
copy(newSlice, subSlice)

Modification de la capacité avec ajouter?

Si vous avez besoin d'une tranche supérieure à sa capacité actuelle, ajoutez-vous automatiquement un nouveau tableau plus grand en arrière-plan et copiera tout. C'est incroyablement efficace et une grande partie de ce qui rend les tranches géniales. Lorsque l'ajout crée un nouveau tableau, il alloue le double de la capacité précédente - vous donnant de la place pour grandir!

Déliement et efficacité de la mémoire?

Voici un peu de Secret: Bien que le tranchage soit super puissant, cela peut parfois conduire à des fuites de mémoire si vous ne faites pas attention. Étant donné que les tranches se réfèrent au même tableau sous-jacent, le tableau peut rester en mémoire même si vous n'utilisez qu'une petite partie.

Par exemple:

bigSlice := make([]int, 1_000_000) // A big slice with a lot of elements
smallSlice := bigSlice[:10]        // A tiny slice from it

// Now `smallSlice` only uses 10 elements, but the underlying array with
// 1,000,000 elements is still in memory! ?

Dans des cas comme celui-ci, il est préférable d'utiliser la copie pour créer une tranche véritablement indépendante qui ne contient que les données dont vous avez besoin, libérant le reste de la mémoire.

miniSlice := make([]int, len(smallSlice))
copy(miniSlice, smallSlice) // Now `miniSlice` is completely separate!

Tranches multidimensionnelles ??

a besoin de plus d'une dimension? Vous pouvez également créer des tranches multidimensionnelles! Cela peut être pratique pour des choses comme des grilles ou des tables. Déclarez simplement une tranche de tranches:

matrix := [][]int{
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
}
fmt.Println(matrix) // [[1 2 3] [4 5 6] [7 8 9]]

Chaque "ligne" est une tranche en soi, vous pouvez donc les développer indépendamment si nécessaire.

matrix[0] = append(matrix[0], 10)
fmt.Println(matrix) // [[1 2 3 10] [4 5 6] [7 8 9]]

La tranche nil?

Une tranche nulle est simplement une tranche qui n'a pas encore été initialisée. Il a une longueur et une capacité nulles mais peut toujours être utilisé avec des fonctions comme ajouter sans paniquer.

var nilSlice []int // Declared, but not initialized
fmt.Println(len(nilSlice)) // 0
fmt.Println(cap(nilSlice)) // 0

Lorsque vous ajoutez une tranche nulle, allez simplement l'initialiser pour vous automatiquement. C'est une astuce intéressante pour avoir dans votre manche.

Pièges et meilleures pratiques?
Surveillez la mémoire partagée: rappelez-vous, les tranches partagent la mémoire avec le tableau d'origine. C'est idéal pour les performances, mais soyez prudent lorsque vous coupez des parties d'un grand tableau pour éviter de garder les données inutiles en mémoire.

Méfiez-vous de la redimensionnement: Lorsque vous ajoutez, GO peut avoir besoin de créer un nouveau tableau sous-jacent si la capacité actuelle est pleine. Cela peut être plus efficace que de faire de nombreuses petites redimensions, mais soyez conscient des frais généraux si vous avez affaire à de grands ensembles de données.

Évitez l'optimisation prématurée: GO gère beaucoup d'allocation de mémoire et de redimensionnement automatiquement avec des tranches. Souvent, essayer de microgérer ces détails peut finir par rendre votre code plus désordonné et moins efficace. Trust Go's Slice Mechanics pour faire la bonne chose dans la plupart des cas.