Установка значения по умолчанию для параметра функции в JavaScript

Я считаю, что такой подход выглядит намного более лаконичным и читаемым:

function pick(arg, def) {
   return (typeof arg === 'undefined' ? def : arg);
}

function myFunc(x) {
  x = pick(x, 'my default');
}

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

Значения по умолчанию для параметров

С введением ES6 в JavaScript появилась одна из самых распространённых идиом — установка значения по умолчанию для параметра функции. То, как мы делали это на протяжении многих лет, будет знакомо многим:

function foo(x, y) {
    x = x || 11;
    y = y || 31;
    console.log(x + y);
}
foo(); // 42
foo(5, 6); // 11
foo(5); // 36
foo(null, 6); // 17

Этот шаблон часто используется, но он может быть опасным, когда мы передаём такие значения, как:

foo(0, 42);
foo(0, 42); // 53 <-- Ой, не 42

Почему? Потому что 0 является "ложным" значением, и x || 11 в таком случае вернёт 11, а не переданное 0. Чтобы исправить эту "подвох", некоторые разработчики пишут проверку более развёрнуто:

function foo(x, y) {
    x = (x !== undefined) ? x : 11;
    y = (y !== undefined) ? y : 31;
    console.log(x + y);
}
foo(0, 42); // 42
foo(undefined, 6); // 17

Теперь давайте рассмотрим удобный синтаксис, добавленный в ES6, для упрощения задания значений по умолчанию для отсутствующих аргументов:

function foo(x = 11, y = 31) {
    console.log(x + y);
}

foo(); // 42
foo(5, 6); // 11
foo(0, 42); // 42
foo(5); // 36
foo(5, undefined); // 36 <-- `undefined` отсутствует
foo(5, null); // 5 <-- null превращается в `0`
foo(undefined, 6); // 17 <-- `undefined` отсутствует
foo(null, 6); // 6 <-- null превращается в `0`

x = 11 в объявлении функции больше похоже на x !== undefined ? x : 11, чем на более распространённый шаблон x || 11.

Выражения значений по умолчанию

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

function bar(val) {
    console.log("bar вызвана!");
    return y + val;
}
function foo(x = y + 3, z = bar(x)) {
    console.log(x, z);
}
var y = 5;
foo(); // "bar вызвана"
// 8 13
foo(10); // "bar вызвана"
// 10 15
y = 6;
foo(undefined, 10); // 9 10

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

Выражение значения по умолчанию может быть даже вызовом функции в строке — обычно это называется немедленно вызываемое функциональное выражение (IIFE):

function foo(x = (function(v) { return v + 11; })(31)) {
    console.log(x);
}
foo(); // 42

В вашем коде вы определяете функцию read_file, которая принимает два аргумента: file и delete_after. Обратите внимание на строку delete_after = delete_after || false;. Эта запись позволяет установить значение параметра delete_after в false, если он не был передан при вызове функции. Таким образом, если функция вызывается без второго аргумента, она будет работать нормально без ошибок.

Вот как это выглядит в вашем коде:

function read_file(file, delete_after) {
    delete_after = delete_after || false;
    // Код для обработки файла
}

Если вам нужно, чтобы delete_after всегда имел значение false, когда оно не указано, то текущая реализация именно эту задачу и выполняет. Если у вас возникнут другие вопросы или нужны дополнительные пояснения, не стесняйтесь спрашивать!

В данном случае, рекомендуется использовать явное сравнение с undefined, чтобы избежать потенциальных ошибок и сделать код более понятным. Вот как можно переписать вашу функцию:

function read_file(file, delete_after) {
    if (delete_after === undefined) { 
        delete_after = false; 
    }
}

Такой подход гарантирует, что delete_after будет установлено в false только в том случае, если оно не было передано при вызове функции. Это позволяет избежать ситуации, когда переменная может принимать другие «ложные» значения, такие как null, 0, или false, если вы хотите, чтобы только отсутствие аргумента определяло значение по умолчанию.