Tableau (Array) du langage Go

Le langage de programmation Go des arrays est très similaire à d'autres langages de programmation. Dans un programme, nous avons parfois besoin de stocker un ensemble de données de même type, par exemple une liste de notes d'étudiants. Ce type de collection est stocké dans le programme à l'aide d'un array. Un array est une séquence de longueur fixe, utilisé pour stocker des éléments de même type en mémoire. En raison de leur longueur fixe, les arrays ne sont pas aussi populaires que les slices (slices) dans le langage Go.
Dans l'array, il est permis de stocker zéro ou plus d'éléments. En utilisant l'opérateur d'indexage [] et sa position de zéro, cela signifie que l'index du premier élément estarray [0]，le dernier élément de l'index estarray [len(array)]-1]}}.

Création et accès aux tableaux

En langage Go, les tableaux sont créés de deux manières différentes :

• Utilisation de la clé var :En langage Go, un tableau est créé en utilisant la clé var avec un nom, une taille et un type d'élément spécifique.

  Syntaxe :

  Var array_name[length]Type
  或
  var array_name[length]Typle{item1, item2, item3, ...itemN}

  Remarque importante :
  

• En langage Go, les tableaux sont modifiables, donc vous pouvez utiliser la syntaxe array[index] à gauche de l'allocation pour définir l'élément du tableau à l'index donné.

  Var array_name[index] = element[object Object]

• Vous pouvez accéder aux éléments du tableau en utilisant un index ou en utilisant une boucle for.

• En langage Go, le type de tableau est unidimensionnel.

• La longueur du tableau est fixe et ne peut pas être modifiée.

• Vous pouvez stocker des éléments répétés dans un tableau.

示例

//Création d'un tableau en utilisant la clé var
//Accès aux éléments du tableau via son index
package main
import "fmt"
func main() {
　　　　//Création d'un tableau de type chaîne de caractères en utilisant la clé var
　　　　var myarr [3]string
　　　　//Allocation d'éléments via index
　　　　myarr[0] = "GFG"
　　　　myarr[1] = "GFG"3codebox.com"
　　　　myarr[2] = "fr.oldtoolbag.com"
　　　　//myarr[
　　　　//] = "w
　　　　fmt.Println("Éléments du tableau:")
　　　　Accès aux éléments du tableau　1codebox"
　　　　Accès aux éléments du tableau　2fmt.Println("Élément: ", myarr[0])1: ", myarr[
　　　　Accès aux éléments du tableau　3fmt.Println("Élément: ", myarr[0])2: ", myarr[
{}

Sortie :

Éléments du tableau:
: www.w　1)
: www.w　2: GFG3codebox.com
: www.w　3Élément3codebox

