Go
Tranches

Introduction

Syntaxe

• slice: = make ([] type, len, cap) // crée une nouvelle tranche
• slice = ajouter (tranche, élément) // ajouter un élément à une tranche
• slice = append (tranche, éléments ...) // ajoute une tranche d'éléments à une tranche
• len: = len (slice) // obtient la longueur d'une tranche
• cap: = cap (tranche) // obtient la capacité d'une tranche
• elNum: = copy (dst, slice) // copie le contenu d'une tranche sur une autre tranche

Aider à trancher

slice = append(slice, "hello", "world")

Ajouter deux tranches ensemble

slice1 := []string{"!"}
slice2 := []string{"Hello", "world"}
slice  := append(slice1, slice2...)

Courir dans le terrain de jeu Go

Suppression d'éléments / tranches "Slicing"

Si vous devez supprimer un ou plusieurs éléments d'une tranche ou si vous devez travailler avec une sous-tranche d'un autre existant; vous pouvez utiliser la méthode suivante.

Les exemples suivants utilisent slice of int, mais cela fonctionne avec tous les types de tranche.

Donc, pour cela, nous avons besoin d'une tranche, à partir de laquelle nous allons supprimer certains éléments:

slice := []int{1, 2, 3, 4, 5, 6} 
// > [1 2 3 4 5 6]

Nous avons également besoin des index d'éléments à supprimer:

// index of first element to remove (corresponding to the '3' in the slice)
var first = 2

// index of last element to remove (corresponding to the '5' in the slice)
var last = 4 

Et nous pouvons "découper" la tranche en supprimant les éléments indésirables:

// keeping elements from start to 'first element to remove' (not keeping first to remove), 
// removing elements from 'first element to remove' to 'last element to remove'
// and keeping all others elements to the end of the slice
newSlice1 := append(slice[:first], slice[last+1:]...)
// > [1 2 6]

// you can do using directly numbers instead of variables
newSlice2 := append(slice[:2], slice[5:]...)
// > [1 2 6]

// Another way to do the same
newSlice3 := slice[:first + copy(slice[first:], slice[last+1:])]
// > [1 2 6]

// same that newSlice3 with hard coded indexes (without use of variables)
newSlice4 := slice[:2 + copy(slice[2:], slice[5:])]
// > [1 2 6]

Pour supprimer un seul élément, il suffit de mettre l'index de cet élément en tant que premier ET en tant que dernier index à supprimer, comme cela:

var indexToRemove = 3
newSlice5 := append(slice[:indexToRemove], slice[indexToRemove+1:]...)
// > [1 2 3 5 6]

// hard-coded version:
newSlice5 := append(slice[:3], slice[4:]...)
// > [1 2 3 5 6]

Et vous pouvez également supprimer des éléments au début de la tranche:

newSlice6 := append(slice[:0], slice[last+1:]...)
// > [6]

// That can be simplified into
newSlice6 := slice[last+1:]
// > [6]

Vous pouvez également supprimer certains éléments de la fin de la tranche:

newSlice7 := append(slice[:first], slice[first+1:len(slice)-1]...)
// > [1 2]

// That can be simplified into
newSlice7 := slice[:first]
// > [1 2]

Si la nouvelle tranche doit contenir exactement les mêmes éléments que le premier, vous pouvez utiliser la même chose mais avec last := first-1 .
(Cela peut être utile si vos index sont calculés précédemment)

Longueur et capacité

Les tranches ont à la fois la longueur et la capacité. La longueur d'une tranche correspond au nombre d'éléments présents dans la tranche, tandis que la capacité correspond au nombre d'éléments que la tranche peut contenir avant de devoir être réallouée.

Lors de la création d'une tranche à l'aide de la fonction make() intégrée, vous pouvez spécifier sa longueur et éventuellement sa capacité. Si la capacité n'est pas explicitement spécifiée, il s'agira de la longueur spécifiée.

var s = make([]int, 3, 5) // length 3, capacity 5

Vous pouvez vérifier la longueur d'une tranche avec la fonction len() intégrée:

var n = len(s) // n == 3

Vous pouvez vérifier la capacité avec la fonction cap() intégrée:

var c = cap(s) // c == 5

Les éléments créés par make() sont définis sur la valeur zéro pour le type d'élément de la tranche:

for idx, val := range s {
    fmt.Println(idx, val)
}
// output:
// 0 0
// 1 0
// 2 0

