Цитата: «Что означает конструкция x = x || y?»

Присвоение значения по умолчанию.

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

оператор двойной трубы

- этот пример полезен?

var section = document.getElementById('special');
if(!section){
     section = document.getElementById('main');
}

также может быть

var section = document.getElementById('special') || document.getElementById('main');

В то время как ответ Клетуса верен, я чувствую, что более подробно следует добавить в отношении «оценивается как false» в JavaScript.

var title = title || 'Error';
var msg   = msg || 'Error on Request';

Не просто проверка наличия заголовка / msg, но также и для любого из них falsy . то есть одно из следующего:

• false.
• 0 (ноль)
• "" (пустая строка)
• null.
• undefined.
• NaN (специальное значение номера означает Not-a-Number!) [/ ​​g7]

Итак, в строке

var title = title || 'Error';

Если заголовок правдивый (т. е. не фальши, так что title = "titleMessage" и т. д.), то логический оператор OR (||) нашел одно истинное значение, что означает, что он оценивает значение true, поэтому он замыкает и возвращает истинное значение (название).

Если заголовок является ложным (т. е. один из приведенных выше списков), то логический оператор OR (||) обнаружил значение «false» и теперь должен оценить другую часть оператора: «Ошибка ', который оценивается как истинный и, следовательно, возвращается.

Было бы также (после нескольких экспериментов с консолью firebug), если обе стороны оператора оценивают значение false, он возвращает второй оператор «фальшивый».

, т. е.

return ("" || undefined)

возвращает undefined, возможно, это позволит вам использовать поведение, заданное в этом вопросе при попытке заголовка / сообщения по умолчанию "". т. е. после запуска

var foo = undefined
foo = foo || ""

foo будет установлен на ""

Если заголовок не установлен, используйте значение «ERROR» в качестве значения по умолчанию.

Более общий:

var foobar = foo || default;

Считывает: Установите foobar на foo или default. Вы могли бы даже многократно связывать это:

var foobar = foo || bar || something || 42;

Двойная труба означает логическое «ИЛИ». На самом деле это не так, когда «параметр не установлен», поскольку строго в javascript, если у вас есть такой код:

function foo(par) {
}

Затем вызовы

foo()
foo("")
foo(null)
foo(undefined)
foo(0)

не являются эквивалент.

Двойной канал (||) передаст первый аргумент в значение boolean, и если результирующее логическое значение истинно, выполните задание, иначе оно назначит правильную часть.

Это имеет значение, если вы проверяете для параметра unset.

Допустим, у нас есть функция setSalary, которая имеет один необязательный параметр. Если пользователь не задает параметр, тогда следует использовать значение по умолчанию 10.

, если вы выполняете проверку следующим образом:

function setSalary(dollars) {
    salary = dollars || 10
}

Это даст неожиданный результат при вызове типа

setSalary(0) 

Он все равно установит 10, следуя описанному выше потоку.

Объясняя это немного подробнее ...

Оператор || является логическим оператором or. Результат верен, если первая часть истинна, и это правда, если вторая часть истинна, и это правда, если обе части истинны. Для ясности здесь он находится в таблице:

 X | Y | X || Y 
---+---+--------
 F | F |   F    
---+---+--------
 F | T |   T    
---+---+--------
 T | F |   T    
---+---+--------
 T | T |   T    
---+---+--------

Теперь обратите внимание на что-то здесь? Если X истинно, результат всегда верен. Поэтому, если мы знаем, что X истинно, нам вообще не нужно проверять Y. Многие языки, таким образом, реализуют оценщики «короткого замыкания» для логических or (и логических - and, идущих с другого направления). Они проверяют первый элемент, и если это правда, они не мешают проверять вторую. Результат (в логических терминах) один и тот же, но с точки зрения исполнения существует потенциально огромная разница, если второй элемент дорог для вычисления.

Итак, что это имеет отношение к вашему примеру?

var title   = title || 'Error';

Давайте посмотрим на это. Элемент title передается вашей функции. В JavaScript, если вы не передаете параметр, по умолчанию используется значение null. Также в JavaScript, если ваша переменная является нулевым значением, она считается ложной логическими операторами. Поэтому, если эта функция вызывается с заданным заголовком, это значение не является ложным и, следовательно, назначается локальной переменной. Если, однако, ему не присваивается значение, оно является нулевым значением и, следовательно, ложным. Затем оператор логического or оценивает второе выражение и возвращает вместо него «Ошибка». Итак, теперь локальной переменной присваивается значение «Ошибка».

Это работает из-за реализации логических выражений в JavaScript. Он не возвращает правильное логическое значение (true или false), но вместо этого возвращает значение, которое оно было дано в соответствии с некоторыми правилами относительно того, что считается эквивалентным true, и то, что считается эквивалентным false. Посмотрите свою ссылку на JavaScript, чтобы узнать, что JavaScript считает истинным или ложным в булевых контекстах.

В основном это проверяет, имеет ли значение перед || оценивает значение true, если да, оно принимает это значение, если нет, оно принимает значение после значений ||.

, для которых оно примет значение после || (насколько я помню):

