Go
Tableaux

Introduction

Syntaxe

• var variableName [5] ArrayType // Déclarer un tableau de taille 5.
• var NomVariable [2] [3] ArrayType = {{Valeur1, Valeur2, Valeur3}, {Valeur4, Valeur5, Valeur6}} // Déclaration d'un tableau multidimensionnel
• variableName: = [...] ArrayType {Value1, Value2, Value3} // Déclarer un tableau de taille 3 (Le compilateur comptera les éléments du tableau pour définir la taille)
• arrayName [2] // Obtention de la valeur par index.
• arrayName [5] = 0 // Définition de la valeur à l'index.
• arrayName [0] // Première valeur du tableau
• arrayName [len (arrayName) -1] // Dernière valeur du tableau

Créer des tableaux

Un tableau en cours est une collection ordonnée d'éléments de même type.
La notation de base pour représenter les tableaux consiste à utiliser [] avec le nom de la variable.

Créer un nouveau tableau ressemble à var array = [size]Type , en remplaçant size par un nombre (par exemple 42 pour spécifier qu'il s'agira d'une liste de 42 éléments) et en remplaçant Type par le type des éléments que le tableau peut contenir (for exemple int ou string )

Juste en dessous se trouve un exemple de code montrant la manière différente de créer un tableau dans Go.

// Creating arrays of 6 elements of type int,
// and put elements 1, 2, 3, 4, 5 and 6 inside it, in this exact order:
var array1 [6]int = [6]int {1, 2, 3, 4, 5, 6} // classical way
var array2 = [6]int {1, 2, 3, 4, 5, 6} // a less verbose way
var array3 = [...]int {1, 2, 3, 4, 5, 6} // the compiler will count the array elements by itself

fmt.Println("array1:", array1) // > [1 2 3 4 5 6]
fmt.Println("array2:", array2) // > [1 2 3 4 5 6]
fmt.Println("array3:", array3) // > [1 2 3 4 5 6]


// Creating arrays with default values inside:
zeros := [8]int{}               // Create a list of 8 int filled with 0
ptrs := [8]*int{}               // a list of int pointers, filled with 8 nil references ( <nil> )
emptystr := [8]string{}         // a list of string filled with 8 times ""

fmt.Println("zeroes:", zeros)      // > [0 0 0 0 0 0 0 0]
fmt.Println("ptrs:", ptrs)         // > [<nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil>]
fmt.Println("emptystr:", emptystr) // > [       ]  
// values are empty strings, separated by spaces,
// so we can just see separating spaces


// Arrays are also working with a personalized type
type Data struct {
    Number int
    Text   string
}

// Creating an array with 8 'Data' elements
// All the 8 elements will be like {0, ""} (Number = 0, Text = "")
structs := [8]Data{}  

fmt.Println("structs:", structs) // > [{0 } {0 } {0 } {0 } {0 } {0 } {0 } {0 }] 
// prints {0 } because Number are 0 and Text are empty; separated by a space

jouer sur le terrain de jeu

Tableau multidimensionnel

Les tableaux multidimensionnels sont essentiellement des tableaux contenant d'autres tableaux en tant qu'éléments.
Il est représenté comme type [sizeDim1][sizeDim2]..[sizeLastDim]type , en remplaçant sizeDim par des nombres correspondant à la longueur de la dimension, et type le type de données dans le tableau multidimensionnel.

Par exemple, [2][3]int représente un tableau composé de 2 sous-tableaux de 3 éléments int .
Il peut s'agir essentiellement de la représentation d'une matrice de 2 lignes et de 3 colonnes .

Donc, nous pouvons créer des tableaux de nombres de dimensions énormes comme les var values := [2017][12][31][24][60]int par exemple si vous devez enregistrer un nombre pour chaque minute depuis l'année 0.

Pour accéder à ce type de tableau, dans le dernier exemple, en recherchant la valeur de 2016-01-31 à 19:42, vous accéderez aux values[2016][0][30][19][42] (car les index de tableau commence à 0 et pas à 1 comme jours et mois)

Quelques exemples suivants:

// Defining a 2d Array to represent a matrix like
// 1 2 3     So with 2 lines and 3 columns;
// 4 5 6     
var multiDimArray := [2/*lines*/][3/*columns*/]int{ [3]int{1, 2, 3}, [3]int{4, 5, 6} }

// That can be simplified like this:
var simplified := [2][3]int{{1, 2, 3}, {4, 5, 6}}

// What does it looks like ?
fmt.Println(multiDimArray)
// > [[1 2 3] [4 5 6]]

fmt.Println(multiDimArray[0]) 
// > [1 2 3]    (first line of the array)

fmt.Println(multiDimArray[0][1])
// > 2          (cell of line 0 (the first one), column 1 (the 2nd one))

// We can also define array with as much dimensions as we need
// here, initialized with all zeros
var multiDimArray := [2][4][3][2]string{} 

fmt.Println(multiDimArray);
// Yeah, many dimensions stores many data
// > [[[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]]
//   [[[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]]

// We can set some values in the array's cells
multiDimArray[0][0][0][0] := "All zero indexes"  // Setting the first value
multiDimArray[1][3][2][1] := "All indexes to max"  // Setting the value at extreme location

fmt.Println(multiDimArray);
// If we could see in 4 dimensions, maybe we could see the result as a simple format
    
// > [[[["All zero indexes" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]]
//   [[[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" "All indexes to max"]]]]

Index de tableau

Les valeurs de tableaux doivent être accessibles à l'aide d'un numéro spécifiant l'emplacement de la valeur souhaitée dans le tableau. Ce numéro s'appelle Index.

Les index commencent à 0 et finissent à la longueur du tableau -1 .

Pour accéder à une valeur, vous devez faire quelque chose comme ceci: arrayName[index] , en remplaçant "index" par le nombre correspondant au rang de la valeur dans votre tableau.

Par exemple:

var array = [6]int {1, 2, 3, 4, 5, 6}

fmt.Println(array[-42]) // invalid array index -1 (index must be non-negative)
fmt.Println(array[-1]) // invalid array index -1 (index must be non-negative)
fmt.Println(array[0]) // > 1
fmt.Println(array[1]) // > 2
fmt.Println(array[2]) // > 3
fmt.Println(array[3]) // > 4
fmt.Println(array[4]) // > 5
fmt.Println(array[5]) // > 6
fmt.Println(array[6]) // invalid array index 6 (out of bounds for 6-element array)
fmt.Println(array[42]) // invalid array index 42 (out of bounds for 6-element array)

Pour définir ou modifier une valeur dans le tableau, le chemin est le même.
Exemple:

var array = [6]int {1, 2, 3, 4, 5, 6}

fmt.Println(array) // > [1 2 3 4 5 6]

array[0] := 6
fmt.Println(array) // > [6 2 3 4 5 6]

array[1] := 5
fmt.Println(array) // > [6 5 3 4 5 6]

array[2] := 4
fmt.Println(array) // > [6 5 4 4 5 6]

array[3] := 3
fmt.Println(array) // > [6 5 4 3 5 6]

array[4] := 2
fmt.Println(array) // > [6 5 4 3 2 6]

array[5] := 1
fmt.Println(array) // > [6 5 4 3 2 1]