Exécutez-le sur play.golang.org

Vous ne pouvez pas accéder aux éléments au-delà de la longueur d'une tranche, même si l'index est dans la capacité:

var x = s[3] // panic: runtime error: index out of range

Cependant, tant que la capacité dépasse la longueur, vous pouvez ajouter de nouveaux éléments sans réallouer:

var t = []int{3, 4}
s = append(s, t) // s is now []int{0, 0, 0, 3, 4}
n = len(s) // n == 5
c = cap(s) // c == 5

Si vous ajoutez à une tranche qui n'a pas la capacité d'accepter les nouveaux éléments, la baie sous-jacente sera réallouée pour vous avec une capacité suffisante:

var u = []int{5, 6}
s = append(s, u) // s is now []int{0, 0, 0, 3, 4, 5, 6}
n = len(s) // n == 7
c = cap(s) // c > 5

Il est donc généralement recommandé d’allouer une capacité suffisante lors de la première création d’une tranche, si vous savez combien d’espace vous aurez besoin pour éviter des réaffectations inutiles.

Copier le contenu d'une tranche vers une autre tranche

Si vous souhaitez copier le contenu d'une tranche dans une tranche initialement vide, vous pouvez suivre les étapes suivantes pour y parvenir.

1. Créez la tranche source:

var sourceSlice []interface{} = []interface{}{"Hello",5.10,"World",true}

2. Créez la tranche de destination avec:

• Longueur = Longueur de sourceSlice

var destinationSlice []interface{} = make([]interface{},len(sourceSlice))

3. Maintenant que le tableau sous-jacent de la tranche de destination est suffisamment grand pour accueillir tous les éléments de la tranche source, nous pouvons procéder à la copie des éléments en utilisant la copy intégrée:

copy(destinationSlice,sourceSlice)

Créer des tranches

Les tranches sont la façon typique dont les programmeurs vont stocker les listes de données.

Pour déclarer une variable slice, utilisez la syntaxe []Type .

var a []int

Pour déclarer et initialiser une variable de tranche dans une ligne, utilisez la syntaxe []Type{values} .

var a []int = []int{3, 1, 4, 1, 5, 9}

Une autre façon d’initialiser une tranche consiste à make fonction make . Il y a trois arguments: le Type de la tranche (ou la carte ), la length et la capacity .

a := make([]int, 0, 5)

Vous pouvez ajouter des éléments à votre nouvelle tranche en utilisant append .

a = append(a, 5)

Vérifiez le nombre d'éléments dans votre tranche en utilisant len .

length := len(a)

Vérifiez la capacité de votre tranche à l'aide du cap . La capacité correspond au nombre d'éléments actuellement alloués à la mémoire pour la tranche. Vous pouvez toujours ajouter à une tranche à sa capacité car Go créera automatiquement une tranche plus grande pour vous.

capacity := cap(a)

Vous pouvez accéder aux éléments d'une tranche en utilisant une syntaxe d'indexation classique.

a[0]  // Gets the first member of `a`

Vous pouvez également utiliser une boucle for sur des tranches avec range . La première variable est l'index dans le tableau spécifié et la deuxième variable est la valeur de l'index.

for index, value := range a {
    fmt.Println("Index: " + index + " Value: " + value)  // Prints "Index: 0 Value: 5" (and continues until end of slice)
}

Aller au terrain de jeu

Filtrer une tranche

Pour filtrer une tranche sans allouer un nouveau tableau sous-jacent:

// Our base slice
slice := []int{ 1, 2, 3, 4 }
// Create a zero-length slice with the same underlying array
tmp := slice[:0]

for _, v := range slice {
  if v % 2 == 0 {
    // Append desired values to slice
    tmp = append(tmp, v)
  }
}

// (Optional) Reassign the slice
slice = tmp // [2, 4]

Valeur zéro de la tranche

La valeur zéro de la tranche est nil , ce qui a la longueur et la capacité 0 . Une tranche nil n'a pas de tableau sous-jacent. Mais il y a aussi des tranches non nul de longueur et de la capacité 0 , comme []int{} ou make([]int, 5)[5:] .

Tout type ayant des valeurs nulles peut être converti en tranche nil :

s = []int(nil)

Pour tester si une tranche est vide, utilisez:

if len(s) == 0　{
    fmt.Ptintf("s is empty.")
}