Как лучше всего определить, не отправляется ли аргумент функции JavaScript

Есть несколько разных способов проверить, был ли передан аргумент функции. В дополнение к двум, которые вы упомянули в своем (исходном) вопросе - проверка arguments.length или использование оператора || для предоставления значений по умолчанию - можно также явно проверить аргументы для undefined через argument2 === undefined или typeof argument2 === 'undefined', если один из них параноик (см. Комментарии).

Использование оператора || стало стандартной практикой - это делают все крутые ребята, но будьте осторожны: значение по умолчанию будет активировано, если аргумент оценивается как false, что означает, что на самом деле это может быть undefined, null, false, 0, '' (или все остальное, для чего Boolean(...) возвращает false).

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

Проверка arguments.length демонстрирует «наиболее правильное» поведение, но может оказаться невозможным, если имеется более одного необязательного аргумента.

Следующий «лучший» тест на undefined - он «терпит неудачу» только в том случае, если функция явно вызывается со значением undefined, что, по всей вероятности, должно рассматриваться так же, как и пропуск аргумента.

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

Подведем итог: Используйте его, только если знаете, что делаете!

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

Другой хороший способ предоставить значения по умолчанию с помощью arguments.length - это пропустить метки оператора switch:

function test(requiredArg, optionalArg1, optionalArg2, optionalArg3) {
    switch(arguments.length) {
        case 1: optionalArg1 = 'default1';
        case 2: optionalArg2 = 'default2';
        case 3: optionalArg3 = 'default3';
        case 4: break;
        default: throw new Error('illegal argument count')
    }
    // do stuff
}

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

Извините, я все еще не могу комментировать, поэтому, чтобы ответить на ответ Тома ... В javascript (undefined! = Null) == false Фактически, эта функция не будет работать с "null", вы должны использовать "undefined"

Это один из немногих случаев, когда я нахожу тест:

if (! argument2) {  

}

работает довольно хорошо и синтаксически имеет правильное значение.

(С одновременным ограничением, что я не допущу допустимого нулевого значения для argument2, которое имеет другое значение; но это сбивает с толку В самом деле.)

Обновлено:

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

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

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

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

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

Я убедился в этом, сравнивая исчерпывающий код ActionScript 3 с элегантным кодом javascript. AS3 может в 3 или 4 раза превышать объем js, и я подозреваю, что надежность, по крайней мере, не лучше, просто из-за количества (в 3-4 раза) принятых решений по кодированию.

Как вы говорите, Shog9, YMMV. : D

Есть существенные отличия. Давайте настроим несколько тестовых примеров:

var unused; // value will be undefined
Test("test1", "some value");
Test("test2");
Test("test3", unused);
Test("test4", null);
Test("test5", 0);
Test("test6", "");

При использовании первого метода, который вы описываете, только второй тест будет использовать значение по умолчанию. Второй метод будет использовать по умолчанию все, кроме первого (поскольку JS преобразует undefined, null, 0 и "" в логическое значение false. И если вы использовали метод Тома, только четвертый тест будет использовать значение по умолчанию!

Какой метод вы выберете, действительно зависит от вашего предполагаемого поведения. Если для undefined допустимы значения, отличные от argument2, то вам, вероятно, понадобится какое-то изменение первого; если требуется ненулевое, ненулевое, непустое значение, тогда идеально подходит второй метод - действительно, он часто используется для быстрого исключения такого широкого диапазона значений из рассмотрения.

url = url === undefined ? location.href : url;

Может быть удобно подойти к обнаружению аргументов, вызвав вашу функцию с помощью объекта дополнительных свойств:

function foo(options) {
    var config = { // defaults
        list: 'string value',
        of: [a, b, c],
        optional: {x: y},
        objects: function(param){
           // do stuff here
        }
    }; 
    if (options !== undefined){
        for (i in config) {
            if (config.hasOwnProperty(i)){
                if (options[i] !== undefined) { config[i] = options[i]; }
            }
        }
    }
}

Если вы используете jQuery, хороший вариант (особенно для сложных ситуаций) - использовать Метод расширения jQuery.

function foo(options) {

    default_options = {
        timeout : 1000,
        callback : function(){},
        some_number : 50,
        some_text : "hello world"
    };

    options = $.extend({}, default_options, options);
}

Если вы вызовете функцию, то вот так:

foo({timeout : 500});

Тогда переменная параметров будет следующей:

{
    timeout : 500,
    callback : function(){},
    some_number : 50,
    some_text : "hello world"
};

Почему бы не использовать оператор !!? Этот оператор, помещенный перед переменной, превращает ее в логическое значение (если я хорошо понял), поэтому !!undefined и !!null (и даже !!NaN, что может быть довольно интересно) вернут false.

Вот пример:

function foo(bar){
    console.info(!!bar);
}

foo("hey") //=> will log true

foo() //=> will log false

Иногда вы также можете захотеть проверить тип, особенно если вы используете функцию как геттер и сеттер. Следующий код - ES6 (не работает в EcmaScript 5 или более ранней версии):

class PrivateTest {
    constructor(aNumber) {
        let _aNumber = aNumber;

        //Privileged setter/getter with access to private _number:
        this.aNumber = function(value) {
            if (value !== undefined && (typeof value === typeof _aNumber)) {
                _aNumber = value;
            }
            else {
                return _aNumber;
            }
        }
    }
}

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

this.setCurrent = function(value) {
  this.current = value || 0;
};

Это обязательно означает, что если значение value отсутствует / не передано - установите его на 0.

Довольно круто, да!

В ES6 (ES2015) вы можете использовать Параметры по умолчанию

function Test(arg1 = 'Hello', arg2 = 'World!'){
  alert(arg1 + ' ' +arg2);
}

Test('Hello', 'World!'); // Hello World!
Test('Hello'); // Hello World!
Test(); // Hello World!

fnCalledFunction (Param1, Param2, window.YourOptionalParameter)

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

window.param3 будет обрабатывать, если он не определен в вызывающем методе.

function example(arg) {
  var argumentID = '0'; //1,2,3,4...whatever
  if (argumentID in arguments === false) {
    console.info(`the argument with id ${argumentID} was not passed to the function`);
  }
}

Поскольку массивы наследуются от Object.prototype. Считайте ⇑, чтобы сделать мир лучше.