Почему логические операторы (&& и ||) всегда возвращают логический результат?

Ответ 1

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

будет возвращать значение boolean.

UPDATE

Обратите внимание, что это основано на моем тестировании. Я не должен полностью полагаться.

Это выражение, которое не присваивает true или false значение. Скорее он присваивает вычисленное значение.

Посмотрим на это выражение.

Пример выражения:

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

//its 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;

Ваше выражение:

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

Другое выражение:

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

Другое выражение:

var _ = obj && obj._;

//_ = obj._

Ответ 2

В JavaScript, как || и && являются логическими операторами короткого замыкания, которые возвращают первое полностью определенное "логическое значение" при оценке слева направо.

В выражении X || Y сначала оценивается X и интерпретируется как булево значение. Если это логическое значение "true", оно возвращается. И Y не оценивается. (Потому что неважно, является ли Y истинным или Y является ложным, X || Y полностью определено.) Это часть короткого замыкания. Если это логическое значение является "ложным", мы до сих пор не знаем, является ли X || Y истинным или ложным, пока мы не оценим Y и не интерпретируем его как булево значение. Затем возвращается Y.

AND && делает то же самое, за исключением того, что перестает оценивать, является ли первый аргумент ложным.

Первая сложная часть состоит в том, что, когда выражение оценивается как "истина", возвращается само выражение. Что считается "истинным" в логических выражениях, но вы также можете его использовать. Вот почему вы видите возвращаемые фактические значения.

Вторая сложная часть заключается в том, что когда выражение оценивается как "ложное", то в JS 1.0 и 1.1 система возвращает логическое значение "false"; тогда как в JS 1.2 на нем возвращается фактическое значение выражения.

В JS, null, false, 0, "" и undefined все считаются ложными.

[Здесь я, конечно, цитирую логические значения для обсуждения. Конечно, буквальная строка "f a l s e" "false" не совпадает с значением false, и поэтому является истиной. ]

Ответ 3

В простейших терминах:

Оператор || возвращает первое правное значение, и если ни одно из них не является правдивым, оно возвращает последнее значение (которое является ложным значением).

Оператор && возвращает первое значение фальши, и если ни один не является ложным, он возвращает последнее значение (которое является правдивым значением).

Это действительно так просто. Экспериментируйте в своей консоли, чтобы убедиться сами.

Ответ 4

Я думаю, у вас есть основной вопрос методологии JavaScript здесь. Теперь JavaScript - это язык, в котором нет языка, поэтому способ и способ обработки логических операций отличаются от других стандартных языков, таких как Java и С++. JavaScript использует концепцию, известную как "принуждение типа", чтобы определить значение логической операции и всегда возвращает значение первого "истинного" типа. например, посмотрите на код ниже:

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

Это связано с тем, что "myshit" - это априорный объект undefined, который всегда будет оценивать значение false при тестировании и, таким образом, JavaScript пропускает это и проверяет следующую сущность для "истинного" значения. Поскольку объект документа известен JavaScript, он возвращает истинное значение, и JavaScript возвращает этот объект.

Если вы хотите получить логическое значение, возвращаемое вам, вам нужно передать логическое условие в такую ​​функцию:

var condition1 = myshit || 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' 

Ответ 5

Во-первых, это должно быть верно, чтобы вернуться, поэтому, если вы проверяете правдивость, то это не имеет значения.

Во-вторых, он позволяет выполнять задания по строкам:

function bar(foo) {
    foo = foo || "default value";

Ответ 6

Мы можем ссылаться на spec (11.11) JS здесь:

Семантика

Производственное логическое выражение: Expression: LogicalANDExpression & & BitwiseORExpression оценивается следующим образом:

• Вычислить логическое выражение.

2.Call GetValue (Результат (1)).

3.Call ToBoolean (Результат (2)).

4.Если результат (3) является ложным, верните результат (2).

5.Evaluate BitwiseORExpression.

6.Call GetValue (результат (5)).

7. Возврат результата (6).

см. здесь для спецификации

Ответ 7

Для сравнения:

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

с:

var prop=obj.value||0;

Возвращение правдоподобного выражения - а не только истинного или ложного - обычно делает ваш код короче и по-прежнему читабельным. Это очень распространено для ||, а не только для & &.

Ответ 8

Используйте функцию Boolean(), например:

var a = 0 || 1;// a = 1
var a = Boolean(0 || 1);// a = true

Ответ 9

Вы можете использовать!! перед условием получения булева результата.

!!(X && Y) // returns true if both X and Y are not null or undefined