Utilisations flexibles du ET logique (&&) et du OU (||) en JavaScript

Introduction

Les valeurs booléennes sont absolues, vraies ou fausses. C’est aussi clair que possible. D'autres types de données en JavaScript ont également ces valeurs inhérentes de vrai et faux, mais ce n'est pas aussi évident car elles ressemblent à 32, null, 0 et « Bonjour » au lieu de vrai et faux. Sachant que toutes les valeurs ont ces valeurs inhérentes, cela signifie que nous pouvons effectuer des opérations sur tous les types de données généralement utilisés pour les booléens. Cela nous offre plus de créativité et de flexibilité lors du codage.

Comprendre les valeurs vraies et fausses

Lorsque nous travaillons avec des mots-clés de flux de contrôle comme if et des opérateurs logiques comme AND (&&) et OR (||), nous utilisons des booléens pour obtenir certains résultats. Ces booléens peuvent être utilisés explicitement avec true ou false, mais nous les générons souvent avec des opérateurs de comparaison tels que ===, < et >.

Que se passe-t-il si nous n'utilisons pas de booléen avec un flux de contrôle ou des opérateurs logiques ? Eh bien, vous avez de la chance ! Toutes les valeurs sont intrinsèquement vraies ou fausses pour vous aider. Nous pouvons classer toutes les valeurs en deux catégories : véridique ou faux.

Lorsque vous essayez de déterminer si une valeur est vraie ou fausse, il est préférable de se souvenir des valeurs fausses car il n'y en a qu'un nombre limité :

• false (une valeur booléenne)
• nul
• indéfini
• NaN (pas un nombre)
• 0 (une valeur numérique)
• "" (la valeur de chaîne vide)

Tout le reste est véridique. Si vous ne savez pas si quelque chose est vrai ou faux ou si vous rencontrez une situation unique qui semble ambiguë, vous pouvez toujours créer une instruction if pour voir si le code à l'intérieur du bloc de code suivant s'exécute.

if (23) { console.log(“truthy”); } // Prints “truthy”
else { console.log(“falsy”); }

if (null) { console.log(“truthy”); } 
else { console.log(“falsy”); } // Prints “falsy”

ET logique (&&)

Lorsque vous utilisez des booléens avec le ET logique (&&), les deux valeurs doivent être vraies pour que l'opérateur logique renvoie vrai. Sinon, si au moins une valeur est fausse, elle renverra faux.

console.log(false && false); // false
console.log(true && false); // false
console.log(true && true); // true

Comprendre les mécanismes de l'opérateur logique ET (&&) peut vous aider lorsqu'il s'agit de valeurs véridiques et fausses. Si la valeur de gauche est fausse, renvoyez-la ; sinon, renvoie la valeur à droite.

console.log(0 && 1); // 0
console.log("a" && ""); // "" (an empty string)
console.log([] && [1, 2, 3]); // [1, 2, 3]

L'opérateur logique ET (&&) veut renvoyer une valeur fausse et ne renvoie la valeur véridique à droite que si les deux sont véridiques. Vous pouvez penser aux deux arguments comme ceci :

(Côté gauche) N'utilisez-moi que si je suis une fausse valeur. && (Côté droit) Sinon, utilisez-moi.

OU logique (||)

Lorsque vous utilisez des booléens avec le OU logique (||), les deux valeurs doivent être fausses pour que l'opérateur logique renvoie faux. Sinon, si au moins une valeur est vraie, elle renverra vrai.

console.log(false || false); // false
console.log(true || false); // true
console.log(true || true); // true

Voici comment fonctionne l'opérateur logique OU (||) : si la valeur de gauche est vraie, renvoyez-la ; sinon, renvoie la valeur à droite.

console.log(1 || 0); // 1
console.log("" || "a"); // "a"
console.log(undefined || null); // null
console.log([] || [1, 2, 3]); // []

L'opérateur logique OU (||) veut renvoyer une valeur véridique et ne renvoie la valeur fausse à droite que si les deux sont fausses. Vous pouvez penser aux deux arguments comme ceci :

(Côté gauche) Utilisez-moi uniquement si je suis une valeur véridique. || (Côté droit) Sinon, utilisez-moi.

Utilisations créatives de AND (&&) et OR (||)

Utilisation d'une valeur par défaut lors de l'attente d'une entrée

Disons que vous créez un objet qui représente une personne doté de propriétés décrivant la personne ainsi que d'une fonction qui salue les autres en utilisant les autres propriétés de l'objet.

function Person(name) {
    // If name is undefined, this.name will 
    // default to 'a person with no name'
    this.name = name || 'a person with no name';
    this.greet = function() {
        console.log('Hello, I am ' + this.name + '.');
    };
}

// Create Person variables
var tyler = new Person('Tyler');
var mystery = new Person(); 
// Without an input, this.name defaults to the 
// second option since name is undefined.

// Call greet() from each Person object
tyler.greet(); // "Hello, I am Tyler."
mystery.greet(); // "Hello, I am a person with no name."

Dans l'exemple ci-dessus, nous attendions une entrée pour le paramètre name, donc la deuxième valeur de l'opération OR (||) n'est utilisée que si le nom n'est pas défini (aucun argument lors de l'appel de fonction).

Nécessitant plusieurs entrées

Si vous créez des objets et souhaitez vous assurer que vous disposez d'un nombre défini d'entrées avant de créer l'objet, vous pouvez enchaîner les opérateurs logiques ET (&&) pour chaque paramètre requis.

function Person(firstName, lastName, age) {
  if (firstName && lastName && age) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.fullName = `${this.firstName} ${this.lastName}`;
    this.age = age;
    this.greet = function() {
      console.log(`Hello, my name is ${this.fullName} and I'm ${this.age} years old.`);
    };
  } 

  // If any argument is missing, the object will only have this property.
  else {
    this.greet = function() {
      console.log(`Hello, I am not a fully formed Person.`)
    };
  }
}

var tyler = new Person('Tyler', 'Meyer', 32);
var brad = new Person('Brad', '', 38);

tyler.greet(); // "Hello, my name is Tyler Meyer and I'm 32 years old."
brad.greet(); // "Hello, I am not a fully formed Person."

L'instruction if recherche un argument pour chaque paramètre avant de créer l'objet Person complet. Si même un argument est une valeur fausse, il créera un objet avec l'instruction else à la place. Par conséquent, nous pouvons empêcher les objets incomplets ou créer des objets par défaut pour les entrées incomplètes.

Conclusion

Si vous avez besoin d'une valeur par défaut jusqu'à ce qu'une valeur soit fournie, l'opérateur logique OU (||) peut être très utile. Si vous devez exiger plusieurs valeurs avant de continuer, l'opérateur logique AND (&&) peut être très utile. Ce ne sont que deux exemples, et en continuant à explorer ces opérateurs, vous découvrirez qu'il existe de nombreuses autres façons d'utiliser ces opérateurs en dehors de la vérification habituelle des valeurs booléennes vraies ou fausses. Gardez ces deux choses à l’esprit lorsque vous envisagez d’utiliser les logiques AND (&&) et OR (||) :

• OR (||) : N'utilisez la valeur de gauche que si elle est véridique.
• AND (&&) : N'utilisez la valeur de gauche que si elle est fausse.

Si vous avez des questions, n'hésitez pas à les laisser dans les commentaires. Je serais heureux de discuter davantage de ce sujet.

Bon codage !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!