Slices : l'épine dorsale du Go !

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

Qu’est-ce qu’une tranche ? ?

Dans Go, les tranches sont un type qui vous permet de travailler avec des listes d'éléments (comme un tableau), mais elles sont dynamiques, ce qui signifie qu'elles peuvent s'agrandir et se réduire selon les besoins. Pas besoin de spécifier une longueur fixe à l’avance comme vous le feriez avec un tableau. Ils sont soutenus par des baies sous le capot, mais vous obtenez bien plus de contrôle. Considérez-les comme les frères et sœurs des baies, plus cool et plus flexibles.

Ainsi, 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 l’agrandissant ou en la réduisant – et c’est aussi simple que de trancher un morceau de gâteau. ?

Créer une tranche ?
Créer 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é à une chaîne vide
Avec make, vous demandez à Go de 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 mémoire. ?

Longueur et capacité ?

Deux concepts cruciaux dans les 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'elle peut contenir avant de devoir la 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'aurez donc pas à vous soucier d'atteindre un plafond.

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

motif
Ajout aux tranches : la magie intégrée de Go ?✨
Ajouter des éléments à une tranche est aussi simple que bonjour avec la fonction d'ajout de Go. Vous pouvez ajouter un ou plusieurs éléments à la fois, et Go gérera tout le redimensionnement et la 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 fonction de redimensionnement automatique rend les tranches très pratiques, surtout si vous ne savez pas quelle sera la taille de votre liste.

Trancher une tranche ??

Slicing in Go est en fait l'endroit où les choses deviennent vraiment amusantes. Vous pouvez créer une "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.

Cette sous-tranche partage toujours le même tableau sous-jacent avec la tranche d'origine, donc les modifications apportées à l'une 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 la copie pour créer une version indépendante de la tranche :

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

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

Modification de la capacité avec ajout ?

Si vous avez besoin d'une tranche plus grande que sa capacité actuelle, l'ajout créera automatiquement un nouveau tableau plus grand en arrière-plan et copiera le tout. C’est incroyablement efficace et c’est en grande partie ce qui rend les tranches géniales. Lorsque append crée une nouvelle baie, il alloue le double de la capacité précédente, ce qui vous donne la possibilité de vous développer !

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

Voici un petit secret de Go : même si le découpage est super puissant, il peut parfois entraîner des fuites de mémoire si vous n'y faites pas attention. Étant donné que les tranches font référence au même tableau sous-jacent, le tableau peut rester en mémoire même si vous n'en utilisez qu'une petite partie.

Par exemple :

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

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 contient uniquement les données dont vous avez besoin, libérant ainsi le reste de la mémoire.

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

Tranches multidimensionnelles ??

Besoin de plus d’une dimension ? Vous pouvez également créer des tranches multidimensionnelles ! Cela peut être pratique pour des éléments comme des grilles ou des tableaux. Déclarez simplement une tranche de tranches :

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]

Chaque « rangée » est une tranche en soi, vous pouvez donc les cultiver indépendamment si nécessaire.

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]

La tranche nulle ?

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 telles que l'ajout sans paniquer.

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

Lorsque vous ajoutez une tranche nulle, Go l'initialise automatiquement pour vous. C’est une bonne astuce à avoir dans votre manche.

Pièges et bonnes pratiques ?
Surveillez la mémoire partagée : n'oubliez pas que les tranches partagent la mémoire avec le tableau d'origine. C'est excellent pour les performances, mais soyez prudent lorsque vous découpez des parties d'un grand tableau pour éviter de conserver des données inutiles en mémoire.

Méfiez-vous du redimensionnement : lorsque vous ajoutez, Go devra peut-être créer un nouveau tableau sous-jacent si la capacité actuelle est pleine. Cela peut être plus efficace que d'effectuer de nombreux petits redimensionnements, mais soyez conscient de la surcharge si vous traitez 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 compliqué et moins efficace. Faites confiance aux mécanismes de tranche de Go pour faire la bonne chose dans la plupart des cas.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!