Les Cartes en Go

Introduction aux Cartes

Les cartes (ou maps en anglais) sont une structure de données intégrée en Go, permettant de stocker un ensemble désordonné de paires clé-valeur. Chaque paire peut être de types identiques ou variés, et la carte est en fait une forme de table de hachage, offrant des performances optimales pour l'accès, l'insertion et la suppression.

Syntaxe des Cartes

Pour créer une carte vide, vous pouvez utiliser la fonction make() et l'assigner à une variable comme suit :

variable_name := make(map[key_data_type]value_data_type)

Il est également possible de créer une carte vide en utilisant une "carte littérale" :

variable_name := map[key_data_type]value_data_type{}

Initialisation d'une Carte

Il est possible d'initialiser une carte avec des paires clé-valeur dès sa déclaration. Voici un exemple :

map_name := map[key_data_type]value_data_type{
  key-1: value-1,
  key-2: value-2,
  key-N: value-N,
}

N'oubliez pas de séparer toutes les paires par une virgule, même la dernière, sauf si l'initialisation se fait sur une seule ligne.

Accès aux Éléments

Pour accéder à une valeur dans une carte, vous devez utiliser la clé correspondante entre crochets :

map_name[key_value]

Vous pouvez également enregistrer cette valeur dans une variable :

variable_name := map_name[key_value]

En cas d'absence de la clé, le type de valeur zéro est retourné (par exemple : int : 0, bool : false).

Ajout et Suppression d'Éléments

Pour ajouter de nouvelles paires clé-valeur dans la carte, il suffit de procéder ainsi :

map_name[new_key] = new_value

Il est possible de supprimer des paires clé-valeur avec la fonction intégrée delete() :

delete(map_name, existing_key)

Exemples de Code

Déclaration d'une Carte Vide

package main
import "fmt"
func main() {
  // Création d'une carte vide
  emptyMap := make(map[string]int)
  // Affichage de la carte
  fmt.Println(emptyMap)
}

Ce code affichera : map[].

Déclaration d'une Carte avec Valeurs

package main
import "fmt"
func main() {
  // Initialiser la carte gradebook avec des valeurs
  gradebook := map[string]float32{"John": 85.2, "Ana": 95.6}
  // Affichage de la carte gradebook
  fmt.Println(gradebook)
}

Ce code affichera : map[John:85.2 Ana:95.6].

Accès aux Éléments

// Afficher la valeur pour la clé "John"
fmt.Println(gradebook["John"])

Ce code affichera : 85.2.

Itération sur toutes les Paires Clé/Valeur

// Itérer sur toutes les paires de gradebook
for key, value := range gradebook {
  fmt.Printf("(%s, %.1f)\n", key, value)
}

Ce code affichera : (John, 85.2)(Ana, 95.6).

Enregistrement d'une Valeur dans une Variable

// Stocker la valeur associée à la clé "Ana"
anaScore := gradebook["Ana"]
fmt.Println(anaScore)

Ce code affichera : 95.6.

Accès à une Clé Inexistante

// Accéder à la valeur pour la clé "David"
johnScore := gradebook["David"]
// Puisque "David" n'existe pas, 0 sera affiché
fmt.Println(johnScore)

Ce code affichera : 0.

Ajout de Valeurs

// Afficher la carte initialisée
gradebook["George"] = 76.4
gradebook["Emma"] = 90
fmt.Println(gradebook)

Ce code affichera : map[Ana:95.6 Emma:90 George:76.4 John:85.2].

Suppression de Valeurs

// Afficher la carte initialisée
delete(gradebook, "John")
fmt.Println(gradebook)

Ce code affichera : map[Ana:95.6 Emma:90 George:76.4].

Utilisation des Cartes pour le Développement Web

L'utilisation de cartes dans vos projets web peut être très avantageuse. Par exemple, si vous construisez une application de type tableau de bord, vous pouvez utiliser des cartes pour stocker les paramètres de configuration ou les réponses d'API avec les identifiants des utilisateurs comme clés. Cela simplifie l'accès à des données complexes et améliore la gestion des données, surtout lorsque vous développez des fonctionnalités comme les profils utilisateurs ou les historiques de commandes. En optimisant les accès aux données via des clés, votre application sera plus performante et réactive, ce qui est essentiel pour l'expérience utilisateur.