• : wEn langage Go, les tableaux peuvent également être déclarés avec une syntaxe abrégée. Cela est plus flexible que la déclaration précédente.

  Syntaxe :

  array_name := [length]Type{item1, item2, item3, ...itemN}[object Object]

  示例

  //Utilisation des tableaux avec une déclaration abrégée
  //Accéder aux tableaux en utilisant une boucle for
  package main
  import "fmt"
  func main() {
  　　　　//Déclaration abrégée de tableau
  　　　　4]string{"w3codebox", "gfg", "w3codeboxs1231", "fr.oldtoolbag.com"
  　　　　//Élément accédé, utilisation d'un boucle for avec le tableau
  　　　　fmt.Println("Éléments du tableau:")
  　　　　for i := 0; i <　3; i++　{
  　　　　　　　　fmt.Println(arr[i])
  　　　　{}
  {}

  Sortie :

  Éléments du tableau:
  w3codebox
  gfg
  w3codeboxs1231

Tableau multidimensionnel

Nous savons déjà que les tableaux sont unidimensionnels, mais il est possible de créer des tableaux multidimensionnels. Un tableau multidimensionnel est un tableau d'arrays de même type. En langage Go, vous pouvez créer des tableaux multidimensionnels en utilisant la syntaxe suivante:

Array_name[Length1][Length2]..[LengthN]Type

您可以使用Var关键字或Déclaration abrégée来创建多维数组，如下例所示。

注意：在多维数组中，如果用户未使用某个值初始化单元格，则编译器将自动将其初始化为零。Golang中没有未初始化的概念。

示例

package main
import "fmt"
func main() {
　　　　//创建和初始化
　　　　//
　　　　//Déclaration abrégée
　　　　//
　　　　3][3]string{{"C#
　　　　　　　　{"Java", "Scala", "Perl"},
　　　　　　　　{"C++", "Go", "HTML"}}
　　　　//La valeur accédée
　　　　//Utiliser une boucle for pour accéder au tableau
　　　　fmt.Println("Éléments du tableau :　1)

　　　　for x := 0; x <　3; x++　{
　　　　　　　　for y := 0; y <　3; y++　{
　　　　　　　　　　　　fmt.Println(arr[x][y])
　　　　　　　　{}
　　　　{}
　　　　//Créer un tableau deux dimensions
　　　　//Tableau créé avec la keyword var
　　　　//et initialiser un
　　　　//Utiliser un tableau à l'aide de l'index
　　　　var arr1　][2][2]int
　　　　arr1][0][0] =　100
　　　　arr1][0][1] =　200
　　　　arr1][1][0] =　300
　　　　arr1][1][1] =　400
　　　　//Accéder à la valeur du tableau
　　　　fmt.Println("Éléments du tableau :　2)

　　　　for p := 0; p <　2; p++　{
　　　　　　　　for q := 0; q <　2; q++　{
　　　　　　　　　　　　fmt.Println(arr1[p][q])
　　　　　　　　{}
　　　　{}
{}

Sortie :

Les éléments du tableau　1
C#
C
Python
Java
Scala
Perl
C++
Go
HTML
Les éléments du tableau　2
100
200
300
400

Remarques sur les tableaux

• Dans le tableau, si le tableau n'est pas explicitement initialisé,Ce tableaudeLa valeur par défaut est 0.

  示例

  package main　
  　　
  import "fmt"
  　　
  func main() {　
  　　
  //Créer un tableau de type int, stockant deux éléments
  //Ici, nous ne faisons pas d'initialisation de tableau, donc la valeur du tableau est zéro
  var myarr[2]int　
  fmt.Println("Éléments du tableau :", myarr)　
  　　
  {}

  Sortie :

  Éléments du tableau : [0 0]

• Dans le tableau, vous pouvezUtiliserMéthode len()ObtenirTableauLa longueur,Tel que montré ci-dessous :

  示例

  package main
  import "fmt"
  func main() {
  　　　　//Créer un tableau
  　　　　//Déclaration abrégée
  　　　　arr1　:=[3int{9,　7,　6{}
  　　　　arr2　:=[...]int{9,　7,　6,　4,　5,　3,　2,　4{}
  　　　　arr3　:=[3int{9,　3,　5{}
  　　　　//　Calculer la taille du tableau en utilisant la méthode len
  　　　　fmt.Println("Tableau1La longueur est :1))
  　　　　fmt.Println("Tableau2La longueur est :2))
  　　　　fmt.Println("Tableau3La longueur est :3))
  {}

  Sortie :

  Tableau1La longueur est :　3
  Tableau2La longueur est :　8
  Tableau3La longueur est :　3

• 在数组中，Si les points d'interrogation " ..."Visible à la position de la longueur, la longueur du tableau est déterminée par les éléments initiaux. Voici un exemple :

  示例

  //L'utilisation des points d'interrogation dans le tableau
  package main
  import "fmt"
  func main() {
  　　　　//Créer un tableau de taille déterminée
  　　　　//Selon le nombre d'éléments
  　　　　//L'utilisation des points d'interrogation
  　　　　myarray := [...]string{"GFG", "gfg", "w3"codeboxs", "fr.oldtoolbag.com", "w"3codebox"}
  　　　　fmt.Println("数组元素:　", myarray)
  　　　　//数组的长度
  　　　　//由...决定
  　　　　//使用len()方法
  　　　　fmt.Println("数组的长度为:", len(myarray))
  {}

  Sortie :

  数组元素:　　[GFG gfg w3codeboxs　fr.oldtoolbag.com　w3codebox]
  数组的长度为:　5

• 在数组中，允许您在array 的元素范围内进行迭代。如下例所示：

  示例

  //如何迭代数组
  package main
  import "fmt"
  func main() {
  　　　　//创建一个数组，其大小
  　　　　//用省略号表示
  　　　　myarray := [...]int{29,　79,　49,　39,　20,　49,　48,　49{}
  　　　　//使用for循环迭代数组
  　　　　for x := 0; x < len(myarray); x++　{
  　　　　　　　　fmt.Printf("%d\n", myarray[x])
  　　　　{}
  {}

  Sortie :

  29
  79
  49
  39
  20
  49
  48
  49

• 在Go语言中，数组的值类型不是引用类型。因此，当将数组分配给新变量时，在新变量中所做的更改不会影响原始数组。如下例所示：

  示例

  package main
  import "fmt"
  func main() {
  　　　　//创建一个数组，其大小
  　　　　//用省略号表示
  　　　　my_array := [...]int{100,　200,　300,　400,　500}
  　　　　fmt.Println("原始数组(改变前):", my_array)
  　　　　//创建一个新变量
  　　　　//并使用my_array进行初始化
  　　　　new_array := my_array
  　　　　fmt.Println("新数组(改变前):", new_array)
  　　　　//将索引0处的值更改为500
  　　　　new_array[0] =　500
  　　　　fmt.Println("新数组(改变后):", new_array)
  　　　　fmt.Println("原始数组(改变后):", my_array)
  {}

  Sortie :

  原始数组(改变前):　[100　200　300　400　500]
  新数组(改变前):　[100　200　300　400　500]
  新数组(改变后):　[500　200　300　400　500]
  原始数组(改变后):　[100　200　300　400　500]

• 在数组中，如果数组的元素类型是可比较的，则数组类型也是可比较的。因此，我们可以使用==运算符直接比较两个数组。如下例所示：

  示例

  //如何比较两个数组
  package main
  import "fmt"
  func main() {
  　　　　arr1　:=[3int{9,　7,　6{}
  　　　　arr2　:=[...]int{9,　7,　6{}
  　　　　arr3　:=[3int{9,　5,　3{}
  　　　　//使用==运算符比较数组
  　　　　fmt.Println(arr1　==arr2)
  　　　　fmt.Println(arr2　==arr3)
  　　　　fmt.Println(arr1　==arr3)
  　　　　//这将给出和错误，因为
  　　　　//　arr1和arr4的类型不匹配
  　　　　/*
  　　　　　　　arr4:=[4int{9,7,6{}
  　　　　　　　fmt.Println(arr1==arr4)
  　　　　*/
  {}

  Sortie :

  true
  false
  false