web-dev-qa-db-fra.com

Opérateur Javascript AND dans la mission

Je sais qu'en JavaScript, vous pouvez faire:

var oneOrTheOther = someOtherVar || "these are not the droids you are looking for...";

où la variable oneOrTheOther prendra la valeur de la première expression si elle n'est pas null, undefined ou false. Dans ce cas, il est affecté à la valeur de la deuxième instruction. 

Cependant, à quoi la variable oneOrTheOther est-elle affectée lorsque nous utilisons l'opérateur AND logique? 

var oneOrTheOther = someOtherVar && "some string";

Que se passerait-il si someOtherVar est non faux?
Que se passerait-il si someOtherVar est faux?

Juste apprendre JavaScript et je suis curieux de savoir ce qui se passerait avec une affectation en conjonction avec l'opérateur AND.

javascriptvariable-assignmentlogical-operatorsand-operator
49
Alex

Fondamentalement, l'opérateur logique AND (&&) renverra la valeur du deuxième opérande si le premier esttruthy , et la valeur du premier opérande s'il est lui-même falsy , par exemple:

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

Notez que falsy sont les valeurs qui contraignent à 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, tout ce qui reste coerces à true.

68
CMS

&& est parfois appelé opérateur guard .

variable = indicator && value

il ne peut être utilisé pour définir la valeur que si l'indicateur est véridique.

21
mykhal

Citant Douglas Crockford1:

L'opérateur && produit la valeur de son premier opérande si le premier opérande est falsy. Sinon, il produit la valeur du deuxième opérande.

1 Douglas Crockford: JavaScript: les bonnes parties - Page 16

18
Daniel Vassallo

Exemple de débutant

Si vous essayez d'accéder à "user.name" mais que ceci se produit:

Uncaught TypeError: Cannot read property 'name' of undefined

Ne crains pas. Vous pouvez résoudre ce problème en utilisant l'opérateur && dans une affectation ou souvent appelé l'opérateur opérateur de garde car il "protège" de l'erreur non définie.

Voici quelques exemples que vous pourriez trouver étranges, mais continuez à lire comme il sera expliqué plus tard.

var user = undefined;
var username = user && user.username;
// no error, "username" assigned value of "user" which is undefined

user = { username: 'Johnny' };
username = user && user.username;
// no error, "username" assigned 'Johnny'

user = { };
username = user && user.username;
// no error, "username" assigned value of "username" which is undefined

Explication: Dans l'opération de protection, chaque terme est évalué de gauche à droite, un à la fois. Si une valeur évaluée est falsy, l'évaluation s'arrête et cette valeur est ensuite affectée. Si le dernier élément est atteint, il est ensuite attribué s'il est faux ou non.

falsy signifie qu'il s'agit de l'une de ces valeurs undefined, false, 0, null, NaN, '' et vérité signifie simplement NON falsification.

Bouton facile pour la méthode de garde

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

// need to access obj.has.some.very.nested.stuff
var val = _.get(obj, 'has.some.very.nested.stuff');

comme il gère le & trucs sous le capot tout en étant agréable à utiliser de manière pratique. Lodash _.get code source

Bonus: L'opérateur OR

L’autre affectation utile et pratique à utiliser est l’opérateur OR _} qui est généralement utilisé pour les plugins, comme ceci:

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

qui n'assignera la partie de code que si "this.myWidget" est faux. C’est pratique car vous pouvez déclarer le code n’importe où et plusieurs fois, qu’il soit affecté ou non auparavant, sachant qu’il ne le sera qu’une fois, car les personnes utilisant un plug-in risquent de déclarer accidentellement votre balise de script src plusieurs fois.

Explication: Chaque valeur est évaluée à partir de (de gauche à droite, une à la fois} _. Si une valeur est vérité, elle arrête l'évaluation et l'assigne, sinon elle continue, si le dernier élément est atteint, elle est affectée, qu'elle soit fausse ou non.

Crédit supplémentaire: combiner && et || dans une mission

Vous avez maintenant le pouvoir ultime et pouvez faire des choses très étranges, comme cet exemple très étrange d'utilisation dans un palindrome.

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

Explication détaillée ici: Vérification du Palindrome en Javascript

Bonne codage.

12
Jason Sebring

Selon ECMAScript 5.1 annoté section 11.11 :

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

expr1 || expr2 Retourne expr1 s'il peut être converti en true; sinon renvoie expr2. Ainsi, lorsqu'il est utilisé avec des valeurs booléennes, || Renvoie vrai si l'un des opérandes est vrai; si les deux sont faux, retourne faux.

Dans l'exemple donné,

var oneOrTheOther = someOtherVar || "Ce ne sont pas les droïdes que vous recherchez, allez-y";

Le résultat serait la valeur de someOtherVar, si Boolean (someOtherVar) est vrai . (Veuillez vous reporter. Vérité d’une expression ). Si c'est faux, le résultat serait "ce ne sont pas les droïdes que vous recherchez ... avancez";

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

Retourne expr1 s'il peut être converti en false; sinon, retourne expr2. Ainsi, lorsqu'il est utilisé avec des valeurs booléennes, && renvoie true si les deux opérandes Sont vrais; sinon, renvoie false.

Dans l'exemple donné,

cas 1: lorsque Boolean (someOtherVar) est défini sur false: il renvoie la valeur de someOtherVar.

cas 2: quand Boolean (someOtherVar) est vrai: il retourne "ce ne sont pas les droïdes que vous recherchez ... avancez le long".

1
BatScream

Je vois && surutilisé ici au travail pour les déclarations de mission. La préoccupation est double: 1) La vérification de l'indicateur est parfois une fonction que les développeurs ne prennent pas en compte. 2) Il est facile pour les développeurs de le voir comme une simple sécurité. cocher et ne pas considérer qu'ils attribuent la valeur false à leur var. Je les aime avoir une attitude digne de ce nom, alors je leur demande de changer cela:

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

pour ça:

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

afin qu'ils obtiennent un entier comme prévu.

0
Drew Deal