JavaScript OR (||) объяснение назначения переменной

Учитывая этот фрагмент 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

Может кто-нибудь объяснить мне, как называется эта техника (мое лучшее предположение - в названии этого вопроса!)? И как / почему это работает точно?

Насколько я понимаю, переменной fбудет присвоено ближайшее значение (слева направо) первой переменной, которая имеет значение, которое не является ни нулевым, ни неопределенным, но мне не удалось найти много справочных материалов об этой технике и видел, что это используется много.

Кроме того, эта техника специфична для JavaScript? Я знаю, что выполнение чего-то подобного в PHP приведет fк истинному логическому значению, а не к значению самого dсебя.

См. Оценку короткого замыкания для объяснения. Это распространенный способ реализации этих операторов; это не уникально для JavaScript.

Это сделано для присвоения значения по умолчанию , в данном случае значения y, если xпеременная ложная .

Логические операторы в JavaScript могут возвращать операнд, а не всегда логический результат, как в других языках.

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

Например:

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

Falsy значения являются те , которые принуждают к falseпри использовании в логическом контексте, и они 0, null, undefined, пустая строка, NaNи, конечно же false.

Javacript использует оценку короткого замыкания для логических операторов ||и &&. Однако он отличается от других языков тем, что возвращает результат последнего значения, остановившего выполнение, вместо значения trueили false.

Следующие значения считаются ложными в JavaScript.

• ложный
• значение NULL
• "" (пустой строкой)
• 0
• бабушка
• не определено

Игнорируя правила приоритета операторов и сохраняя простоту, следующие примеры показывают, какое значение остановило оценку и в результате возвращается.

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

Первые 5 значений NaNявляются ложными, поэтому все они оцениваются слева направо до тех пор, пока оно не встретит первое истинное значение - "Hello"что делает все выражение истинным, поэтому все дальнейшее повышение не будет оцениваться и "Hello"будет возвращено в результате выражения , Аналогично в этом случае:

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

Первые 5 значений являются достоверными и оцениваются до тех пор, пока не встретятся первое ложное значение ( null), которое делает выражение ложным, поэтому 2010больше не оценивается и nullвозвращается в результате выражения.

В приведенном вами примере используется это свойство JavaScript для выполнения назначения. Он может использоваться где угодно, где вам нужно получить первое истинное или ложное значение среди набора значений. Этот код ниже будет присвоить значение , "Hello"чтобы , bкак это делает его легче присвоить значение по умолчанию, вместо того , чтобы делать if-другую проверку.

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

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

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

Внутри оповещения мы проверяем, messagesявляется ли ложным, и если да, то оцениваем и возвращаем noNewMessagesText, иначе оцениваем и возвращаем newMessagesText. Поскольку в этом примере это ложно, мы останавливаемся на noNewMessagesText и предупреждаем "Sorry, you have no new messages.".

Переменные Javascript не являются типизированными, поэтому f можно присвоить целочисленное значение, даже если оно было назначено с помощью логических операторов.

F присваивается ближайшее значение, которое не эквивалентно ложному . Итак, 0, false, null, undefined, все передаются:

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

В этом нет никакой магии. Булевы выражения вроде a || b || c || dлениво оцениваются. Interpeter ищет значение a, оно не определено, поэтому оно ложно, поэтому оно движется дальше, затем оно видит, bкакое значение равно нулю, что все еще дает ложный результат, поэтому оно движется дальше, а затем c- ту же историю. Наконец, он видит dи говорит «да, это не нуль, поэтому у меня есть результат», и он присваивает его конечной переменной.

Этот прием будет работать во всех динамических языках, которые лениво оценивают логические выражения при коротком замыкании. В статических языках он не будет компилироваться (ошибка типа). В языках, которые стремятся оценить логические выражения, он вернет логическое значение (т. Е. В данном случае true).

Этот вопрос уже получил несколько хороших ответов.

Таким образом, этот метод использует возможность компилирования языка. То есть JavaScript «закорачивает» оценку булевых операторов и возвращает значение, связанное либо с первым непустым значением переменной, либо с тем, что содержит последняя переменная. См. Объяснение Анурага тех ценностей, которые будут оцениваться как ложные.

Использование этой техники не является хорошей практикой по нескольким причинам; Однако.

1. Читаемость кода: это использует логические операторы, и если поведение того, как это компилируется, не понято, то ожидаемый результат будет логическим значением.
2. Стабильность: при этом используется функция компиляции языка, которая несовместима между несколькими языками, и из-за этого она потенциально может быть изменена в будущем.

3. Документированные функции: существует альтернатива, которая удовлетворяет эту потребность и совместима с другими языками. Это будет троичный оператор:

   ()? значение 1: значение 2.

Использование тернарного оператора требует немного большего набора текста, но оно четко различает оцениваемое логическое выражение и назначаемое значение. Кроме того, он может быть объединен в цепочку, поэтому типы назначений по умолчанию, выполняемые выше, могут быть воссозданы.

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

Вернуть вывод первого истинного значения .

Если все ложно, вернуть последнее ложное значение.

Пример:-

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

Он устанавливает новую переменную ( z) либо в значение x«истинно» (не ноль, допустимый объект / массив / функция / что бы то ни было) или yиное. Это относительно распространенный способ предоставления значения по умолчанию на случай, если xего не существует.

Например, если у вас есть функция, которая принимает необязательный параметр обратного вызова, вы можете предоставить обратный вызов по умолчанию, который ничего не делает:

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

Это означает, что если xустановлено, значение для zбудет x, в противном случае, если yустановлено, то его значение будет установлено какz значение.

это так же, как

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

Это возможно, потому что логические операторы в JavaScript не возвращают логические значения, но значение последнего элемента, необходимого для завершения операции (в предложении ИЛИ это будет первое не ложное значение, в предложении И это будет последнее ). Если операция не выполняется, falseвозвращается.

Это называется оператор короткого замыкания.

Оценка короткого замыкания говорит, что второй аргумент выполняется или оценивается, только если первого аргумента недостаточно для определения значения выражения. когда первый аргумент функции OR (||) оценивается как true, общее значение должно быть true.

Его также можно использовать для установки значения по умолчанию для аргумента функции.

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`

Он будет оценивать X и, если X не равен NULL, пустой строке или 0 (логическое ложное значение), то он назначит его z. Если X - ноль, пустая строка или 0 (логическое ложь), тогда он назначит y для z.

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

Будет выводить «Боб»;

Согласно сообщению в блоге Билла Хиггинса ; идиома логического ИЛИ назначения Javascript (февраль 2007 г.), это поведение верно с версии 1.2 (по крайней мере)

Он также предлагает другое использование для этого (цитируется): « облегченная нормализация различий между браузерами »

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