Fondamentalement, l'opérateur logique ET ( && ) renverra la valeur du second opérande si le premier est vrai , et il renverra la valeur du premier opérande s'il est par lui-même faux , par exemple:

 true && "foo"; // "foo" NaN && "anything"; // NaN 0 && "anything"; // 0 

Notez que les valeurs fausses sont celles qui forcent à false lorsqu'elles sont utilisées dans un contexte booléen, elles sont null , undefined , 0 , NaN , une chaîne vide et bien sûr false , toute autre contrainte à la true .

Citant Douglas Crockford ¹ :

L'opérateur && produit la valeur de son premier opérande si le premier opérande est faux. Sinon, il produit la valeur du second opérande.

¹ Douglas Crockford: JavaScript: les bonnes parties – Page 16

&& est parfois appelé opérateur de garde .

 variable = indicator && value 

Il peut être utilisé pour définir la valeur uniquement si l'indicateur est vrai.

Exemple de débutant

Si vous essayez d'accéder à "user.name", cela se produit alors:

 Uncaught TypeError: Cannot read property 'name' of undefined 

Si vous ne voulez pas que cela se produise, vous pouvez le faire en utilisant l'opérateur && dans une tâche:

 // username is not assigned here var user = 'mrsmith'; var username = user && user.username; console.log('username', username); 

Le résultat n'est pas défini. Si user && user.name est faux, il n'essaiera pas d'accéder à "user.name" et laisse la variable "username" indéfinie.

 // username is assigned here var user = 'mrsmith'; var username = user && user.username || user; console.log('username', username); 

Les résultats dans "mrsmith" en tant qu'utilisateur && user.name ont abouti à faux, alors est allé à l'utilisateur et a abouti à "mrsmith"

Voir cet exemple simple pour référence: https://jsfiddle.net/qv6rg940/3/

L'autre tâche utile et étrange qui est en pratique est l'opérateur OR qui est plus commun de ne définir que quelque chose si son PAS défini, ce que vous avez probablement vu dans les plugins ou les frameworks comme tel:

 this.myWidget = myWidget || (function() { // define widget })(); 

Qui ne définira que le widget si "myWidget" est indéfini.

Vous pourriez même devenir fou de cela et le mettre dans la logique de l'algorithme réel de la manière suivante:

 function palindrome(s,i) { return (i >= s.length/2) || (s[i] === s[s.length -1 - i]) && palindrome(s, ++i); } 

Méthode Lodash Guard

Utilisez le magnifique opérateur de garde de lodash pour accéder aux données imbriquées comme suit:

 var val = _.get(obj, 'some.very.nested.stuff.might.not.be.defined'); 

Car il gère le && sous le capot tout en étant agréable à utiliser dans une méthode pratique.

Selon la section 11.11 d'ECMAScript annotée :

Dans le cas de l'opérateur OR logique (||),

Expr1 || Expr2 Renvoie expr1 s'il peut être converti en true; Sinon, renvoie expr2. Ainsi, lorsqu'il est utilisé avec des valeurs booléennes, || Renvoie true si l'un ou l'autre opérande est vrai; Si les deux sont faux, renvoie faux.

Dans l'exemple donné,

Var oneOrTheOther = someOtherVar || "Ce ne sont pas les droides que vous recherchez … bougez";

Le résultat serait la valeur de SomeOrVar, si Boolean (someOtherVar) est vrai . (Veuillez vous référer: Truthiness of a expression ). Si c'est faux, le résultat serait "ce ne sont pas les droides que vous recherchez … déménager";

Et dans le cas de l'opérateur logique ET (&&)

Renvoie expr1 s'il peut être converti en faux; Sinon, renvoie expr2. Ainsi, lorsqu'il est utilisé avec des valeurs booléennes, && renvoie true si les deux opérandes sont vrais; Sinon, renvoie faux.

Dans l'exemple donné,

Case 1: quand Boolean (someOtherVar) est faux: il renvoie la valeur de someOtherVar.

Case 2: quand Boolean (someOtherVar) est vrai: il renvoie "ce ne sont pas les droides que vous recherchez … déplacer".

J'ai vu et ai été utilisé trop au travail pour les déclarations d'affectation. La préoccupation est double: 1) La vérification «indicateur» est parfois une fonction avec les frais généraux que les développeurs ne tiennent pas compte. 2) Il est facile pour les développeurs de simplement le voir comme une vérification de sécurité et ne pas considérer qu'ils attribuent des faux à leur var. J'aime qu'ils aient une attitude sûre du type, alors je leur ai fait changer cela:

var currentIndex = App.instance && App.instance.rightSideView.getFocusItemIndex();

pour ça:

var currentIndex = App.instance && App.instance.rightSideView.getFocusItemIndex() || 0;

Donc ils ont un nombre entier comme prévu.