Что произойдет, если я не передам параметр в функции Javascript?

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

Пример функции

function myfunction(x) {
    alert("This is a sample alert");
}

Теперь, если я вызываю функцию, myfunction();мне выдается предупреждение. Почему я могу вызвать функцию без ошибок или предупреждений, если я не передал параметр?

РЕДАКТИРОВАТЬ

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

Ничего не произойдет - это означает, что вы не получите сообщение об ошибке или предупреждение, так как передача параметров в javascript является необязательной.
Все параметры, которые не были «предоставлены», будут иметь undefinedзначение .

function foo(x, y, z){
    //...
}

foo(1);

fooТеперь внутри функции:

function foo(x, y, z){
    x === 1
    y === undefined
    z === undefined
}

Вы даже можете передать больше аргументов, например:

foo(1,2,3,4,5,7); // Valid!

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

function foo(x, y, z) {
    console.log('x value: ' + x);
    console.log('y value: ' + y);
    console.log('z value: ' + z);
    console.log('Arguments length: ' + arguments.length);
}
console.log('Zero parameters');
foo();
console.log('Four parameters');
foo(1, 2, 3, 4);

Пример полезной функции, обрабатывающей любое количество параметров:

function max() {
    var maxValue = arguments[0];
    for (var i = 1; i < arguments.length; i++) {
        if (maxValue < arguments[i]) {
            maxValue = arguments[i];
        }
    }
    return maxValue;
}

alert(max(1, 5, 7, 2, 88, 32, 44));

Все аргументы в функциях JavaScript являются необязательными (читайте «слабо типизированные»).

Функции JavaScript можно вызывать с любым количеством аргументов, независимо от количества аргументов, указанных в определении функции. Поскольку функция типизирована слабо, у нее нет способа объявить тип ожидаемых аргументов, и разрешено передавать значения любого типа в любую функцию. Когда функция вызывается с меньшим количеством аргументов, чем объявлено, дополнительные аргументы имеют неопределенное значение.

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

arguments[0]
arguments[1]
arguments[2]

• JavaScript - Полное руководство, 5-е издание

Так работает JavaScript. Параметры являются необязательными, и в функции они будут иметь значение «undefined», не имеющее реального значения, если они отсутствуют при вызове функции.

Под «необязательным» я имею в виду именно это: вызов любой функции включает произвольно длинный список параметров. Не должно быть связи между количеством параметров, переданных функции, и объявленным числом . Тогда лучше всего думать об этом заявлении:

function x(a, b, c) {
  // ...
}

заключается в том, что вы объявляете функцию и привязываете имя «a» к первому параметру, «b» - ко второму, а «c» - к третьему. Однако никоим образом не гарантируется, что любой из них будет фактически привязан к значению при любом данном вызове функции позже.

Точно так же вы можете определить функцию вообще без каких-либо параметров, а затем «найти» их через argumentsобъект:

function noArgs() {
  var a = arguments[0], b = arguments[1], c = arguments[2];
  // ...
}

Так что это не совсем то же самое, что и первая функция, но во многих смыслах она близка.

Значение «undefined» в JavaScript - это значение, но его семантика довольно необычна для языков. В частности, это не совсем то же самое, что и nullзначение. Кроме того, «undefined» само по себе не является ключевым словом; это просто полу-специальное имя переменной!

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

Если вы не передадите значение, параметр будет undefined.

function myfunction(x) {
    alert(x);
}

myfunction(); // alerts undefined
myfunction(1); // alerts 1
myfunction(1,2,3); // alerts 1

Если вы передаете больше параметров, чем указано в подписи, вы можете использовать arguments.

function myfunction(x) {
    alert(x);
    console.log(arguments);
}

myfunction(1,2,3); // alerts 1, logs [1,2,3]

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

myFunction(1,2,3,4,5,6,7,'etc');

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

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

Например:

function myfunction(x) {
    return x*2;
}

Выдает ошибку; хотя, вероятно, только NaN(в данном случае) или variable is undefined.

Если вы опустите аргумент, его значение будет undefined . Это позволяет довольно легко создавать необязательные параметры.

Еще одна особенность - это возможность определять функцию без параметров и успешно вызывать ее с аргументами, используя argumentsобъект. Это позволяет легко создавать массивы аргументов переменной длины.

В javascript console.log внутри функции выдает undefined в качестве вывода для непроходящих параметров, но вне функции он дает неопределенную ошибку, поскольку внутри функции браузеры явно объявляют переменную. Например,

console.log(x) 

дает VM1533: 1 Uncaught ReferenceError: x не определен, тогда как

function test(x) {
console.log(x)
}
test(); 

дает undefined. Это потому, что функция test () переписывается браузером как:

function test(x) {
    var x;
    console.log(x)
    }

Другой пример : -

var x =5 ;
function test(x) {
console.log(x)
}
test(); 

все еще не определено, поскольку функция становится

function test(x) {
    var x;
    console.log(x)
    }

В предупреждении в приведенном ниже примере будет указано значение undefined: -

    var x =5;
    function test() {
    alert(x);
    var x =10;
    }

test(); 

Вышеупомянутая функция станет: -

 function test() {
    var x;
    alert(x);
    x =10;
    }

Объем переменной javascript внутри функции - это область уровня функции, а не уровень блока. Например,

function varScope() {

for(var i = 0; i < 10; i++){
    for(var j = 0; j < 5; j++){}
        console.log("j is "+j)
    }
    console.log("i is "+i);


}
varScope();

даст результат как:

j is 5 
i is 10

Снова функция стала такой: -

  function varScope() {
    var i;
    var j;
    for(i = 0; i < 10; i++){
        for(j = 0; j < 5; j++){}
            console.log("j is "+j)
        }
        console.log("i is "+i);
    }