JavaScript OU (||) Explication de l'affectation des variables

Question

Compte tenu de ce bout de JavaScript ...

var a;
var b = null;
var c = undefined;
var d = 4;
var e = 'five';

var f = a || b || c || d || e;

alert(f); // 4

Quelqu'un peut-il s'il vous plaît me expliquer ce que cette technique est appelée (ma meilleure estimation est dans le titre de cette question!)? Et comment / pourquoi il fonctionne exactement?

Ma compréhension est que f variable sera attribuée la valeur la plus proche (de gauche à droite) de la première variable qui a une valeur qui ne soit nulle ou non définie, mais je n'ai pas réussi à trouver beaucoup de matériel de référence sur cette technique et ont vu beaucoup utilisé.

En outre, cette technique est spécifique à JavaScript? Je sais faire quelque chose de similaire en PHP entraînerait f ayant une vraie valeur booléenne, plutôt que la valeur de d lui-même.

Answer 1

Voir évaluation de court-circuit pour l'explication. Il est une façon commune de mettre en œuvre ces opérateurs; il est unique JavaScript.

Answer 2

Il est fait d'attribuer une valeur par défaut , dans ce cas, la valeur de y, si la variable x est falsy .

Les opérateurs booléens en JavaScript peuvent retourner un opérande, et pas toujours un résultat booléen comme dans d'autres langues.

L'opérateur logique OU (||) retourne la valeur de son second opérande, si le premier est falsy, sinon la valeur du premier opérande est retourné.

Par exemple:

"foo" || "bar"; // returns "foo"
false || "bar"; // returns "bar"

Falsy valeurs sont celles qui contraignent à false lorsqu'il est utilisé dans le contexte booléen, et ils sont 0, null, undefined, une chaîne vide, NaN et bien sûr false.

Answer 3

évaluation de court-circuit pour les opérateurs logiques || et &&. Toutefois, il est différent d'autres langues en ce qu'elle renvoie le résultat de la dernière valeur qui a mis fin à l'exécution, au lieu d'un true, ou valeur false.

Les valeurs suivantes sont considérées comme falsy en JavaScript.

• false
• null
• "" (chaîne vide)
• 0
• Nan
• non défini

Ignorant les règles de priorité de l'opérateur, et garder les choses simples, la exemples suivants montrent que la valeur de l'évaluation interrompue et est renvoyée en conséquence.

false || null || "" || 0 || NaN || "Hello" || undefined // "Hello"

Les 5 premières valeurs JUSQU'A NaN sont falsy ils sont tous évalués de gauche à droite, jusqu'à ce qu'il rencontre la première valeur truthy - "Hello" ce qui rend toute l'expression vraie, donc tout plus haut ne sera pas évaluée et "Hello" est renvoyée à la suite de l'expression. De même, dans ce cas:

1 && [] && {} && true && "World" && null && 2010 // null

Les 5 premières valeurs sont toutes truthy et s'évalué jusqu'à ce qu'il rencontre la première valeur falsy (de null) qui rend l'expression fausse, donc 2010 n'est pas évaluée plus, et null est renvoyée en raison de l'expression.

L'exemple que vous avez donné est l'utilisation de cette propriété de JavaScript pour effectuer une mission. Il peut être utilisé partout où vous avez besoin pour obtenir la première valeur truthy ou falsy parmi un ensemble de valeurs. Ce code ci-dessous affecter la valeur "Hello" à b comme il est plus facile d'attribuer une valeur par défaut, au lieu de faire des contrôles si-else.

var a = false;
var b = a || "Hello";

Vous pouvez appeler l'exemple ci-dessous une exploitation de cette fonction, et je crois qu'il rend le code plus difficile à lire.

var messages = 0;
var newMessagesText = "You have " + messages + " messages.";
var noNewMessagesText = "Sorry, you have no new messages.";
alert((messages && newMessagesText) || noNewMessagesText);

Dans l'alerte, nous vérifions si messages est falsy, et si oui, évaluer et retourner noNewMessagesText, sinon évaluer et retourner newMessagesText. Comme il est falsy dans cet exemple, nous nous arrêtons à noNewMessagesText et "Sorry, you have no new messages." alerte.

Answer 4

Variables Javascript ne sont pas typés, donc f peut être attribué une valeur entière, même si elle a été affectée par des opérateurs booléens.

f est attribué la valeur la plus proche qui est pas équivalent à false . Donc, 0, faux, null, non défini, sont tous passé au-dessus:

alert(null || undefined || false || '' || 0 || 4 || 'bar'); // alerts '4'

Answer 5

Il n'y a pas de magie à elle. Les expressions booléennes comme a || b || c || d sont évalués paresseusement. Interpeter recherche la valeur de a, elle est indéfinie il est donc faux de sorte qu'il passe, il voit b qui est nulle, ce qui donne encore résultat faux il se déplace, il voit c - même histoire. Enfin, il voit d et dit: « Hein, ce n'est pas nulle, donc je dois mon résultat » et il attribue à la variable finale.

