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

Question

Pourquoi ces opérateurs logiques renvoient-ils un objet et non un booléen ?

var _ = (obj.fn && obj.fn() ) || obj._ || ( obj._ = {} );

var _ = obj && obj._;

Je veux comprendre pourquoi il renvoie le résultat de obj.fn() (si elle est définie) OU obj._ mais pas de résultat booléen.

Answer 1

En JavaScript, les deux || y && sont des opérateurs de court-circuit logique qui renvoient la première "valeur logique" entièrement déterminée lorsqu'ils sont évalués de gauche à droite.

Dans l'expression X || Y , X est d'abord évalué, puis interprété comme une valeur booléenne. Si cette valeur booléenne est "vraie", elle est retournée. Et Y n'est pas évalué. (Parce qu'il n'est pas important de savoir si Y est vrai ou Y est fausse, X || Y a été entièrement déterminé). C'est la partie court-circuit.

Si cette valeur booléenne est "false", alors nous ne savons toujours pas si X || Y est vrai ou faux jusqu'à ce que nous évaluions Y et l'interprète également comme une valeur booléenne. Ainsi donc Y est renvoyé.

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

Le premier point délicat est que lorsqu'une expression est évaluée comme "vraie", l'expression elle-même est renvoyée. Ce qui compte comme "vrai" dans les expressions logiques, mais vous pouvez aussi l'utiliser. C'est pourquoi vous voyez des valeurs réelles retournées.

La deuxième difficulté réside dans le fait que, lorsqu'une expression est évaluée comme étant "fausse", le système renvoie la valeur booléenne "false" en JS 1.0 et 1.1, alors qu'en JS 1.2, il renvoie la valeur réelle de l'expression.

Dans JS false , 0 , -0 , "" , null , undefined , NaN y document.all tous compter comme faux .

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

Answer 2

Dans les termes les plus simples :

Le site || retourne la première valeur vraie, et si aucune n'est vraie, il retourne la dernière valeur (qui est une valeur fausse).

Le site && renvoie la première valeur faussée, et si aucune n'est faussée, il renvoie la dernière valeur (qui est une valeur véridique).

C'est vraiment aussi simple que ça. Expérimentez dans votre console pour vous en convaincre.

console.log("" && "Dog");    // ""
console.log("Cat" && "Dog"); // "Dog"
console.log("" || "Dog");    // "Dog"
console.log("Cat" || "Dog"); // "Cat"

Answer 3

var _ = ((obj.fn && obj.fn() ) || obj._ || ( obj._ == {/* something */}))? true: false 

retournera un booléen.

UPDATE

Notez que ceci est basé sur mes tests. Il ne faut pas se fier entièrement à moi.

C'est une expression qui fait no attribuer true o false valeur. Il attribue plutôt la valeur calculée.

Examinons cette expression.

Un exemple d'expression :

var a = 1 || 2;
// a = 1

// it's because a will take the value (which is not null) from left
var a = 0 || 2;
// so for this a=2; //its because the closest is 2 (which is not null)

var a = 0 || 2 || 1;    //here also a = 2;

Votre expression :

var _ = (obj.fn && obj.fn() ) || obj._ || ( obj._ = {} );

// _ = closest of the expression which is not null
// in your case it must be (obj.fn && obj.fn())
// so you are gettig this

Une autre expression :

var a = 1 && 2;
// a = 2

var a = 1 && 2 && 3;
// a = 3 //for && operator it will take the fartest value
// as long as every expression is true

var a = 0 && 2 && 3;
// a = 0

Une autre expression :

var _ = obj && obj._;

// _ = obj._

Answer 4

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

---

Opérateur OR :

Il renvoie la valeur de l'élément premier opérande qui valide comme vrai (le cas échéant), sinon il renvoie la valeur de l'élément dernier opérande (même si elle est validée comme fausse) .

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 Opérateur :

Il renvoie la valeur de l'élément dernier opérande qui valide comme vrai (si toutes les conditions valident comme vrai), sinon il retourne la valeur de l'objet 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
             ^
             return first operand that validates as false,
             so, a = ''

---

Conclusion :

Si vous voulez que JavaScript agisse de la même manière que les autres langages de programmation, utilisez Boolean() comme ceci :

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

Answer 5

Vous devriez considérer les opérateurs de court-circuit comme étant conditionnels plutôt que des opérateurs logiques.

x || y correspond à peu près :

if ( x ) { return x; } else { return y; }  

et x && y correspond à peu près :

if ( x ) { return y; } else { return x; }  

Dans ces conditions, le résultat est parfaitement compréhensible.

---

Desde Documentation MDN :

Les opérateurs logiques sont généralement utilisés avec des valeurs booléennes (logiques). Lorsqu'ils le sont, ils renvoient une valeur booléenne. Toutefois, les opérateurs && et || renvoient en fait la valeur de l'un des opérandes spécifiés, de sorte que si ces opérateurs sont utilisés avec des valeurs non booléennes, ils renverront une valeur non booléenne. .

Et voici le tableau avec les valeurs retournées de tous les opérateurs logiques.