Javascript et opérateur dans l'affectation

Question

Je sais que JavaScript que vous pouvez faire:

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

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

Cependant, qu'est-ce que la variable oneOrTheOther seront affectés aux lorsque nous utilisons l'opérateur logique AND?

var oneOrTheOther = someOtherVar && "some string";

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

Juste apprendre JavaScript et je suis curieux de savoir ce qui se passerait avec la cession en collaboration avec l'opérateur.

Answer 1

En fait, la logique et l'opérateur (&&), renvoie la valeur du deuxième opérande si le premier est truthy , et il retourne la valeur du premier opérande si elle est par lui-même < em> falsy , par exemple:

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

Notez que falsy Les valeurs sont celles qui coerce à false lorsqu'il est utilisé dans le contexte booléen, ils sont null, undefined, 0, NaN, une chaîne vide, et false bien sûr, quoi que ce soit d'autre contraint à true .

Answer 2

&& est parfois appelé garde opérateur.

variable = indicator && value

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

Answer 3

Douglas Crockford ¹ :

  

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

---

¹ Douglas Crockford: JavaScript: The Good Parts - Page 16

Answer 4

débutants Exemple

Si vous essayez d'accéder « user.name » mais cela se produit:

Uncaught TypeError: Cannot read property 'name' of undefined 

Ne crains point. Vous pouvez résoudre cela en utilisant le opérateur && dans une cession ou souvent appelé le opérateur de garde car elle « gardiens » de l'événement d'erreur non définie.

Voici quelques exemples que vous pouvez trouver étrange, mais continuer à lire comme il est 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 garde, chaque terme est évalué de gauche à droite à la fois . Si une valeur est évaluée falsy, l'évaluation arrête et que la valeur est alors affectée. Si le dernier élément est atteint, il est alors attribué ou non il est falsy.

falsy des moyens est l'une de ces valeurs undefined, false, 0, null, NaN, '' et truthy signifie tout simplement pas falsy.

facile pour la garde Méthode

Utilisez l'opérateur belle garde de lodash aux données imbriquées d'accès comme ceci:

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

car il gère les choses && sous le capot tout en étant agréable à utiliser dans une méthode pratique. Lodash _.get code source

Bonus: l'opérateur OR

L'autre affectation étrange utile qui est en cours d'utilisation pratique est le OU opérateur qui est généralement utilisé pour les plugins comme ceci:

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

qui n'attribue la partie de code si « this.myWidget » est falsy. Ceci est pratique parce que vous pouvez déclarer le code partout et plusieurs fois ne pas se soucier si elle été affectée ou non auparavant, sachant qu'il ne sera attribué qu'une seule fois puisque les gens à l'aide d'un plug-in peut déclarer accidentellement plusieurs fois de votre balise script.

Explication : Chaque valeur est évaluée à partir de de gauche à droite, un à la fois . Si une valeur est truthy, il arrête l'évaluation et attribue cette valeur, sinon, continue à aller, si le dernier élément est atteint, il est attribué, peu importe si elle est falsy ou non.

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

Vous avez maintenant le pouvoir ultime et peut faire des choses très étranges, comme cet exemple très étrange de l'utiliser dans un palindrome.

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

explication approfondie ici: Palindrome check-in Javascript

Happy codage.

Answer 5

Selon annotés ECMAScript 5.1 section 11.11 :

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

  

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

Dans l'exemple donné,

var oneOrTheOther = someOtherVar || « Ce ne sont pas les droïdes que vous recherchez ... se déplacent le long »;

Le résultat serait la valeur de someOtherVar, si Boolean (someOtherVar) est vrai . (S'il vous plaît se référer. Truthiness d'une expression ). Si elle est fausse le résultat serait « ce ne sont pas les droïdes que vous recherchez ... se déplacent le long »;

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

  

Renvoie expr1 si elle peut être convertie en faux; sinon, renvoie   Expr2. Ainsi, lorsqu'il est utilisé avec des valeurs booléennes, && renvoie true si les deux   opérandes sont vraies; sinon, retourne false.

Dans l'exemple donné,

Cas 1: lorsque booléenne (someOtherVar) est faux. Il renvoie la valeur de someOtherVar

Cas n ° 2: lorsque Boolean (someOtherVar) est vrai:. Il retourne « ce ne sont pas les droïdes que vous recherchez ... se déplacent le long »

Answer 6

Je suis ici galvaudé && vois au travail pour les états d'affectation. La préoccupation est double: 1) Le contrôle « indicateur » est parfois une fonction avec des frais généraux que les développeurs ne tiennent pas compte. 2) Il est facile pour les devs de voir tout comme un contrôle de sécurité et ne pas considérer qu'ils sont faux assignent à leur var. Je comme eux d'avoir une attitude de type sécurité, donc je les ai changer ceci:

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

à ceci:

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

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