Menu

Tech

COMMENCER À APPRENDRE

Français

Booléens

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

Les booléens en Go stockent des valeurs vrai/faux en utilisant le type de données bool.

Déclarons une variable booléenne en utilisant la syntaxe de déclaration courte := :

isActive := true
fmt.Println("Is active:", isActive)

Après l'exécution de ce code, la valeur Is active: true s'affichera à l'écran. Nous avons créé une variable booléenne qui contient la valeur true.

Maintenant, créons une autre variable booléenne avec une valeur false :

isComplete := false
fmt.Println("Is complete:", isComplete)

Après l'exécution de ce code, la valeur Is complete: false s'affichera à l'écran. Cela démontre que les variables booléennes peuvent contenir soit des valeurs true, soit des valeurs false.

Voyons ce qui se passe lorsque nous affichons les deux variables booléennes ensemble :

isActive := true
isComplete := false
fmt.Println("Is active:", isActive)
fmt.Println("Is complete:", isComplete)

Après l'exécution de ce code, nous verrons les deux valeurs s'afficher l'une après l'autre à l'écran :

Is active: true
Is complete: false

Défi

Débutant

Dans ce défi, vous allez travailler avec des valeurs booléennes en Go. Les valeurs booléennes ne peuvent être que true ou false.

Nous avons commencé avec deux variables booléennes : likesGo et firstProgram. Votre tâche consiste à :

Créez une nouvelle variable booléenne appelée isLearning et définissez-la sur true
Créez une autre variable booléenne appelée isExpert et définissez-la sur false

Ensuite, affichez les quatre variables booléennes pour voir leurs valeurs.

Aide-mémoire

Les booléens en Go stockent des valeurs vrai/faux en utilisant le type de données bool.

Déclarer des variables booléennes :

isActive := true
isComplete := false

Afficher les valeurs booléennes :

fmt.Println("Is active:", isActive)
fmt.Println("Is complete:", isComplete)

Les variables booléennes ne peuvent contenir que des valeurs true ou false.

Essayez vous-même

package main

import "fmt"

func main() {
	// Deux variables booléennes sont déjà définies
	likesGo := true
	firstProgram := false
	
	// TODO : Créer une variable booléenne appelée 'isLearning' et la définir sur true
	
	// TODO : Créer une variable booléenne appelée 'isExpert' et la définir sur false
	
	// Afficher toutes les variables booléennes
	fmt.Println("Likes Go:", likesGo)
	fmt.Println("First program:", firstProgram)
	fmt.Println("Is learning:", isLearning)
	fmt.Println("Is expert:", isExpert)
}

Testez-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 World Println Commentaires Go

4Opérateurs de comparaison et logiques

Opérateurs de comparaison - Partie 1 Opérateurs de comparaison - Partie 2 Opérateur logique AND Opérateur logique OR Opérateur logique NOT Bases de la priorité des opérateurs Récapitulatif - Effectuer des comparaisons

7Structures de contrôle : Les boucles

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

10Types composites : Tableaux

Introduction aux tableaux Déclaration de tableaux Initialisation de tableaux Accès aux éléments d'un tableau Taille d'un tableau avec `len`Itération sur les tableaux Tableaux multidimensionnels

13Types composites : Structures

Définition de types personnalisés Création d'instances de structures Accès aux champs d'une structure Pointeurs vers des structures Initialisation de structures Structures imbriquées Structures anonymes Récapitulatif - Structures de données personnalisées

2Variables et types de données de base

Qu'est-ce qu'une variable Inférence de type avec `:=` Entiers (int)Nombres à virgule flottanteBooléensChaînes de caractères (Strings)Valeurs zéro Constantes Conventions de nommage Récapitulatif - Variables et types

5Entrées/Sorties de base

Sortie formatée Verbes de formatage Affichage des types Saisie utilisateur de base Récapitulatif - Entrées et Sorties

8Fonctions

Comprendre les fonctions Déclarer une fonction Appeler des fonctions Paramètres de fonction Retourner une valeur unique Retourner plusieurs valeurs Valeurs de retour nommées Bases de la portée des fonctions Récapitulatif - Créer du code réutilisable

11Types composites : Slices

Introduction aux Slices Déclaration de littéraux de Slices Création de Slices avec `make`Longueur vs Capacité des Slices Accès aux éléments d'un Slice Ajout d'éléments Découpage de Slices/Tableaux existants Itération sur les Slices Copie de Slices Récapitulatif - Listes dynamiques

14Gestion de base des erreurs

Le concept d'erreur L'interface `error`Fonctions retournant des erreurs Vérification des erreurs Création d'erreurs simples Création d'erreurs formatées Gestion de base des erreurs Récapitulatif - Gérer les problèmes

3Opérateurs de base

Opérateurs arithmétiques Opérateur de division L'opérateur modulo Opérateur d'affectation Opérateurs d'affectation augmentée Incrémentation et décrémentation Ré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 variables L'instruction `switch``switch` avec expressions `switch` sans expression Le mot-clé `fallthrough`Récapitulatif - Prendre des décisions

9Pointeurs

Qu'est-ce qu'un pointeur ?Déclaration de variables pointeurs L'opérateur d'adresse Déréférencement de pointeurs Utiliser des pointeurs dans les fonctions Pointeurs Nil Récapitulatif - Comprendre les pointeurs

12Types composites : Maps

Introduction aux Maps Déclaration de littéraux de Map Création de Maps avec `make`Ajout et mise à jour de paires clé-valeur Accès aux valeurs d'une Map Vérification de l'existence d'une clé Suppression d'entrées de Map Taille d'une Map Itération sur les Maps Récapitulatif - Stockage clé-valeur