• undefined
• false
• 0
• '' (нулевая или нулевая строка)

Что такое оператор двойной трубы (||)?

Оператор двойной трубы (||) является логическим оператором OR. В большинство языков работает следующим образом:

• Если первое значение false, оно проверяет второе значение. Если это true, он возвращает true, и если он false, он возвращает false.
• Если первое значение true, оно всегда возвращает true, независимо от того, что второе значение.

Таким образом, в основном это работает как эта функция:

function or(x, y) {
  if (x) {
    return true;
  } else if (y) {
    return true;
  } else {
    return false;
  }
}

Если вы все еще не понимаете, посмотрите на эту таблицу:

      | true   false  
------+---------------
true  | true   true   
false | true   false  

Другими словами, это только false, когда оба значения являются ложными.

Как это отличается в JavaScript?

JavaScript немного отличается, потому что это свободно набранный язык. В этом случае это означает, что вы можете использовать оператор || со значениями, которые не являются логическими. Хотя это не имеет смысла, вы можете использовать этот оператор, например, с помощью функции и объекта:

(function(){}) || {}

Что там происходит?

Если значения не являются логическими, JavaScript делает неявным разговор до логического. Это означает, что если значение ложно (например, 0, "", null, undefined (см. Также Все значения false в JavaScript )), он будет рассматриваться как false; в противном случае это рассматривается как true.

Таким образом, приведенный выше пример должен дать true, поскольку пустая функция является правдой. Ну, это не так. Он возвращает пустую функцию. Это потому, что JavaScript || оператор не работает, как я писал в начале. Он работает следующим образом:

• Если первое значение ложно, оно возвращает второе значение.
• Если первое значение является правдивым, оно возвращает первое значение.

Удивлен? Фактически, он «совместим» с традиционным оператором ||. Его можно записать в виде следующей функции:

function or(x, y) {
  if (x) {
    return x;
  } else {
    return y;
  }
}

Если вы передадите правдивое значение как x, оно возвращает x, то есть правное значение. Поэтому если вы используете его позже в if:

(function(x, y) {
  var eitherXorY = x || y;
  if (eitherXorY) {
    console.log("Either x or y is truthy.");
  } else {
    console.log("Neither x nor y is truthy");
  }
}(true/*, undefined*/));

, вы получите "Either x or y is truthy.".

Если x был ложным, eitherXorY будет y , В этом случае вы получите "Either x or y is truthy.", если y правдиво; в противном случае вы получите "Neither x nor y is truthy".

Фактический вопрос

Теперь, когда вы знаете, как работает оператор ||, вы, вероятно, можете сами выяснить, что делает x = x || y имею в виду. Если x правдиво, x присваивается x, так что на самом деле ничего не происходит; в противном случае y присваивается x. Он обычно используется для определения параметров по умолчанию в функциях. Тем не менее, это часто считается плохой практикой программирования, поскольку она не позволяет вам передавать значение ложности (что необязательно undefined или null) в качестве параметра. Рассмотрим следующий пример:

function badFunction(/* boolean */flagA) {
  flagA = flagA || true;
  console.log("flagA is set to " + (flagA ? "true" : "false"));
}

Он выглядит действительным с первого взгляда. Однако что произойдет, если вы передадите false в качестве параметра flagA (поскольку он является логическим, то есть может быть true или false)? Это станет true. В этом примере нет способа установить flagA на false.

Было бы лучше прояснить, действительно ли flagA является undefined, например:

function goodFunction(/* boolean */flagA) {
  flagA = typeof flagA !== "undefined" ? flagA : true;
  console.log("flagA is set to " + (flagA ? "true" : "false"));
}

Хотя он длиннее, он всегда работает, и его легче понять.

Вы также можете использовать синтаксис ES6 для параметров функции по умолчанию , но обратите внимание что он не работает в старых браузерах (например, IE). Если вы хотите поддерживать эти браузеры, вы должны передать ваш код с помощью Babel .

См. Также Логические операторы на MDN .

Чтобы добавить некоторые объяснения ко всем сказанным передо мной, я должен дать вам несколько примеров для понимания логических понятий.

var name = false || "Mohsen"; # name equals to Mohsen
var family = true || "Alizadeh" # family equals to true

Это означает, что если левая сторона оценивается как истинное утверждение, она будет закончена и левая сторона будет возвращена и назначена переменной. в других случаях правая сторона будет возвращена и назначена.

И оператор имеет противоположную структуру, как показано ниже.

var name = false && "Mohsen" # name equals to false
var family = true && "Alizadeh" # family equals to Alizadeh

И я должен добавить еще одну вещь: этот бит сокращений - мерзость. Он управляет оптимизацией случайного интерпретатора (не беспокоясь о второй операции, если первая является правдой) для управления назначением. Это использование не имеет ничего общего с целью оператора. Я не верю, что это должно когда-либо использоваться.

Я предпочитаю тернарный оператор для инициализации, например,

var title = title?title:'Error';

Это использует однострочную условную операцию для ее правильной цели. Он по-прежнему играет неприглядные игры с правдивостью, но это Javascript для вас.