Comparaisons d'egalite en Programmation

Salut HaWker ! Jeff Bruchado par ici.

C'est un autre article de notre serie d'articles qui va couvrir notre voyage pour Apprendre la Programmation depuis Zero.

Aujourd'hui ce sera un article sur un autre contenu extremement important pour poursuivre votre apprentissage.

Alors, s'il vous plait ! Si vous ne maitrisez pas ce dont je vais parler aujourd'hui, lisez jusqu'a la fin !

Bon, sans plus tarder, commencons !

Aujourd'hui, nous allons parler d'un sujet super utilise en Programmation : les Comparaisons d'egalite (Equality Comparisons).

Les Comparaisons d'egalite, ou en anglais Equality Comparisons sont utilisees pour verifier si deux valeurs sont egales ou differentes.

Il existe deux facons de realiser des comparaisons d'egalite :

L'operateur d'egalite simple (==) et l'operateur d'egalite stricte (===).

Comprenons chacun d'eux en detail.

Operateur d'egalite simple (==)

L'operateur d'egalite simple (==) est utilise pour verifier si deux valeurs sont egales.

Avant de realiser la comparaison, l'operateur simple tente de convertir les valeurs vers le meme type avant de faire la comparaison.

Par exemple :

console.log(1 == 1); // true
console.log('1' == 1); // true
console.log(true == 1); // true
console.log(null == undefined); // true
console.log([] == false); // true

Comme nous pouvons le voir dans l'exemple ci-dessus, l'operateur d'egalite simple (==) tente de convertir les valeurs vers le meme type avant de faire la comparaison.

Dans le premier exemple, 1 est compare avec 1 et les deux sont du meme type (number), donc la comparaison est vraie.

Dans le deuxieme exemple, '1' (string) est comparee avec 1 (number) et sont converties vers le meme type (number) avant la comparaison, donc la comparaison est vraie.

Dans le troisieme exemple, true (boolean) est compare avec 1 (number) et sont convertis vers le meme type (number) avant la comparaison, donc la comparaison est vraie.

Dans le quatrieme exemple, null (une valeur de reference nulle) est compare avec undefined (une valeur de reference non definie) et sont consideres egaux, donc la comparaison est vraie.

Dans le cinquieme exemple, [] (un array vide) est compare avec false (une valeur booleenne) et sont convertis vers le meme type (number) avant la comparaison, donc la comparaison est vraie.

Bon HaWker, comme vous pouvez le constater, ce contenu a une densite d'informations relativement elevee.

Et il est courant que vous vous sentiez confus avec beaucoup d'informations.

Pour cela, rappelez-vous que si vous avez des questions, envoyez-moi toujours votre question en reponse a ces articles.

Je vais toujours essayer de vous aider de la meilleure facon possible.

Je suis la pour vous aider a evoluer et progresser dans votre carriere.

Je me donne beaucoup de mal pour garantir que je reussis a passer toutes les informations necessaires concentrees dans cet article.

Mais si vous voulez avoir acces a quelque chose de plus, et avoir acces au contenu complet de toute la sequence que vous allez recevoir au fil du temps.

Vous pouvez cliquer sur ce lien, sans engagement, j'insiste que c'est seulement **si vous voulez vraiment accelerer votre developpement a travers des exercices pratiques et tous les contenus organises et separes dans un seul endroit, divises en degres de priorite, entre ce que vous devez apprendre et ce qui n'est pas si necessaire au debut de ce voyage.

Je vous garantis que cela va beaucoup accelerer vos etudes.

Enfin, etant donne le message pour ceux qui veulent accelerer leur developpement dans le domaine, continuons le contenu et comprenons l'Operateur d'egalite stricte (===).

Operateur d'egalite stricte (===)

L'operateur d'egalite stricte (===) est utilise pour verifier si deux valeurs sont egales et du meme type.

Il ne tente pas de convertir les valeurs vers le meme type avant de faire la comparaison.

Par exemple :

console.log(1 === 1); // true
console.log('1' === 1); // false
console.log(true === 1); // false
console.log(null === undefined); // false
console.log([] === false); // false

Comme nous pouvons le voir dans l'exemple ci-dessus, l'operateur d'egalite stricte (===) ne tente pas de convertir les valeurs vers le meme type avant de faire la comparaison.

Dans le premier exemple, 1 est compare avec 1 et les deux sont du meme type (number) et valeur, donc la comparaison est vraie.

Dans le deuxieme exemple, '1' (une string) est comparee avec 1 (number) et, comme ils sont de types differents, la comparaison est fausse.

Dans le troisieme exemple, true (une valeur boolean) est compare avec 1 (un number) et, comme ils sont de types differents, la comparaison est fausse.

Dans le quatrieme exemple, null (une valeur de reference nulle) est compare avec undefined (une valeur de reference non definie) et, bien qu'ils soient consideres egaux par l'operateur d'egalite simple, ils sont de types differents, donc la comparaison est fausse.

PS : Si vous ne comprenez pas les differents Types de Donnees, accedez a l'un des articles precedents qui parle des Types de Donnees et relisez-le.

Dans le cinquieme exemple, [] (un array vide) est compare avec false (une valeur boolean) et, comme ils sont de types differents, la comparaison est fausse.

Conclusion

En resume, l'operateur d'egalite stricte (===) est generalement considere plus sur que l'operateur d'egalite simple (==), car il ne tente pas de convertir les valeurs vers le meme type avant la comparaison.

Il est recommande de toujours utiliser l'operateur d'egalite stricte, a moins que vous ayez une bonne raison d'utiliser l'operateur d'egalite simple.

Eh bien HaWker, nous arrivons a la fin d'un autre article.

J'espere que cet article a ajoute a votre repertoire de connaissances sur la Programmation.

Comme toujours, si vous avez une question ou voulez explorer un point plus en detail, repondez simplement a votre question dans cet email.

Et rappelez-vous, je suis la pour vous aider a vous ameliorer de 1% a chaque nouvel article !

Sensationnel HaWker !

Si vous etes arrive jusqu'ici, comme d'habitude, s'il vous plait, repondez a cet email avec "J'ai reussi a comprendre les Comparaisons d'Egalite en Programmation".

Ainsi je saurai que cette serie d'articles vous est utile, et que vous suivez et profitez.

Comme vous le savez deja ! Seul un veritable HaWker arrive jusqu'a la fin.

Felicitations !

Je suis content de vous avoir ici.

A bientot.

C'est parti !

- Jeff Bruchado

Felicitations d'etre arrive jusqu'ici, HaWker !

A ce moment ou vous avez appris les comparaisons d'egalite en programmation, que diriez-vous de tester vos connaissances ? Participez au quiz ci-dessous et voyez combien vous avez absorbe de notre article.

C'est une excellente facon de consolider l'apprentissage et de vous preparer pour les prochaines etapes de votre voyage de programmation.

Appuyez pour acceder au quiz.

Bonne chance et amusez-vous !