Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Connectez le précédent et le suivant

Nous avons présenté if et for dans notre article précédent. Cela ne devrait pas être pratiqué. Pratiquons comment l'utiliser.continue Instruction pour calculer la somme des nombres pairs inférieurs à 100. Pendant que nous écrivons du code,continueL'instruction nous aidera à ignorer certaines itérations qui ne sont pas nécessaires, par exemple, dans cet exemple, nous ignorerons tous les nombres impairs.

sum := 0
for i := 1; i < 100; i++{
   if i & 1 == 0 {
      continue
   }
   sum += i
}
 
fmt.Println("the sum is",sum)

Commencer à apprendre

En programmation, nous avons souvent besoin de traiter un ensemble d'éléments du même type, et ces ensembles d'éléments sont représentés par des structures de données spécifiques dans le langage Go. Aujourd'hui, je vais vous présenter en détail plusieurs types de collections dans Go : tableau, tranche et carte.

tableau

Commençons par les tableaux. Le tableau est la structure de données la plus élémentaire de Go. Il s'agit d'une séquence d'éléments de longueur fixe du même type. Une fois qu'un tableau est déclaré, sa longueur ne peut plus être modifiée. La déclaration et l'initialisation des tableaux sont très simples,

Déclarer un tableau

Lors de la déclaration d'un tableau, vous devez spécifier le type et la longueur du tableau. Voici comment un tableau est déclaré :

var arrayName [arrayLength]elementType

Par exemple, déclarez un tableau d'entiers de longueur 5 :

var numbers [5]int

initialiser le tableau

Vous pouvez initialiser un tableau de différentes manières :

• Utilisez l'initialisation littérale :

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

• utiliser:=Courte déclaration :

numbers := [5]int{1, 2, 3, 4, 5}

• Déduire automatiquement la longueur du tableau :

numbers := [...]int{1, 2, 3, 4, 5}

• Spécifiez l'initialisation de l'index :

numbers := [5]int{0: 1, 4: 5}

Caractéristiques des tableaux

• Longueur fixe: La longueur du tableau est déterminée lors de sa déclaration et ne peut pas être modifiée ultérieurement.
• éléments du même type: Les tableaux ne peuvent contenir que des éléments du même type.
• allocation de mémoire de manière contiguë: Les éléments du tableau sont alloués de manière contiguë en mémoire, ce qui rend l'accès aux éléments du tableau très efficace.

Accéder aux éléments du tableau

Vous pouvez accéder aux éléments d'un tableau par index, à partir de 0 :

value := numbers[2] // 获取索引为 2 的元素

Tableau de parcours

vous pouvez utiliserforParcourez tous les éléments d'un tableau :

for i, value := range numbers {
    fmt.Printf("Index: %d, Value: %dn", i, value)
}

longueur du tableau

Vous pouvez utiliser lelenFonction pour obtenir la longueur d'un tableau :

length := len(numbers)

valeur nulle du tableau

Si un tableau n'est pas explicitement initialisé, ses éléments sont automatiquement mis à la valeur zéro de leur type. Par exemple, la valeur zéro d'un tableau d'entiers est 0 :

var numbers [5]int // 所有元素都是 0

Tableaux multidimensionnels

Le langage Go prend également en charge les tableaux multidimensionnels. Voici un exemple de déclaration et d'initialisation d'un tableau d'entiers 2x3 :

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

Limites des tableaux

Puisque la longueur du tableau est fixe, cela peut ne pas être très flexible dans certains cas. Si vous avez besoin d'une collection de longueur variable, vous pouvez utiliser des tranches.

tranche

Vient ensuite slice, qui est un type intégré plus flexible qui peut être considéré comme un tableau dynamique. La longueur de la tranche est variable et elle est créée sur la base d'un tableau, offrant plus de commodité. Voici comment déclarer et initialiser une tranche :

s := make([]int, 3)      // 创建一个长度为3的整型切片
s[0] = 1                // 切片元素赋值
s[1] = 2
s[2] = 3
s = append(s, 4)        // 向切片追加元素

Dans le langage Go, bien que les tableaux et les tranches soient tous deux utilisés pour stocker une série d'éléments du même type, ils présentent des différences significatives en termes d'allocation de mémoire, de variabilité de taille et d'utilisation. Voici les principales différences entre les tableaux et les tranches :

variabilité de taille

• tableau : La taille d'un tableau est déterminée lors de sa déclaration et ne peut pas être modifiée ultérieurement.La taille d'un tableau fait partie de son type, donc[3]intet[4]intsont de différents types.
• tranche : Les tranches sont dynamiques et peuvent s'agrandir ou se réduire au moment de l'exécution.La taille d'une tranche ne fait pas partie de son type, donc[]intEst le type commun à toutes les tranches entières.

allocation de mémoire

• tableau : Les tableaux sont des types valeur, et lorsqu'un tableau est passé en paramètre de fonction, une copie de sa valeur est transmise. Cela signifie que les modifications apportées au tableau à l'intérieur de la fonction n'affectent pas le tableau d'origine.
• tranche : Slice est un type de référence, qui contient un pointeur vers le tableau sous-jacent, la longueur et la capacité de la tranche. Lorsqu'une tranche est passée en tant que paramètre de fonction, une copie du pointeur est transmise, donc les modifications apportées à la tranche dans la fonction affecteront la tranche d'origine.

initialisation

• tableau: Lors de l'initialisation d'un tableau, sa taille doit être spécifiée et les valeurs des éléments peuvent être attribuées immédiatement.
• tranche: Les tranches peuvent être passées par des littéraux,makeFonction ou tranche d'un tableau à initialiser, aucune taille spécifiée.

Exemple de code

Voici des exemples d'initialisation de tableaux et de tranches :

