O que acontece se eu não passar um parâmetro em uma função Javascript?

Eu sou novo no mundo do Javascript e estou tentando escrever funções muito básicas e tropecei no exemplo abaixo por acidente e não tenho certeza de por que funciona quando não estou passando um parâmetro quando a função exige.

Função de amostra

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

Agora, se eu chamar a função, myfunction();o alerta será apresentado. Por que consigo chamar a função sem erros ou avisos quando não passei um parâmetro?

EDITAR

Não esperava tantas respostas boas e não estou de forma alguma em posição de dizer qual é a melhor, então posso pedir às pessoas que sugiram a melhor resposta e concederei a aceitação a essa pessoa.

Nada acontecerá - o que significa que você não receberá um erro ou um aviso, pois passar os parâmetros em javascript é opcional.
Todos os parâmetros que não foram "fornecidos" terão o undefinedvalor .

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

foo(1);

Dentro da foofunção agora:

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

Você pode ainda passar mais argumentos, como:

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

Você pode saber a quantidade de parâmetros fornecidos por arguments.lengthdentro da função.

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);

Exemplo de função útil que manipula qualquer quantidade de parâmetros:

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));

Todos os argumentos em funções JavaScript são opcionais (leia-se "digitado livremente").

As funções JavaScript podem ser chamadas com qualquer número de argumentos, independentemente do número de argumentos nomeados na definição da função. Como uma função é digitada livremente, não há como declarar o tipo de argumento que ela espera, e é legal passar valores de qualquer tipo para qualquer função. Quando uma função é chamada com menos argumentos do que os declarados, os argumentos adicionais têm o valor indefinido.

Você pode referir-se aos argumentos de uma função dentro da função usando as variáveis ​​de argumento nomeadas ou o objeto de argumentos. Este objeto contém uma entrada para cada argumento passado para a função, o índice da primeira entrada começando em 0. Por exemplo, se uma função recebe três argumentos, você pode referir-se ao argumento da seguinte maneira:

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

• JavaScript - The Definitive Guide, 5th Edition

É assim que o JavaScript funciona. Os parâmetros são opcionais e terão o valor não realmente um valor "indefinido" na função se eles estiverem ausentes em uma chamada de função.

Por "opcional" quero dizer exatamente isso: invocar qualquer função envolve uma lista arbitrariamente longa de parâmetros. Não é necessário haver relação entre o número de parâmetros passados para uma função e o número declarado . A melhor maneira de pensar nesta declaração, então:

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

é que você está declarando uma função e associando o nome "a" ao primeiro parâmetro, "b" ao segundo e "c" ao terceiro. Não é de forma alguma garantido, no entanto, que qualquer um desses realmente vinculado a um valor em qualquer chamada da função posteriormente.

Do mesmo modo, você pode definir uma função sem nenhum parâmetro e, em seguida, "encontrá-los" por meio do argumentsobjeto:

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

Portanto, não é exatamente o mesmo que a primeira função, mas é semelhante na maioria dos aspectos que contam na prática.

O valor "indefinido" em JavaScript é um valor, mas sua semântica é meio incomum no que diz respeito às linguagens. Em particular, não é exatamente igual ao nullvalor. Além disso, "undefined" em si não é uma palavra-chave; é apenas um nome de variável semi-especial!

JavaScript não tem valores padrão para parâmetros de função como outras linguagens fazem. Portanto, você pode passar tantos ou tão poucos argumentos quanto quiser.

Se você não passar um valor, o parâmetro é undefined.

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

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

Se você passar mais parâmetros do que na assinatura, você pode usar arguments.

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

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

Você também pode fornecer mais argumentos do que apenas aquele mencionado na função

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

Você pode usar a argumentspropriedade que é uma matriz para visualizar os argumentos fornecidos.

Porque não há erro até que a função espere poder trabalhar com o parâmetro que você deve passar.

Por exemplo:

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

Iria lançar um erro; embora provavelmente apenas a NaN(neste caso) ou a variable is undefined.

Se você omitir o argumento, seu valor será undefined. Isso permite que você crie parâmetros opcionais com bastante facilidade.

Outra característica é a possibilidade de definir uma função sem parâmetros, e chamá-la com argumentos com sucesso, utilizando o argumentsobjeto. Isso permite que você crie facilmente matrizes de argumentos de comprimento variável.

Em javascript console.log dentro de uma função dá undefined como saída para parâmetros não passados, mas fora da função não dá erro definido porque dentro de uma função os navegadores declaram explicitamente a variável. Por exemplo

console.log(x) 

dá VM1533: 1 não capturado ReferenceError: x não está definido, enquanto

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

dá indefinido. É porque a função test () é reescrita pelo navegador como:

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

Outro exemplo : -

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

ainda está indefinido conforme a função se torna

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

O alerta no exemplo abaixo dará indefinido: -

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

test(); 

A função acima se tornará: -

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

O escopo da variável javascript dentro de uma função é o escopo no nível da função e não no nível do bloco. Por exemplo

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();

dará saída como:

j is 5 
i is 10

Mais uma vez, a função tornou-se como: -

  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);
    }