Slice (Slice) du langage Go

En langage Go, le slice est plusTableauPlus puissant, flexible, pratique et léger, c'est une structure de données légère. Slice est une séquence de longueur variable, utilisée pour stocker des éléments du même type, et ne permet pas de stocker des éléments de types différents dans le même slice. Comme un tableau avec des indices et une longueur, mais la taille du slice peut être ajustée, contrairement aux tableaux qui ont une taille fixe. En interne, les slices et les tableaux sont connectés, le slice étant une référence à l'array de base. Il est permis de stocker des éléments répétés dans le slice.La première position d'index dans une tranchée est toujours 0, et la dernière position d'index sera (la longueur de la tranchée - 1).

Déclaration de la tranchée

La déclaration de la tranchée est comme pour un tableau, mais sans la taille de la tranchée. Par conséquent, elle peut croître ou diminuer selon les besoins.

Syntaxe :

[]T
ou
[]T{}
ou
[]T{value1, value2, value3, ...value n}

Ici, T est le type de l'élément. Par exemple :

var my_slice[]int

Composition de la tranchée

Une tranchée contient trois composants :

• Pointeur :Le pointeur est utilisé pour pointer vers le premier élément du tableau accessible via la tranchée. Ici, l'élément pointé n'a pas besoin d'être le premier élément du tableau.

• Longueur :La longueur est le nombre total d'éléments existants dans le tableau.

• Capacité :La capacité représente la taille maximale extensible.

Discussionons tous ces composants à l'aide d'exemples :