// 数组
var arr [3]int = [3]int{1, 2, 3}
 
// 切片
var slice []int = []int{1, 2, 3}
// 或者使用 make 函数
slice := make([]int, 3)

Différences fonctionnelles

• tableau: Puisque la taille du tableau est fixe, la taille du tableau est connue au moment de la compilation, ce qui permet d'allouer de la mémoire pour le tableau sur la pile, et la complexité temporelle d'accès aux éléments du tableau est O(1).
• tranche: Le découpage offre plus de flexibilité enappend La fonction ajoute des éléments ou obtient des sous-tranches via des opérations de découpage.Le tableau sous-jacent de la tranche peut être alloué sur le tas, et la complexité temporelle d'accès aux éléments de la tranche est également O(1), maisappendPeut entraîner une réallocation du tableau sous-jacent, qui est généralement une opération O(n).

cartographie

Enfin, regardons la cartographie. Une carte est un tableau associatif dans Go qui mappe les clés aux valeurs. Les clés de la carte peuvent être de n'importe quel type pris en charge par l'opérateur d'égalité, tel que des entiers, des nombres à virgule flottante, des chaînes, des pointeurs, des interfaces (à condition que les valeurs contenues dans l'interface soient comparables), des structures et des tableaux. La valeur mappée peut être de n’importe quel type.

Déclaration et initialisation

déclarer la carte

La syntaxe pour déclarer une carte est la suivante :

var mapName map[keyType]valueType

Par exemple, déclarez une carte avec des clés sous forme de chaînes et des valeurs sous forme d'entiers :

var scores map[string]int

Initialiser la carte

Après avoir déclaré la carte, vous devez passermakefonction pour l'initialiser afin qu'il puisse être utilisé :

scores = make(map[string]int)

Alternativement, vous pouvez utiliser une courte déclaration et initialiser :

scores := make(map[string]int)

Vous pouvez également utiliser des littéraux pour l'initialisation au moment de la déclaration :

scores := map[string]int{
    "alice":  90,
    "bob":    85,
    "charlie": 88,
}

Caractéristiques de la carte

• unicité clé: Dans une carte, chaque clé est unique. Si vous essayez d'insérer une clé existante, cela mettra à jour la valeur correspondant à la clé.
• désordre:map n'est pas ordonné et l'ordre des éléments peut être différent à chaque itération de la carte.
• taille dynamique:La taille de la carte est dynamique, vous pouvez ajouter ou supprimer des paires clé-valeur selon vos besoins.
• Type de référence: Map est un type de référence lorsque vous transmettez map à une fonction, ce que vous transmettez en réalité est un pointeur vers la structure de données sous-jacente.

Carte des opérations

Ajouter un élément

scores["alice"] = 90

Obtenir l'élément

value := scores["alice"]

Si la clé n'existe pas, une valeur nulle pour ce type de valeur sera renvoyée.

Vérifiez si la clé existe

Vous pouvez utiliser l'idiome virgule -ok pour vérifier si la clé existe dans la carte :

value, exists := scores["alice"]
if exists {
    // 键存在
} else {
    // 键不存在
}

Supprimer l'élément

utiliserdeleteLa fonction peut supprimer une paire clé-valeur de la carte :

delete(scores, "alice")

Si la clé n'existe pas,deleteLa fonction ne fait rien.

Parcourez la carte

utiliserforUne boucle peut parcourir toutes les paires clé-valeur de la carte :

for key, value := range scores {
    fmt.Printf("%s: %dn", key, value)
}

valeur nulle de la carte

La valeur zéro de la carte estnil .unnil Une carte n'a pas de structure de données sous-jacente et ne peut pas ajouter d'éléments.Avant d'ajouter des éléments à la carte, vous devez utilisermakeInitialisez-le.

longueur de la carte

Vous pouvez utiliser lelenFonction pour obtenir le nombre de paires clé-valeur dans la carte :

length := len(scores)

type de clé de carte

Les clés de map peuvent être de n'importe quel type comparable, tel que des entiers, des nombres à virgule flottante, des chaînes, des pointeurs, des interfaces (à condition que les valeurs contenues dans l'interface soient comparables), des structures, des tableaux, etc. Les tranches, les cartes et les fonctions ne peuvent pas être utilisées comme clés de carte car ces types ne prennent pas en charge les comparaisons d'égalité.

Facile de faire des erreurs

Dans le langage Go, les tableaux, les tranches et les cartes sont trois structures de données couramment utilisées, chacune ayant des caractéristiques et des considérations différentes. Voici quelques points à noter lors de leur utilisation :

Tableau

• Évitez d'utiliser des tableaux trop volumineux, car ils occupent beaucoup d'espace dans la pile et peuvent provoquer un débordement de pile.
• Les tableaux sont utilisés lorsqu'une collection de données de taille fixe est requise.

Tranche

• Une réallocation de mémoire peut se produire lorsque le découpage est étendu. Essayez de pré-allouer suffisamment de capacité pour éviter une expansion fréquente.
• Évitez d'utiliser des tranches trop grandes car elles peuvent occuper beaucoup d'espace sur le tas.
• Notez que la valeur zéro de la tranche estnil, doit être initialisé avant utilisation.

carte

• La valeur zéro de la carte estnil，nilMap ne peut pas être utilisé pour stocker des paires clé-valeur et doit être initialisé avant utilisation.
• Dans un environnement simultané, les opérations de lecture et d'écriture sur la carte ne sont pas thread-safe et doivent être protégées à l'aide de verrous mutex ou d'autres mécanismes de synchronisation.
• utiliserdeleteSupprimer une clé qui n'existe pas ne génère pas d'erreur, mais il est possible de vérifier en toute sécurité si la clé existe.