Cette astuce fonctionne dans toutes les langues dynamiques qui font paresseuse évaluation de court-circuit des expressions booléennes. Dans les langues statiques, il ne compilera pas (erreur de type). Dans les langues qui sont désireux dans l'évaluation des expressions booléennes, il retournera la valeur logique (à savoir vrai dans ce cas).

Answer 6

Cette question a déjà reçu plusieurs bonnes réponses.

En résumé, cette technique profite d'une caractéristique de la façon dont la langue est compilé. C'est, JavaScript « court-circuit » l'évaluation des opérateurs booléens et renvoie la valeur associée à la première valeur soit variable non-fausse ou quelle que soit la dernière variable contient. Voir l'explication de Anurag de ces valeurs qui évalueront false.

L'utilisation de cette technique n'est pas une bonne pratique pour plusieurs raisons; cependant.

1. Code de Lisibilité:. Ceci est l'utilisation des opérateurs booléens, et si le comportement de la façon dont cette compilation n'est pas comprise, le résultat attendu serait une valeur booléenne
2. Stabilité:. Ce utilise une caractéristique de la façon dont la langue est compilé qui est incompatible dans plusieurs langues, et en raison de cela, il est quelque chose qui pourrait potentiellement être ciblé pour un changement dans l'avenir

3. Caractéristiques documentées: Il existe une alternative existante qui répond à ce besoin et est cohérente dans plusieurs langues. Ce serait l'opérateur ternaire:

   ()? Valeur 1: Valeur 2.

En utilisant l'opérateur ternaire ne nécessite un peu plus taper, mais il distingue clairement entre l'expression booléenne en cours d'évaluation et la valeur assignée. En outre, il peut être enchaînée, de sorte que les types d'affectations par défaut en cours d'exécution ci-dessus pourrait être recréée.

var a;
var b = null;
var c = undefined;
var d = 4;
var e = 'five';

var f =  ( a ) ? a : 
                ( b ) ? b :
                       ( c ) ? c :
                              ( d ) ? d :
                                      e;

alert(f); // 4

Answer 7

Retour de sortie première vraie valeur .

Si tous sont faux retour dernière valeur fausse.

Exemple: -

  null || undefined || false || 0 || 'apple'  // Return apple

Answer 8

Il est le réglage de la nouvelle variable (z) soit la valeur de x si elle est « truthy » (non nul, un objet valide / tableau / fonction / quoi que ce soit) ou y autrement. Il est un moyen relativement commun de fournir une valeur par défaut en cas x n'existe pas.

Par exemple, si vous avez une fonction qui prend un paramètre de rappel en option, vous pourriez fournir un rappel par défaut qui ne fait rien:

function doSomething(data, callback) {
    callback = callback || function() {};
    // do stuff with data
    callback(); // callback will always exist
}

Answer 9

Cela signifie que si x est réglé, la valeur z sera x, sinon si y est réglé alors sa valeur sera définie comme la valeur du z.

il est le même que

if(x)
  z = x;
else
  z = y;

Il est possible parce que les opérateurs logiques JavaScript ne retourne pas les valeurs booléennes, mais la valeur du dernier élément nécessaire pour terminer l'opération (dans une phrase ou ce serait la première valeur non-faux, dans une et de la peine, il serait le dernier). Si l'opération échoue, false est renvoyée.

Answer 10

L'opérateur de circuit appelé court.

Évaluation court-circuit dit, le second argument est exécuté ou évalué que si le premier argument ne suffit pas de déterminer la valeur de l'expression. lorsque le premier argument de la fonction OU (||) évalue à vrai, la valeur globale doit être vrai.

Il pourrait également être utilisé pour définir une valeur par défaut pour la fonction argument.`

function theSameOldFoo(name){ 
  name = name || 'Bar' ;
  console.log("My best friend's name is " + name);
}
theSameOldFoo();  // My best friend's name is Bar
theSameOldFoo('Bhaskar');  // My best friend's name is Bhaskar`

Answer 11

Il évaluera X et, si X est non nul, la chaîne vide, ou 0 (logique faux), il attribuera à z. Si X est nul, la chaîne vide, ou 0 (faux logique), alors il y assigner à z.

var x = '';
var y = 'bob';
var z = x || y;
alert(z);

Affichera 'bob';

Answer 12

D'après le Bill Higgins Blog après; l'idiome logique OU affectation Javascript (février 2007), ce comportement est vrai que de v1.2 (au moins)

Il suggère aussi une autre utilisation pour elle (cité): " la normalisation légère des différences entre navigateur "

// determine upon which element a Javascript event (e) occurred
var target = /*w3c*/ e.target || /*IE*/ e.srcElement;