Pourquoi ne pas les opérateurs logiques (&& et ||) retourne toujours un résultat booléen?

En JavaScript, les deux || et && sont logiques de court-circuit opérateurs de retour de la première entièrement déterminé “valeur logique” lorsqu'elles sont évaluées de gauche à droite.

Dans l'expression X || Y, X est évalué en premier, et interprété comme une valeur booléenne. Si cette valeur booléenne est “vrai”, alors il est retourné. Et Y n'est pas évalué. (Car il n'a pas d'importance si Y est vrai ou Y est faux, X || Y a été entièrement déterminé.) C'est le court-circuit de la partie.

Si cette valeur booléenne est “faux”, alors nous ne savons pas encore si X || Y est vrai ou faux jusqu'à ce que nous évaluons Y, et de l'interpréter comme une valeur booléenne ainsi. Alors Y revient.

Et && fait la même chose, sauf qu'il s'arrête à évaluer si le premier argument est faux.

La première partie délicate est que lorsqu'une expression est évaluée comme “vrai”, alors l'expression elle-même est retourné. Qui est considéré comme "vrai" dans des expressions logiques, mais vous pouvez aussi l'utiliser. Donc, c'est pourquoi vous voyez des valeurs réelles de l'être retourné.

La deuxième partie délicate est que quand une expression est évaluée comme “faux”, puis en JS 1.0 et 1.1 le système renvoie une valeur booléenne “false”; considérant qu'en JS 1.2 sur elle renvoie la valeur réelle de l'expression.

En JS false, 0, -0, "", null, undefined, NaN et document.all tous sont considérés comme false.

Ici, je suis, bien sûr, citant des valeurs logiques pour la discussion du saké. Bien sûr, la chaîne littérale "false" n'est pas la même que la valeur false, et est donc vrai.

Je pense que vous avez le code JavaScript de base de la méthodologie de question ici.

Maintenant, JavaScript est un langage faiblement typé. En tant que tel, de la façon et de la manière dont elle traite les opérations logiques diffère de celle des autres langages comme Java et C++. JavaScript utilise le concept de contrainte de type" pour déterminer la valeur d'une opération logique et renvoie toujours la valeur de la première true type. Par exemple, regardez le code ci-dessous:

var x = mystuff || document;
//after execution of the line above, x = document

C'est parce que mystuff est un a priori undefined entité qui sera toujours l'évaluer à false lorsqu'il est testé et en tant que tel, JavaScript ignore ce et tests de la prochaine entité pour une true valeur. Depuis l'objet document est connu pour JavaScript, il renvoie une true valeur et JavaScript renvoie cet objet.

Si vous vouliez une valeur booléenne retourné à vous, vous avez passer votre logique de l'état à une fonction comme ceci:

var condition1 = mystuff || document;

function returnBool(cond){
  if(typeof(cond) != 'boolean'){ //the condition type will return 'object' in this case
     return new Boolean(cond).valueOf();
  }else{ return; }
}    
//Then we test...
var condition2 = returnBool(condition1);
window.console.log(typeof(condition2)); //outputs 'boolean' 

Dans la plupart des langages de programmation, le && et || opérateurs retourne un booléen. En JavaScript, c'est différent.

---

OU de l'Exploitant:

Elle renvoie la valeur de la premier opérande qui valide comme vrai (le cas échéant), sinon, elle retourne la valeur de la dernier opérande (même si il valide comme faux).

Exemple 1:

var a = 0 || 1 || 2 || 3;
        ^    ^    ^    ^
        f    t    t    t
             ^
             first operand that validates as true
             so, a = 1

Exemple 2:

var a = 0 || false || null || '';
        ^    ^        ^       ^
        f    f        f       f
                              ^
                              no operand validates as true,
                              so, a = ''

---

ET Exploitant:

Elle renvoie la valeur de la dernier opérande qui valide comme vrai (si toutes les conditions valide comme vrai), sinon, elle retourne la valeur de la premier opérande qui valide comme faux.

Exemple 1:

var a = 1 && 2 && 3 && 4;
        ^    ^    ^    ^
        t    t    t    t
                       ^
                       last operand that validates as true
                       so, a = 4

Exemple 2:

var a = 2 && '' && 3 && null;
        ^    ^     ^    ^
        t    f     t    f
             ^
             entire condition is false, so return first operand that validates as false,
             so, a = ''

---

Conclusion:

Si vous voulez JavaScript pour agir de la même façon d'autres langages de programmation, utiliser Boolean() fonction, comme ceci:

var a = Boolean(1 || 2 || 3);//a = true

Comparer:

var prop;
if (obj.value) {prop=obj.value;}
else prop=0;

avec:

var prop=obj.value||0;

Retour d'un truthy de l'expression plutôt que de simplement vrai ou faux - habituellement rend votre code plus court et toujours lisible. Ceci est très fréquent pour ||, non pas tant pour &&.