Qu'est-ce qu'un tuple en langage Go ?

Les tuples sont des conteneurs séquentiels immuables de longueur fixe (séquences d'éléments). Il n'y a pas de type de tuple dans le langage Go et les tableaux sont équivalents aux tuples. Dans le langage Go, un tableau est une séquence composée d'éléments de longueur fixe d'un type spécifique. Un tableau peut être composé de zéro ou plusieurs éléments ; la syntaxe de déclaration d'un tableau est "var nom de variable de tableau [nombre d'éléments]Type. ".

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Qu'est-ce qu'un tuple

Tuple (tuple) : un conteneur séquentiel immuable de longueur fixe avec une efficacité d'accès élevée et adapté au stockage de données longues et constantes.

La compréhension simple est de stocker un tas de données dans un conteneur, mais ce conteneur a une caractéristique, c'est-à-dire qu'une fois défini, il ne peut pas être modifié. Dans un sens, un tuple est une liste. qui ne peut pas être modifié. La fonction est similaire à la liste et des opérations telles que le découpage et la modification peuvent également être effectuées.

Il n'y a pas de type de tuple dans le langage Go

Les tableaux en langage Go sont équivalents aux tuples en python.

Un tableau est une séquence d'éléments de longueur fixe d'un type spécifique. Un tableau peut être composé de zéro ou plusieurs éléments.

Tableaux en langage Go

Déclaration des tableaux

La syntaxe de déclaration des tableaux est la suivante :

var 数组变量名 [元素数量]Type

La description de la syntaxe est la suivante :

• Noms des variables de tableau : Variables lors de la déclaration et en utilisant le nom des tableaux.

• Nombre d'éléments : Le nombre d'éléments du tableau peut être une expression, mais le résultat final calculé au moment de la compilation doit être une valeur entière. Le nombre d'éléments ne peut pas contenir une valeur dont la taille ne peut être confirmée qu'à l'exécution.

• Type : Il peut s'agir de n'importe quel type de base, y compris le tableau lui-même. Lorsque le type est le tableau lui-même, un tableau multidimensionnel peut être implémenté.

En langage Go, pour créer un tableau, vous pouvez déclarer une variable de tableau et spécifier sa longueur et son type de données.

ne contient que deux éléments et le troisième élément ne peut pas se voir attribuer de valeur, cela provoquera donc une erreur de compilation.

var cheeses [2]string
cheeses[O] = "Mar iolles”
cheeses[l] = ” Epoisses de Bourgogne ”

Chaque élément du tableau est accessible via l'indice d'index. La plage de l'indice d'index va de 0 à la position de la longueur du tableau moins 1. La fonction intégrée len() peut renvoyer le nombre d'éléments dans. le tableau.

var a [3]int             // 定义三个整数的数组
fmt.Println(a[0])        // 打印第一个元素
fmt.Println(a[len(a)-1]) // 打印最后一个元素
// 打印索引和元素
for i, v := range a {
    fmt.Printf("%d %d\n", i, v)
}
// 仅打印元素
for _, v := range a {
    fmt.Printf("%d\n", v)
}

Par défaut, chaque élément du tableau sera initialisé à la valeur zéro correspondant au type d'élément, qui est 0 pour les types numériques. Vous pouvez également utiliser la syntaxe littérale du tableau pour initialiser le tableau avec un ensemble de valeurs :

var q [3]int = [3]int{1, 2, 3}
var r [3]int = [3]int{1, 2}
fmt.Println(r[2]) // "0"

Dans la définition du tableau, si les points de suspension "..." apparaissent à la position de la longueur du tableau, cela signifie que la longueur du tableau est calculée en fonction du nombre de valeurs d'initialisation. Par conséquent, la définition du tableau. le tableau q ci-dessus peut être simplifié comme suit :

q := [...]int{1, 2, 3}
fmt.Printf("%T\n", q) // "[3]int"

La longueur du tableau fait partie intégrante du type de tableau, donc [3]int et [4]int sont deux types de tableau différents. La longueur du tableau doit être une constante. expression car la longueur du tableau doit être déterminée au stade de la compilation.

q := [3]int{1, 2, 3}
q = [4]int{1, 2, 3, 4} // 编译错误：无法将 [4]int 赋给 [3]int

Comparez deux tableaux pour l'égalité

Si les deux tableaux ont le même type (y compris la longueur du tableau et le type d'éléments dans le tableau), nous pouvons directement utiliser les opérateurs de comparaison (== et != ) Pour déterminer si deux tableaux sont égaux, les tableaux ne sont égaux que lorsque tous les éléments des deux tableaux sont égaux. Deux tableaux de types différents ne peuvent pas être comparés, sinon le programme ne pourra pas terminer la compilation.

a := [2]int{1, 2}
b := [...]int{1, 2}
c := [2]int{1, 3}
fmt.Println(a == b, a == c, b == c) // "true false false"
d := [3]int{1, 2}
fmt.Println(a == d) // 编译错误：无法比较 [2]int == [3]int

Traverser le tableau - accéder à chaque élément du tableau

Traverser le tableau est également similaire à parcourir la tranche. Le code est le suivant :

var team [3]string
team[0] = "hammer"
team[1] = "soldier"
team[2] = "mum"
for k, v := range team {
    fmt.Println(k, v)
}

Résultat de sortie du code :

La description du code est la suivante. :

• La ligne 6 utilise une boucle for pour parcourir le tableau d'équipe. La clé parcourue k est l'index du tableau, et la valeur v est la valeur de chaque élément du tableau.

• Ligne 7, imprimez chaque valeur clé.

La fonction tuple est implémentée dans Golang

Bien que d'autres langages aient des types de tuple, le langage go ne les fournit pas. Mais il ne faut pas désespérer, d’autres fonctionnalités de go rendent très facile l’implémentation de fonctions tuple. L'exemple suivant montre comment Go implémente les fonctions de type tuple.

L'utilisation de struct

tuple peut stocker différents types de données, et nous pouvons utiliser le type interface{} pour prendre en charge n'importe quel type de données.

package main

import "fmt"

func main() {
	type Student struct {
		name, age interface{}
	}

	stuList1 := []Student{
		{"tom", 21},
		{"jack", 22},
	}

	stuList2 := []Student{
		{"mary", 30},
	}
	// append stuList2 to stuList1
	stuList1 = append(stuList1, stuList2...)

	for _, stu := range stuList1 {
		fmt.Println(“stuInfo:”,stu)
	}
}


/*
Output:
stuInfo: {tom 21}
stuInfo: {jack 22}
stuInfo: {mary 30}
*/

Vous pouvez voir à travers la sortie que le résultat est similaire à un type de tuple, et les attributs individuels sont également accessibles via des points. Bien que ces fonctionnalités soient liées au tuple, il ne s’agit pas réellement d’un type de tuple.

Renvoyer plusieurs valeurs

Vous pouvez renvoyer plusieurs valeurs via la fonction tuple. Bien que go n'ait pas de type tuple, il prend en charge les fonctions de retour pour renvoyer plusieurs valeurs :

package main

import "fmt"

func multipleValues() (string, int) {
	return "Alex", 21
}

func main() {
	name, age := multipleValues()
	fmt.Println("Name :", name)
	fmt.Println("Age :", age)
}

/*
Output:
Name : Alex
Age : 21
*/

Ici, vous pouvez voir que plusieurs valeurs sont renvoyées à la fois.

【Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!