Vérifier Plusieurs Conditions en JavaScript (OR/AND) est une compétence essentielle qui permet de créer des scripts plus robustes et dynamiques. En utilisant les opérateurs logiques OR (||) et AND (&&), vous pouvez contrôler le flux de votre code de manière fluide. Apprenons comment les utiliser à travers des exemples concrets de code.
Introduction aux Conditions (OR/AND) en JavaScript
Les opérateurs logiques en JavaScript sont utilisés pour vérifier plusieurs conditions en même temps. L’opérateur AND (&&) vérifie si toutes les conditions sont vraies, tandis que l’opérateur OR (||) vérifie si au moins une condition est vraie. Comprendre et utiliser ces opérateurs permet de concevoir des scripts plus précis et adaptés à diverses situations.
Utiliser l’Opérateur AND (&&) pour Vérifier Plusieurs Conditions
L’opérateur AND permet de vérifier que toutes les conditions spécifiées sont vraies avant de continuer l’exécution du script. Voici un exemple simple pour en comprendre l’utilisation :
const age = 25;
const hasDrivingLicense = true;
if (age >= 18 && hasDrivingLicense) {
console.log('Vous pouvez conduire.');
} else {
console.log('Vous ne pouvez pas conduire.');
}
Dans cet exemple, la condition est vraie si la personne a au moins 18 ans et possède un permis de conduire. Si l’une des conditions n’est pas remplie, l’autre bloque l’exécution de la condition entière.
Utiliser l’Opérateur OR (||) pour Vérifier Plusieurs Conditions
L’opérateur OR permet de vérifier que l’une des conditions spécifiées est vraie. Voici un exemple pratique :
const isWeekend = true;
const isVacation = false;
if (isWeekend || isVacation) {
console.log('Je peux me détendre aujourd\'hui.');
} else {
console.log('Je dois travailler aujourd\'hui.');
}
Dans cet exemple, si c’est le week-end ou si la personne est en vacances, elle peut se détendre. Il suffit qu’une des deux conditions soit vraie pour que l’ensemble de la condition soit valide.
Combiner les Opérateurs AND (&&) et OR (||) pour des Conditions Complexes
Il est souvent nécessaire de combiner les opérateurs AND et OR pour contrôler le flux de votre programme de manière plus complexe. Voici comment vous pouvez le faire :
const age = 20;
const hasParentalConsent = false;
const hasJob = true;
if ((age >= 18 && hasJob) || hasParentalConsent) {
console.log('Vous pouvez participer au programme.');
} else {
console.log('Vous ne pouvez pas participer au programme.');
}
Dans cet exemple, une personne peut participer au programme si elle a au moins 18 ans et un emploi, ou si elle a le consentement parental. Cela montre comment combiner les opérateurs pour vérifier des conditions imbriquées.
Utiliser les Conditions dans des Boucles
Les opérateurs logiques sont particulièrement utiles dans les boucles. Par exemple, voyons comment les utiliser dans une boucle for pour trouver des nombres pairs ou multiples de 5 :
for (let i = 1; i <= 20; i++) {
if (i % 2 === 0 || i % 5 === 0) {
console.log(i, 'est pair ou multiple de 5');
}
}
Ici, la boucle parcourt les nombres de 1 à 20 et affiche ceux qui sont pairs ou multiples de 5. Cela montre l'efficacité des opérateurs OR (||) dans les itérations.
Vérifier des Conditions dans les Fonctions
Les conditions logiques peuvent également être utilisées dans des fonctions pour renvoyer des valeurs ou exécuter des actions spécifiques. Par exemple :
function canVote(age) {
if (age >= 18) {
return 'Vous pouvez voter.';
} else {
return 'Vous ne pouvez pas voter.';
}
}
console.log(canVote(20));
console.log(canVote(16));
Dans cette fonction, nous vérifions simplement si la personne a 18 ans ou plus pour déterminer si elle peut voter.
Conclusion
Les opérateurs logiques OR/AND en JavaScript sont des outils puissants pour contrôler le flux de votre code. Que vous travailliez avec des conditions simples ou complexes, ils vous permettent de vérifier plusieurs situations de manière efficace. Continuez à expérimenter avec ces opérateurs pour voir comment ils peuvent simplifier et améliorer vos scripts. Pour en savoir plus sur JavaScript, consultez notre cours sur les fondamentaux de JavaScript.
Comprendre l'Utilisation des Conditions OR AND JavaScript
Lors de l'apprentissage des bases de JavaScript, il est essentiel de comprendre comment vérifier plusieurs conditions en utilisant les opérateurs OR et AND. Dans ce contexte, nous allons explorer plusieurs situations où ces opérateurs peuvent être combinés
Alternance Entre Operateurs Logiques
Utiliser l'alternance entre les opérateurs AND et OR dans une même condition peut sembler complexe, mais avec de la pratique, cela devient intuitif. Par exemple, considérons une situation où une personne doit remplir au moins une de plusieurs exigences pour passer une vérification :
const isCitizen = true;
const hasPassport = true;
const hasVisa = false;
if ((isCitizen && hasPassport) || hasVisa) {
console.log('Vous êtes autorisé à entrer.');
} else {
console.log('Vous n’êtes pas autorisé à entrer.');
}
Dans cet exemple, une personne peut entrer dans le pays si elle est citoyenne et possède un passeport, ou si elle possède un visa. Ce bloc de code démontre comment combiner efficacement les opérateurs AND et OR.
Pour approfondir vos connaissances sur les conditions en JavaScript, explorez notre guide consacré aux conditions if - else en JavaScript.
Les Grands Ensembles de Conditions Avec les Boucles
Manipuler les conditions logiques dans des boucles peut grandement simplifier vos algorithmes. Prenons un scenario classique :
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
for (let i = 0; i < numbers.length; i++) {
if (numbers[i] % 2 === 0 || numbers[i] % 3 === 0) {
console.log(numbers[i], 'est divisible par 2 ou par 3');
}
}
Ce morceau de code itère à travers un tableau de nombres et vérifie si chaque nombre est divisible par 2 ou 3, et affiche les nombres conformes. L'usage des opérateurs logiques OR (||) dans ce contexte simplifie grandement la logique de la boucle.
Apprenez à concaténer en JavaScript pour combiner plusieurs chaînes de caractères ou données diversité.
Les Applications Pratiques avec des Fonctions
Utilisons une fonction pratique pour examiner une condition complexe :
function canAccessWebsite(age, isVerified) {
if ((age >= 18 && isVerified) || age >= 21) {
return 'Accès autorisé';
} else {
return 'Accès refusé';
}
}
console.log(canAccessWebsite(20, true)); // Accès autorisé
console.log(canAccessWebsite(20, false)); // Accès refusé
console.log(canAccessWebsite(22, false)); // Accès autorisé
Dans cette fonction, une personne peut accéder à un site web si elle a au moins 18 ans et a vérifié son identité, ou si elle a 21 ans ou plus. Cet exemple illustre comment une fonction peut encapsuler et appliquer des conditions logiques complexes.
Pour en savoir plus sur la utilisation du débogueur en JavaScript, suivez notre tutoriel complet.
