Menu
Coddy logo textTech
COMMENCER À APPRENDRE
flag Fr iconFrançaisdown icon

Chaînes de caractères (Strings)

Fait partie de la section Fondamentaux du Journey GO de Coddy — leçon 10 sur 109.

Les chaînes de caractères (strings) en Go sont utilisées pour stocker des données textuelles. Apprenons à les manipuler étape par étape.

Tout d'abord, créons une variable de type chaîne de caractères en utilisant le mot-clé var avec une déclaration de type explicite :

var message string = "Hello, Go!"
fmt.Println(message)

Après l'exécution de ce code, le texte Hello, Go! s'affichera à l'écran. Nous avons créé une variable de type chaîne nommée message et affiché sa valeur.

Maintenant, créons une chaîne de caractères en utilisant la syntaxe de déclaration courte de Go avec :=, qui déduit automatiquement le type :

greeting := "Welcome to Go programming"
fmt.Println(greeting)

Après l'exécution de ce code, le texte Welcome to Go programming s'affichera à l'écran. L'opérateur := crée une nouvelle variable et détermine son type en fonction de la valeur fournie.

Les deux méthodes accomplissent la même chose : elles créent des variables de type chaîne qui stockent du texte. La syntaxe de déclaration courte (:=) est plus couramment utilisée en Go car elle est concise et pratique.

challenge icon

Défi

Débutant

Dans ce défi, vous allez vous entraîner à manipuler des chaînes de caractères en Go.

Nous avons déjà configuré deux variables de type chaîne : firstName et lastName. Votre tâche consiste à :

  1. Créer une troisième variable de type chaîne nommée greeting avec la valeur "Hello, my name is " (notez l'espace à la fin après "is")
  2. Afficher chacune des trois chaînes sur des lignes distinctes en utilisant fmt.Println()

Aide-mémoire

Les chaînes de caractères en Go stockent des données textuelles. Créez des variables de type string en utilisant la déclaration de type explicite :

var message string = "Hello, Go!"
fmt.Println(message)

Ou utilisez la syntaxe de déclaration courte avec := pour l'inférence de type automatique :

greeting := "Welcome to Go programming"
fmt.Println(greeting)

L'opérateur := est plus couramment utilisé car il est concis et pratique.

Essayez vous-même

package main

import "fmt"

func main() {
	// Ces variables sont déjà définies pour vous
	firstName := "Alex"
	lastName := "Smith"
	
	// TODO : Créer une variable de chaîne de salutation avec la valeur "Hello, my name is"
	
	// TODO : Afficher les trois chaînes (greeting, firstName et lastName) sur des lignes séparées
	
}
quiz iconTestez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Fondamentaux

1Introduction à Go

Qu'est-ce que Go ?Hello WorldPrintlnCommentaires Go

4Opérateurs de comparaison et logiques

Opérateurs de comparaison - Partie 1Opérateurs de comparaison - Partie 2Opérateur logique ANDOpérateur logique OROpérateur logique NOTBases de la priorité des opérateursRécapitulatif - Effectuer des comparaisons

7Structures de contrôle : Les boucles

Explication de la boucle `for`Boucle For - Les basesBoucle For - Condition uniquementLe mot-clé `break`Le mot-clé `continue`Boucles imbriquéesRécapitulatif - Répéter des actions

10Types composites : Tableaux

Introduction aux tableauxDéclaration de tableauxInitialisation de tableauxAccès aux éléments d'un tableauTaille d'un tableau avec `len`Itération sur les tableauxTableaux multidimensionnels

13Types composites : Structures

Définition de types personnalisésCréation d'instances de structuresAccès aux champs d'une structurePointeurs vers des structuresInitialisation de structuresStructures imbriquéesStructures anonymesRécapitulatif - Structures de données personnalisées

2Variables et types de données de base

Qu'est-ce qu'une variableInférence de type avec `:=` Entiers (int)Nombres à virgule flottanteBooléensChaînes de caractères (Strings)Valeurs zéroConstantesConventions de nommageRécapitulatif - Variables et types

5Entrées/Sorties de base

Sortie formatéeVerbes de formatageAffichage des typesSaisie utilisateur de baseRécapitulatif - Entrées et Sorties

8Fonctions

Comprendre les fonctionsDéclarer une fonctionAppeler des fonctionsParamètres de fonctionRetourner une valeur uniqueRetourner plusieurs valeursValeurs de retour nomméesBases de la portée des fonctionsRécapitulatif - Créer du code réutilisable

11Types composites : Slices

Introduction aux SlicesDéclaration de littéraux de SlicesCréation de Slices avec `make`Longueur vs Capacité des SlicesAccès aux éléments d'un SliceAjout d'élémentsDécoupage de Slices/Tableaux existantsItération sur les SlicesCopie de SlicesRécapitulatif - Listes dynamiques

14Gestion de base des erreurs

Le concept d'erreurL'interface `error`Fonctions retournant des erreursVérification des erreursCréation d'erreurs simplesCréation d'erreurs formatéesGestion de base des erreursRécapitulatif - Gérer les problèmes

3Opérateurs de base

Opérateurs arithmétiquesOpérateur de divisionL'opérateur moduloOpérateur d'affectationOpérateurs d'affectation augmentéeIncrémentation et décrémentationRécapitulatif - Calculs

6Structure de contrôle : Les conditionnelles

L'instruction `if`Le mot-clé `else`Le mot-clé `else if`Masquage de variable dans `if`Initialisation des variablesL'instruction `switch``switch` avec expressions`switch` sans expressionLe mot-clé `fallthrough`Récapitulatif - Prendre des décisions

9Pointeurs

Qu'est-ce qu'un pointeur ?Déclaration de variables pointeursL'opérateur d'adresseDéréférencement de pointeursUtiliser des pointeurs dans les fonctionsPointeurs NilRécapitulatif - Comprendre les pointeurs

12Types composites : Maps

Introduction aux MapsDéclaration de littéraux de MapCréation de Maps avec `make`Ajout et mise à jour de paires clé-valeurAccès aux valeurs d'une MapVérification de l'existence d'une cléSuppression d'entrées de MapTaille d'une MapItération sur les MapsRécapitulatif - Stockage clé-valeur