Tableaux du langage Go
Le langage Go fournit une structure de données de type tableau.
Un tableau est une séquence d'éléments de données numérotés et de longueur fixe du même type unique, qui peut être n'importe quel type primitif tel que des entiers, des chaînes de caractères ou des types personnalisés.
Par rapport à la déclaration denumber0, number1, ..., number99variables, utilisez la forme de tableaunumbers[0], numbers[1] ..., numbers[99]qui est plus pratique et plus facile à étendre.
Les éléments d'un tableau peuvent être lus (ou modifiés) par index (position). L'index commence à 0, le premier élément a l'index 0, le deuxième a l'index 1, et ainsi de suite.
Déclaration de tableaux
Déclarer un tableau en langage Go nécessite de spécifier le type des éléments et le nombre d'éléments. Le format de syntaxe est le suivant :
var arrayName [size]dataTypeoù,arrayNameest le nom du tableau,sizeest la taille du tableau,dataTypeest le type de données des éléments du tableau.
Ce qui suit définit un tableau balance de longueur 10 et de type float32 :
var balance [10]float32
Initialisation des tableaux
Ce qui suit illustre l'initialisation d'un tableau :
L'exemple suivant déclare un tableau d'entiers nommé numbers d'une taille de 5. Au moment de la déclaration, chaque élément du tableau est initialisé par défaut en fonction de son type de données. Pour les types entiers, la valeur initiale est 0.
var numbers [5]int
Vous pouvez également utiliser une liste d'initialisation pour initialiser les éléments d'un tableau :
var numbers = [5]int{1, 2, 3, 4, 5}
Le code ci-dessus déclare un tableau d'entiers de taille 5 et initialise ses éléments à 1, 2, 3, 4 et 5 respectivement.
De plus, vous pouvez également utiliser:=Utiliser la syntaxe de déclaration courte pour déclarer et initialiser un tableau :
numbers := [5]int{1, 2, 3, 4, 5}
Le code ci-dessus crée un tableau d'entiers nommé numbers, définit sa taille à 5 et initialise les valeurs de ses éléments.
Remarque :En langage Go, la taille d'un tableau fait partie de son type, donc des tableaux de tailles différentes sont incompatibles. C'est-à-dire que[5]intet[10]intsont des types différents.
Ce qui suit définit un tableau balance de longueur 5 et de type float32, et initialise les éléments du tableau :
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
Nous pouvons également initialiser rapidement un tableau au moment de la déclaration à l'aide de littéraux :
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
Si la longueur du tableau est incertaine, vous pouvez utiliser...Au lieu de la longueur du tableau, le compilateur déduira la longueur du tableau automatiquement en fonction du nombre d'éléments :
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
ou
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
Si la longueur du tableau est définie, nous pouvons également initialiser des éléments en spécifiant des indices :
// 将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}
Initialisation d'un tableau{}Le nombre d'éléments dans ne peut pas être supérieur au[]nombre dans.
Si vous ignorez[]Si aucune taille de tableau n'est définie dans les nombres, le langage Go définira la taille du tableau en fonction du nombre d'éléments :
balance[4] = 50.0
L'exemple ci-dessus lit le cinquième élément. Les éléments d'un tableau peuvent être accédés (ou modifiés) par index (position). Les indices commencent à 0, le premier élément étant à l'indice 0, le deuxième à l'indice 1, et ainsi de suite.
Accéder aux éléments d'un tableau
Les éléments d'un tableau peuvent être lus par index (position). Le format est le nom du tableau suivi de crochets, avec la valeur de l'index entre les crochets. Par exemple :
var salary float32 = balance[9]
L'exemple ci-dessus lit la valeur du 10e élément du tableau balance.
Ce qui suit montre un exemple d'opérations complètes sur les tableaux (déclaration, affectation, accès) :
Exemple 1
import "fmt"
func main() {
var n [10]int /* n est un tableau de longueur 10 */
var i,j int
/* initialiser les éléments du tableau n */
for i = 0; i < 10; i++ {
n[i] = i + 100 /* définir l'élément à i + 100 */
}
/* Afficher la valeur de chaque élément du tableau */
for j = 0; j < 10; j++ {
fmt.Printf("Element[%d] = %d\n", j, n[j] )
}
}
Le résultat d'exécution de l'exemple ci-dessus est le suivant :
Element[0] = 100 Element[1] = 101 Element[2] = 102 Element[3] = 103 Element[4] = 104 Element[5] = 105 Element[6] = 106 Element[7] = 107 Element[8] = 108 Element[9] = 109
Exemple 2
import "fmt"
func main() {
var i,j,k int
// Déclarer le tableau et l'initialiser rapidement en même temps
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
/* afficher les éléments du tableau */ ...
for i = 0; i < 5; i++ {
fmt.Printf("balance[%d] = %f\n", i, balance[i] )
}
balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
/* Afficher la valeur de chaque élément du tableau */
for j = 0; j < 5; j++ {
fmt.Printf("balance2[%d] = %f\n", j, balance2[j] )
}
// initialiser les éléments avec les indices 1 et 3
balance3 := [5]float32{1:2.0,3:7.0}
for k = 0; k < 5; k++ {
fmt.Printf("balance3[%d] = %f\n", k, balance3[k] )
}
}
Le résultat d'exécution de l'exemple ci-dessus est le suivant :
balance[0] = 1000.000000 balance[1] = 2.000000 balance[2] = 3.400000 balance[3] = 7.000000 balance[4] = 50.000000 balance2[0] = 1000.000000 balance2[1] = 2.000000 balance2[2] = 3.400000 balance2[3] = 7.000000 balance2[4] = 50.000000 balance3[0] = 0.000000 balance3[1] = 2.000000 balance3[2] = 0.000000 balance3[3] = 7.000000 balance3[4] = 0.000000
Plus de contenu
Les tableaux sont très importants pour le langage Go. Ci-dessous, nous présenterons plus de contenu sur les tableaux :
| content | Description |
|---|---|
| Tableaux multidimensionnels | Le langage Go prend en charge les tableaux multidimensionnels. Le tableau multidimensionnel le plus simple est un tableau à deux dimensions. |
| Passage de tableaux aux fonctions | Vous pouvez passer des arguments de tableau à des fonctions |