TypeScript - Boolean : Guide du débutant pour la vérité et la falsité dans la programmation

Salut là, future superstar du codage ! Êtes-vous prêt à plonger dans le monde fascinant des booléens en TypeScript ? Ne vous inquiétez pas si vous n'avez jamais écrit une ligne de code auparavant - nous allons commencer dès le début et effectuer ce voyage ensemble. À la fin de ce tutoriel, vous serez un maître des booléens, capable de manier vrai et faux comme un magicien de la programmation !

Qu'est-ce qu'un booléen ?

Avant de rentrer dans les détails, parlons de ce qu'est réellement un booléen. En programmation, un booléen est un type de données qui ne peut prendre que deux valeurs : true ou false. C'est comme un interrupteur - il est soit allumé, soit éteint, sans rien entre les deux.

Imaginez que vous demandez à votre ami s'il veut aller au cinéma. Sa réponse ne peut être que "Oui" (true) ou "Non" (false). C'est exactement comment les booléens fonctionnent en programmation !

Syntaxe : Comment écrire des booléens en TypeScript

En TypeScript, écrire un booléen est aussi simple que de taper true ou false. Voici un exemple :

let estHeureux: boolean = true;
let estTriste: boolean = false;

Dans ce code, nous avons créé deux variables : estHeureux et estTriste. La variable estHeureux est définie sur true, tandis que estTriste est définie sur false.

Annotations de type : Dire à TypeScript ce à quoi s'attendre

Vous avez peut-être remarqué la partie : boolean dans notre exemple précédent. C'est ce qu'on appelle une annotation de type. C'est comme mettre une étiquette sur une boîte pour dire à tout le monde ce qu'il y a dedans. Quand nous écrivons : boolean, nous disons à TypeScript : "Attention, cette variable va être un booléen !"

Voici un autre exemple :

let pleut: boolean;
pleut = true;
// pleut = "Oui"; // Celawould causer une erreur !

Dans ce cas, nous avons déclaré pleut comme un booléen, mais nous ne lui avons pas encore donné de valeur. Plus tard, nous affectons true à cette variable, ce qui est tout à fait correct. Cependant, si nous essayions d'affecter une chaîne comme "Oui", TypeScript lancerait une erreur car "Oui" n'est pas une valeur booléenne.

Valeurs truthy et falsy : Quand les valeurs non booléennes agissent comme des booléens

Maintenant, c'est où les choses deviennent intéressantes ! En TypeScript (et JavaScript), certaines valeurs non booléennes peuvent être traitées comme si elles étaient des booléens. Nous appelons ces valeurs "truthy" et "falsy".

• Les valeurs falsy incluent : false, 0, '' (chaîne vide), null, undefined, et NaN.
• Tout le reste est considéré comme truthy.

Voyons cela en action :

if (1) {
console.log("1 est truthy !");
}

if ("") {
console.log("Cela ne sera pas affiché car une chaîne vide est falsy.");
}

Dans cet exemple, la première instruction if s'exécutera car 1 est truthy, mais la seconde ne le fera pas car une chaîne vide est falsy.

Conversion d'une valeur non booléenne en booléen

Parfois, vous pourriez vouloir convertir une valeur non booléenne en booléen. Il y a quelques façons de faire cela :

1. En utilisant la fonction Boolean() :

let num = 5;
let valeurBool = Boolean(num);
console.log(valeurBool); // Affiche : true

2. En utilisant l'opérateur de double négation (!!) :

let str = "Hello";
let valeurBool = !!str;
console.log(valeurBool); // Affiche : true

Les deux méthodes convertiront les valeurs truthy en true et les valeurs falsy en false.

Opérations booléennes : Combiner des booléens

Maintenant que nous savons comment créer des booléens, apprenons à les manipuler. Il y a trois principales opérations booléennes :

1. ET (&&) : Retourne true si les deux opérandes sont true.
2. OU (||) : Retourne true si au moins un des opérandes est true.
3. NON (!) : Inverse la valeur booléenne.

Voyons ces opérations en action :

let estAdulte = true;
let aPermis = false;

console.log(estAdulte && aPermis); // false
console.log(estAdulte || aPermis); // true
console.log(!estAdulte); // false

Dans cet exemple, estAdulte && aPermis est false car bien que estAdulte soit true, aPermis est false. estAdulte || aPermis est true car au moins l'un d'eux (estAdulte) est true. !estAdulte est false car c'est l'inverse de true.

Expressions conditionnelles avec des booléens

Les booléens sont souvent utilisés dans des instructions conditionnelles pour prendre des décisions dans notre code. Voici un exemple :

let age: number = 20;
let peutVoter: boolean = age >= 18;

if (peutVoter) {
console.log("Tu peux voter !");
} else {
console.log("Désolé, tu es trop jeune pour voter.");
}

Dans ce code, nous vérifions si age est supérieur ou égal à 18. Si c'est le cas, peutVoter sera true, et la personne peut voter. Sinon, peutVoter sera false, et elle ne peut pas voter.

Boolean en TypeScript vs boolean

Vous pourriez parfois voir Boolean (avec une majuscule) dans le code TypeScript. Cela fait référence à l'objet Boolean, qui est différent du type primitif boolean que nous avons utilisé.

let booleanPrimitif: boolean = true;
let objetBoolean: Boolean = new Boolean(true);

En général, il est recommandé d'utiliser le type primitif boolean sauf si vous avez une raison spécifique d'utiliser l'objet Boolean.

Propriétés et méthodes booléennes

Bien que le type primitif boolean n'ait pas de propriétés ou de méthodes, l'objet Boolean en a quelques-unes. Voici quelques-unes :

Propriété/Méthode	Description
Boolean.prototype.toString()	Retourne "true" ou "false"
Boolean.prototype.valueOf()	Retourne la valeur primitive de l'objet Boolean

Voici comment vous pourriez les utiliser :

let boolObj = new Boolean(true);
console.log(boolObj.toString()); // Affiche : "true"
console.log(boolObj.valueOf()); // Affiche : true

Et voilà ! Vous avez刚刚 effectué un tour d'horizon des booléens en TypeScript. Souvenez-vous, les booléens peuvent sembler simples, mais ils sont les briques de la logique en programmation. Chaque fois que vous utilisez une instruction if ou une boucle, vous travaillez avec des booléens en arrière-plan.

Alors continuez à pratiquer, restez curieux, et souvenez-vous : dans le monde des booléens, il n'y a pas de peut-être - seulement vrai ou faux. Bon codage !

Credits: Image by storyset