Почему эти логические операторы возвращают объект, а не логическое?
var _ = (obj.fn && obj.fn() ) || obj._ || ( obj._ = {} );
var _ = obj && obj._;
Я хочу понять, почему он возвращает результат obj.fn() (если он определен) OR obj._, но не boolean result.
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._
В 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, и поэтому является истиной. ]
В простейших терминах:
Оператор || возвращает первое правное значение, и если ни одно из них не является правдивым, оно возвращает последнее значение (которое является ложным значением).
Оператор && возвращает первое значение фальши, и если ни один не является ложным, он возвращает последнее значение (которое является правдивым значением).
Это действительно так просто. Экспериментируйте в своей консоли, чтобы убедиться сами.
Я думаю, у вас есть основной вопрос методологии 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'
Во-первых, это должно быть верно, чтобы вернуться, поэтому, если вы проверяете правдивость, то это не имеет значения.
Во-вторых, он позволяет выполнять задания по строкам:
function bar(foo) {
foo = foo || "default value";
Мы можем ссылаться на 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).
см. здесь для спецификации
Для сравнения:
var prop;
if (obj.value) {prop=obj.value;}
else prop=0;
с:
var prop=obj.value||0;
Возвращение правдоподобного выражения - а не только истинного или ложного - обычно делает ваш код короче и по-прежнему читабельным. Это очень распространено для ||, а не только для & &.
Используйте функцию Boolean(), например:
var a = 0 || 1;// a = 1
var a = Boolean(0 || 1);// a = true
Вы можете использовать!! перед условием получения булева результата.
!!(X && Y) // returns true if both X and Y are not null or undefined