Guide débutant sur les tranches en Go

Bonjour à tous, futurs programmeurs Go ! Aujourd'hui, nous plongeons dans une des structures de données les plus polyvalentes et puissantes de Go : les tranches (slices). Pensez aux tranches comme aux couteaux suisses de la programmation Go - elles sont flexibles, efficaces, et une fois que vous les maîtriserez, vous vous demanderez comment vous avez pu coder sans elles !

Qu'est-ce qu'une tranche ?

Avant de commencer, mettons les choses en place. Imaginez que vous organisez une fête (une fête de codage, bien sûr !). Vous avez besoin d'une liste d'invités, mais vous ne savez pas combien de personnes viendront. C'est là que les tranches brillent ! Elles sont comme des listes d'invités dynamiques qui peuvent croître ou se réduire selon les besoins.

En Go, une tranche est une vue flexible et dynamique sur un tableau. C'est comme une fenêtre qui peut ajuster sa taille, vous permettant de travailler avec une partie d'un tableau ou même de créer complètement un nouveau tableau sur le fly.

Définir une tranche

Commençons par créer notre première tranche. Il y a plusieurs façons de le faire, explorons-les une par une.

Méthode 1 : Utiliser la fonction make()

guestList := make([]string, 3)
fmt.Println(guestList) // Output : [  ]

Dans cet exemple, nous avons créé une tranche de chaînes avec une longueur initiale de 3. C'est comme préparer trois chaises vides pour notre fête. La fonction make() est notre organisateur de fête, préparant l'espace pour nos invités.

Méthode 2 : Utiliser une tranche littérale

guestList := []string{"Alice", "Bob", "Charlie"}
fmt.Println(guestList) // Output : [Alice Bob Charlie]

Ici, nous créons une tranche et la remplissons immédiatement avec des invités. C'est comme avoir une liste VIP prête à l'emploi !

Méthode 3 : Trancher un tableau existant

partyRoom := [5]string{"Alice", "Bob", "Charlie", "David", "Eve"}
vipGuests := partyRoom[0:3]
fmt.Println(vipGuests) // Output : [Alice Bob Charlie]

Dans ce cas, nous créons une tranche à partir d'un tableau existant. C'est comme sélectionner les trois premières personnes de notre salle de fête pour être sur la liste VIP.

Fonctions len() et cap()

Maintenant que nous avons nos listes d'invités, parlons de deux fonctions importantes : len() et cap().

guestList := make([]string, 3, 5)
fmt.Printf("Longueur : %d, Capacité : %d\n", len(guestList), cap(guestList))
// Output : Longueur : 3, Capacité : 5

• len() nous dit combien d'invités sont actuellement sur notre liste.
• cap() nous dit combien d'invités notre liste peut contenir avant qu'elle doive grandir.

Pensez à len() comme au nombre de chaises actuellement installées, et à cap() comme au nombre total de chaises disponibles dans la salle de fête.

Tranche nil

Parfois, vous pourriez déclarer une tranche mais ne pas l'initialiser. Cela s'appelle une tranche nil.

var emptyList []string
fmt.Println(emptyList == nil) // Output : true

Une tranche nil est comme avoir une idée de liste d'invités mais ne pas encore créer la liste. C'est parfaitement valide et peut être utile dans certaines situations !

Sous-tranchage

Le sous-tranchage est comme créer une section VIP au sein de votre fête. Vous pouvez sélectionner une partie d'une tranche existante pour en créer une nouvelle.

fullGuestList := []string{"Alice", "Bob", "Charlie", "David", "Eve"}
vipGuests := fullGuestList[1:4]
fmt.Println(vipGuests) // Output : [Bob Charlie David]

Ici, nous sélectionnons des invités de l'index 1 à 3 (souvenez-vous, l'index final est exclusif) pour être nos VIPs.

Fonctions append() et copy()

append()

La fonction append() est comme avoir un videur qui peut ajouter de nouveaux invités à votre fête.

guestList := []string{"Alice", "Bob"}
guestList = append(guestList, "Charlie")
fmt.Println(guestList) // Output : [Alice Bob Charlie]

Vous pouvez même ajouter plusieurs invités à la fois :

guestList = append(guestList, "David", "Eve")
fmt.Println(guestList) // Output : [Alice Bob Charlie David Eve]

copy()

La fonction copy() est comme avoir un organisateur de fête qui peut dupliquer votre liste d'invités.

originalList := []string{"Alice", "Bob", "Charlie"}
newList := make([]string, len(originalList))
copiedElements := copy(newList, originalList)
fmt.Printf("Copiés %d éléments. Nouvelle liste : %v\n", copiedElements, newList)
// Output : Copiés 3 éléments. Nouvelle liste : [Alice Bob Charlie]

Table des méthodes de tranche

Voici un tableau pratique résumant les méthodes de tranche clés que nous avons discutées :

Méthode	Description	Exemple
make()	Crée une tranche	make([]int, 5)
len()	Retourne la longueur d'une tranche	len(slice)
cap()	Retourne la capacité d'une tranche	cap(slice)
append()	Ajoute des éléments à une tranche	slice = append(slice, 1, 2, 3)
copy()	Copie des éléments d'une tranche à une autre	copy(destSlice, sourceSlice)
Sous-tranchage	Crée une nouvelle tranche à partir d'une existante	newSlice := slice[1:4]

Et voilà, amis ! Vous avez fait vos premiers pas dans le merveilleux monde des tranches Go. Souvenez-vous, la pratique rend parfait, donc n'ayez pas peur d'expérimenter avec ces concepts. Créez vos propres listes d'invités, jouez avec l'ajout et la copie, et bientôt vous trancherez et découpez du code Go comme un pro !

Bonne programmation, et puissent vos tranches être toujours parfaitement ajustées à vos besoins !

Credits: Image by storyset