Comment fonctionne l'affectation logique javascript?

Question

En javascript, si nous avons un code tel que

var a = "one"; 
var b = q || a; 
alert (b); 

L'opérateur logique OU assignera la valeur a à b, et l'alerte sera « un. »

Est-ce limité aux affectations seulement ou pouvons-nous l'utiliser partout?

Il semble qu'une chaîne vide est traitée de la même manière que non définie. Est-ce correct?

Comment cela fonctionne avec les variables AND? Qu'en est-il des combinaisons d'entre eux?

Quel est un bon exemple de quand utiliser ces idiomes, ou quand ne pas le faire?

Answer 1

Pour votre q || a d'évaluer à a, q devrait être une valeur 'falsy'. Ce que vous avez fait est appelé "évaluation de court-circuit".

répondre à vos questions:

1. Les opérateurs logiques (comme et - &&, ou - ||) peuvent être utilisés dans d'autres situations. Plus généralement dans les instructions conditionnelles comme if. More here

2. La chaîne vide n'est pas traitée comme undefined. Les deux sont des valeurs falsifiées. Il y a quelques autres fausses valeurs. More here

3. AND, ou && dans JavaScript, n'est pas une variable.C'est un opérateur

4. L'idiome que vous avez utilisé est assez commun.

   var x = val || 'default'; //is generally a replacement for

   var x = val ? val : 'default' //or

   if (val) var x = val; else var x = 'default';

Answer 2

La façon || fonctionne en Javascript est:

1. Si l'opérande gauche est évaluée comme true, retourner l'opérande gauche
2. Sinon, retournez le droit opérande

& & fonctionne de façon similaire.

Vous pouvez utiliser cela pour des contrôles d'existence en ligne, par exemple:

var foo = (obj && obj.property) 

sera mis foo-obj.property si obj est défini et « truthy ».

Answer 3

Ce comportement est partagé avec d'autres langages de script tels que Perl. L'opérateur OU logique peut être utilisé comme raccourci syntaxique pour spécifier des valeurs par défaut du fait que l'opérateur OU logique arrête d'évaluer ses opérandes lorsqu'il rencontre la première expression évaluée comme vraie: "évalue le premier opérande et si la valeur est interprétée sinon faux, assignez-le, sinon répétez pour le second opérande. "

Je trouve que j'utilise souvent ce comportement pour spécifier des valeurs par défaut pour les paramètres de fonction. Par exemple.

function myFunction(foo, bar) { 
    var fooValue = foo || "a"; 

    // no need to test fooValue -- it's guaranteed to be defined at this point 
} 

Answer 4

Je ne suis pas sûr que je suis votre question. Vous pouvez utiliser une expression n'importe où vous pouvez utiliser une expression, et un opérateur logique sur deux expressions entraîne une expression.

alert(q||a); 
alert(true||false); 

var x=5; 
var y=0; 
if (y!=0 && x/y>2) { /*do something*/ } 

Le dernier bit est utile. Comme la plupart des langages, Javascript «court-circuite» les AND et les ORs. Si la première partie d'un AND est fausse, elle n'évalue pas le second bit, ce qui vous permet d'économiser une division par zéro. Si la première partie d'un OR est vraie, elle n'évalue pas la seconde.

Mais vous pouvez utiliser des opérateurs booléens partout où vous pouvez utiliser une expression.

Answer 5

Javascript évalue la logique par la pureté/la fausseté. Des valeurs telles que (false, "", null, undefined, 0, -0) sont évaluées comme étant fausses logiques.

Ajoutez à cela l'évaluation paresseux « ou » opérations sont maintenant évalués à partir left to right et arrêts une fois true se trouve. Puisque, dans votre exemple, la transparence n'est pas littéralement un booléen, la valeur est renvoyée.

Dans ce cas:

x = 0; y = 5; alert(y || x)/*returns 5*/; alert(x || y)/*also returns 5*/; 

cela peut aussi être d'autres objets.

functionThatReturnsTrue() || functionThatDoesSomething(); 

Answer 6

IMHO - ne pas utiliser pour l'affectation de type booléen. Cela peut être déroutant. Comme non défini! == faux, c'est-à-dire que le faux lui-même est une valeur.

E.g. Si tu veux copier une valeur de champ d'un objet si et seulement si ce champ est défini

var bar.value = false; 
var foo = true; 

var foo = bar.value || foo; // ==> should be false as bar.value is defined 

Pour affectation de type booléen, u devrait vraiment utiliser la variable

var foo = (bar.value !== undefined) ? bar.value : foo;