//Tranchée
package　main
import　"fmt"
func　main()　{
　　　　//创建一个数组
　　　　arr　:=　[7string{"C'est", "le", "Golang", "de base", "tutoriel", "en ligne", "fr.oldtoolbag.com"
　　　　//Afficher le tableau
　　　　fmt.Println("Tableau:", arr)
　　　　//Création de la coupe
　　　　myslice := arr[1:6]
　　　　//Afficher la tranchée
　　　　fmt.Println("Tranchée:", myslice)
　　　　//Afficher la longueur de la tranchée
　　　　fmt.Printf("Longueur de la tranchée: %d", len(myslice))
　　　　//Afficher la capacité de la tranchée
　　　　fmt.Printf("\nCapacité de la tranchée: %d", cap(myslice))
}

Sortie :

Tableau: [C'est le tutoriel en ligne de base de Golang en ligne fr.oldtoolbag.com]
Tranchée: [C'est le tutoriel en ligne de base de Golang]
Longueur de la tranchée :　5
Capacité de la tranchée :　6

Explication de l'utilisation :Dans cet exemple, nous créons une tranchée à partir d'un tableau donné. Ici, le pointeur de la tranchée pointe sur l'index1parce que le bas de la tranchée est fixé à1donc elle commence à accéder aux éléments à partir de l'index1La longueur de la tranchée est5représente le nombre total d'éléments dans la tranchée5et la tranchée6La capacité représente le nombre maximum d'éléments qu'elle peut stocker6d'éléments.

Comment créer et initialiser une tranchée ?

En langage Go, vous pouvez créer et initialiser une tranchée de la manière suivante :

• Utiliser une tranchée littérale :Vous pouvezUtiliser une tranchée littéraleCréer une tranchée. La création de la tranchée littérale est comme pour une liste littérale, mais avec une différence, c'est qu'il n'est pas permis de spécifier la taille de la tranchée dans les crochets[]. Voici un exemple, le côté droit de l'expression est une tranchée littérale.

  var my_slice_1　= []string{"w3codeboxs "for", "w3codeboxs "}

  Attention :切记，当您使用字符串文字创建切片时，它首先创建一个数组，然后返回对其的切片引用。

  Exemple

  //　使用切片创建切片字面量
  package　main
  import　"fmt"
  func　main()　{
  　　　　//使用var关键字,创建切片
  　　　　var my_slice_1　= []string{"w3codeboxs "for", "w3codeboxs "}
  　　　　fmt.Println("My Slice　1:", my_slice_1)
  　　　　//Création de la coupe
  　　　　//使用简写声明
  　　　　my_slice_2　:=　[]int{12,　45,　67,　56,　43,　34,　45}
  　　　　fmt.Println("My Slice　2:", my_slice_2)
  }

  Sortie :

  My Slice　1: [w3codeboxs for w3codeboxs]
  My Slice　2: [12　45　67　56　43　34　45]

• 使用数组：我们已经知道切片是数组的引用，因此您可以根据给定的数组创建切片。要从给定数组创建切片，首先需要指定下限和上限，这意味着slice可以从下限到上限开始获取数组中的元素。它不包括上面从上限开始的元素。如下例所示：

  Syntaxe :

  array_name[low:high]

  此语法将返回一个新切片。

  Attention :下限的默认值为0，上限的默认值为给定数组中存在的元素总数。

• Exemple

  //从数组创建切片
  package　main　
  　　
  import　"fmt"
  　　
  func　main()　{　
  　　
  　　　　//创建一个数组
  　　　　arr　:=　[4]string{"w3codeboxs "for", "w3codeboxs "GFG"}　
  　　
  　　　　//从给定数组创建切片　
  　　　　var my_slice_1　= arr[1:2]　
  　　　　my_slice_2　:= arr[0:]　
  　　　　my_slice_3　:= arr[:2]　
  　　　　my_slice_4　:= arr[:]　
  　　
  　　　　//显示结果
  　　　　fmt.Println("我的数组: "arr)　
  　　　　fmt.Println("My Slice　1: "my_slice_1)　
  　　　　fmt.Println("My Slice　2: "my_slice_2)　
  　　　　fmt.Println("My Slice　3: "my_slice_3)　
  　　　　fmt.Println("My Slice　4: "my_slice_4)　
  }

  Sortie :

  我的数组: [w3codeboxs for w3codeboxs GFG]
  My Slice　1: [for]
  My Slice　2: [w3codeboxs for w3codeboxs GFG]
  My Slice　3: [w3codeboxs for]
  My Slice　4: [w3codeboxs for w3codeboxs GFG]

• 使用已经存在的切片：也可以从给定的切片创建切片。要从给定切片创建切片，首先需要指定下限和上限，这意味着slice可以从给定切片中从下限到上限开始获取元素。它不包括上面从上限开始的元素。如下例所示：

  Syntaxe :

  slice_name[low:high]

  此语法将返回一个新切片。

  Attention :下限的默认值为0，上限的默认值为给定切片中存在的元素总数。

  Exemple

  //从切片创建切片
  package　main
  import　"fmt"
  func　main()　{
  　　　　//Création de la coupe
  　　　　oRignAl_slice := []int{90,　60,　40,　50,　34,　49,　30}
  　　　　//从给定的切片创建切片
  　　　　var my_slice_1　= oRignAl_slice[1:5]
  　　　　my_slice_2　:= oRignAl_slice[0:]
  　　　　my_slice_3　:= oRignAl_slice[:6]
  　　　　my_slice_4　:= oRignAl_slice[:]
  　　　　my_slice_5　:= my_slice_3[2:4]
  　　　　//显示结果
  　　　　fmt.Println("Original slice:", oRignAl_slice)
  　　　　fmt.Println("Nouvelle tranche"　1:", my_slice_1)
  　　　　fmt.Println("Nouvelle tranche"　2:", my_slice_2)
  　　　　fmt.Println("Nouvelle tranche"　3:", my_slice_3)
  　　　　fmt.Println("Nouvelle tranche"　4:", my_slice_4)
  　　　　fmt.Println("Nouvelle tranche"　5:", my_slice_5)
  }

  Sortie :

  Tranche originale: [90　60　40　50　34　49　30]
  Nouvelle tranche　1: [60　40　50　34]
  Nouvelle tranche　2: [90　60　40　50　34　49　30]
  Nouvelle tranche　3: [90　60　40　50　34　49]
  Nouvelle tranche　4: [90　60　40　50　34　49　30]
  Nouvelle tranche　5: [40　50]

• Utiliser la fonction make() :Vous pouvez également utiliser les bibliothèques fournies par goFonction make()Créer une tranche. Cette fonction prend trois paramètres, à savoir le type, la longueur et la capacité. Ici, la valeur de capacité est optionnelle. La taille allouée pour le tableau de base est égale à la capacité donnée et retourne une tranche qui référence le tableau de base. Habituellement, la fonction make() est utilisée pour créer une tranche vide. Ici, la tranche vide est celle qui contient une référence à un tableau vide.

  Syntaxe :

  func make([]T, len, cap) []T

  Exemple

  //Utiliser la fonction make()
  package　main
  import　"fmt"
  func　main()　{
  　　　　//Créer une taille de7du tableau
  　　　　//Couper ce tableau en4
  　　　　//et retourne une référence à la tranche
  　　　　//Utiliser la fonction make()
  　　　　var my_slice_1　= make([]int,　4,　7)
  　　　　fmt.Printf("Slice　1　= %v, \nlength = %d, \ncapacity = %d\n", my_slice_1, len(my_slice_1), cap(my_slice_1))
  　　　　//Créer une autre taille de7du tableau
  　　　　//et retourne une référence à la tranche
  　　　　//Utiliser la fonction make()
  　　　　var my_slice_2　= make([]int,　7)
  　　　　fmt.Printf("Slice　2　= %v, \nlength = %d, \ncapacity = %d\n", my_slice_2, len(my_slice_2), cap(my_slice_2))
  }

  Sortie :

  Slice　1　= [0 0 0 0],　
  length =　4,　
  capacity =　7
  Slice　2　= [0 0 0 0 0 0 0],　
  length =　7,　
  capacity =　7

Comment itérer sur une tranche ?

Vous pouvez parcourir une tranche de la manière suivante :

• Avec une boucle for :C'est la méthode la plus simple pour itérer sur une tranche, comme montré dans les exemples suivants :

  Exemple

  //　Itération de la tranche avec une boucle for
  package　main　
  　　
  import　"fmt"
  　　
  func　main()　{　
  　　
  　　　　//Création de la coupe
  　　　　myslice　:=　[]string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
  　　
  　　　　//Itérer avec une boucle for
  　　　　for e := 0; e < len(myslice); e++　{　
  　　　　　　　　fmt.Println(myslice[e])　
  　　　　}　
  }

  Sortie :

  Ce
  est
  le
  tutorial
  de
  Go
  language

• Dans la boucle for, utiliser la plage :Permet d'utiliser la plage dans la boucle for pour itérer sur les tranches. En utilisant range dans la boucle for, vous pouvez obtenir l'index et la valeur de l'élément, comme montré dans l'exemple :

  Exemple

  //Dans la boucle for, utiliser la plage des tranches
  package　main　
  　　
  import　"fmt"
  　　
  func　main()　{　
  　　
  　　　　//Création de la coupe
  　　　　myslice　:=　[]string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
  　　
  　　　　　　　　//Iterate_a_slice
  　　　　　　　　//Using_range_in_for_loop
  　　　　for index, ele := range myslice {　
  　　　　　　　　fmt.Printf("Index = %d et element = %s\n", index+3, ele)　
  　　　　}　
  }

  Sortie :

  Index =　3　et element = Ce
  Index =　4　et element = est
  Index =　5　et element = le
  Index =　6　et element = tutorial
  Index =　7　et element = de
  Index =　8　et element = Go
  Index =　9　et element = language

• Using_a_blank_identifier_in_the_for_loop:In_the_for_loopIn_the_range_if_you_do_not_want_to_get_the_index_value_of_the_element_then_you_can_use_a_space(_)_as_a_substitute_for_the_index_variable_as_shown_in_the_following_example:
  

  Exemple

  //Using_range_in_for_loop_without_index　
  package　main　
  　　
  import　"fmt"
  　　
  func　main()　{　
  　　
  　　　　//Création de la coupe　
  　　　　myslice　:=　[]string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
  　　
  　　　　　　　　//Iterate_a_slice
  　　　　　　　　//Using_range_in_for_loop
  　　　　　　　　//No_index
  　　　　for　_,　ele　:=　range　myslice　{　
  　　　　　　　　fmt.Printf("Element　=　%s\n", ele)　
  　　　　}　
  }

  Sortie :

  Element　=　This
  Element　=　is
  Element　=　the
  Element　=　tutorial
  Element　=　of
  Element　=　Go
  Element　=　language

Key_points_about_slices

1. Zero_value_slice:In_Go_language_it_is_allowed_to_create_a_zero_slice_that_does_not_contain_any_elements.Therefore_the_capacity_and_length_of_this_slice_are_0.A_nil_slice_does_not_contain_a_reference_to_an_array_as_shown_in_the_following_example:

   Exemple

   package　main　
   　　
   import　"fmt"
   　　
   func　main()　{　
   　　
   　　　　//　Create_a_zero_value_slice
   　　　　var　myslice　[]string　
   　　　　fmt.Printf("Length　=　%d\n", len(myslice))　
   　　　　fmt.Printf("Capacity　=　%d　", cap(myslice))　
   　　
   }

   Sortie :

   Length　=　0
   Capacity　=　0

2. Modification_of_Slice:As_we_already_know_that_slices_are_reference_types_they_can_reference_the_base_array.Therefore_if_we_change_some_elements_in_the_slice_then_the_changes_should_also_happen_in_the_referenced_array.In_other_words_if_you_make_any_changes_to_the_slice_then_the_slice_will Reflect_in_the_array_as_shown_in_the_following_example:

   Exemple

   //How_to_modify_a_slice
   package　main　
   　　
   import　"fmt"
   　　
   func　main()　{　
   　　
   　　　　//Create_a_zero_value_slice
   　　　　arr　:=　[6]int{55,　66,　77,　88,　99,　22}　
   　　　　slc　:=　arr[0:4]　
   　　
   　　　　//Modification_before
   　　
   　　　　fmt.Println("Original_Array:　", arr)　
   　　　　fmt.Println("Original_Slice:　", slc)　
   　　
   　　　　//Modification_after　
   　　　　slc[0]　=　100　
   　　　　slc[1]　=　1000　
   　　　　slc[2]　=　1000　
   　　
   　　　　fmt.Println("\nNew_Array:　", arr)　
   　　　　fmt.Println("New_Slice:　", slc)　
   }

   Sortie :

   Original_Array:　　[55　66　77　88　99　22]
   Original_Slice:　　[55　66　77　88]
   New_Array:　　[100　1000　1000　88　99　22]
   New_Slice:　　[}}100　1000　1000　88]

3. Comparaison des coupes :Dans la coupe, vous ne pouvez utiliser==L'opérateur vérifie si la coupe donnée existe.==Sous l'aide de l'opérateur, comparez deux coupes, une erreur sera lancée, comme dans l'exemple suivant :

   Exemple

   //Jugez si la coupe est nulle
   package　main　
   　　
   import　"fmt"
   　　
   func　main()　{　
   　　
   　　　　//Création de la coupe
   　　　　s1　:=　[]int{12,　34,　56}　
   　　　　var　s2　[]int
   　　
   　　　　　　　　//Si vous essayez d'exécuter ce commentaire
   　　　　　　　　//Le compilateur de code donnera une erreur
   　　　　/*s3:=　[]int{23,　45,　66}　
   　　　　　　fmt.Println(s1==s3)　
   　　　　*/
   　　
   　　　　//Vérifiez si la coupe donnée est nil
   　　　　fmt.Println(s1　==　nil)　
   　　　　fmt.Println(s2　==　nil)　
   }

   Sortie :

   false
   true

   Attention :Pour comparer deux coupes, utilisez la correspondance de portée en boucle ou vous pouvez utiliserDeepEqualFonction.

4. Coupes multidimensionnelles :Les coupes multidimensionnelles sont comme les tableaux multidimensionnels, mais les coupes ne contiennent pas de taille.

   Exemple

   package　main　
   　　
   import　"fmt"
   　　
   func　main()　{　
   　　
   　　　　//Création des coupes multidimensionnelles
   　　　　s1　:=　[][]int{{12,　34},　
   　　　　　　　　{56,　47},　
   　　　　　　　　{29,　40},　
   　　　　　　　　{46,　78},　
   　　　　}　
   　　
   　　　　//Accès aux coupes multidimensionnelles
   　　　　fmt.Println("Slice　1　:　",　s1)　
   　　
   　　　　//Création des coupes multidimensionnelles　
   　　　　s2　:=　[][]string{　
   　　　　　　　　[]string{"w3codeboxs",　"for"},　
   　　　　　　　　[]string{"w3codeboxs",　"GFG"},　
   　　　　　　　　[]string{"gfg",　"w3codebox"},　
   　　　　}　
   　　
   　　　　//Accès aux coupes multidimensionnelles
   　　　　fmt.Println("Slice　2　:　",　s2)　
   　　
   }

   Sortie :

   Slice　1　:　　[[12　34]]　[56　47]]　[29　40]　[46　78]]
   Slice　2　:　　[[w3codeboxs　for]　[w3codeboxs　GFG]　[gfg　w3codebox]]

5. Tri des coupes :En langage Go, il est possible de trier les éléments existants dans une coupe. Le langage Go fournit la bibliothèque standard sort, qui contient des fonctions pour trier int, float64Différents types de méthodes de tri pour les coupes de chaînes de caractères. Ces fonctions trient toujours les coupes disponibles en ordre croissant.

   Exemple

   //Éléments existants dans la coupe
   package　main　
   　　
   import　("　
   　　　　"fmt"
   　　　　"sort"
   )　
   　　
   func　main()　{　
   　　
   　　　　//Création de la coupe
   　　　　slc1　:=　[]string{"Python",　"Java",　"C#",　"Go",　"Ruby"}　
   　　　　slc2　:=　[]int{45,　67,　23,　90,　33,　21,　56,　78,　89}　
   　　
   　　　　fmt.Println("Avant le tri :")　
   　　　　fmt.Println("Slice　1:　",　slc1)　
   　　　　fmt.Println("Slice　2:　",　slc2)　
   　　
   　　　　//Fonction de tri utilisée pour les coupes
   　　　　sort.Strings(slc1)　
   　　　　sort.Ints(slc2)　
   　　
   　　　　fmt.Println("\nTrieu :")　
   　　　　fmt.Println("Slice　1:　",　slc1)　
   　　　　fmt.Println("Slice　2:　",　slc2)　
   　　
   }

   Sortie :

   Avant :
   Slice　1:　　[Python　Java　C#　Go　Ruby]
   Slice　2:　　[45　67　23　90　33　21　56　78　89]
   Trieu :
   Slice　1:　　[C#　Go　Java　Python　Ruby]
   Slice　2:　　[21　23　33　45　56　67　78　89　90]