Cosa succede se non passo un parametro in una funzione Javascript?

Sono nuovo nel mondo di Javascript e sto armeggiando con la scrittura di funzioni di base e mi sono imbattuto per caso nell'esempio seguente e non sono sicuro del motivo per cui funziona quando non sto passando un parametro quando la funzione lo richiede.

Funzione di esempio

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

Ora se chiamo la funzione myfunction();mi viene presentato l'avviso. Perché posso chiamare la funzione senza errori o avvisi quando non ho passato un parametro?

MODIFICARE

Non mi aspettavo così tante ottime risposte e non sono ancora in grado di dire quale sia la migliore, quindi posso chiedere alle persone di suggerire la risposta migliore e premierò l'accettazione a quella persona.

Non accadrà nulla, il che significa che non riceverai un errore o un avviso poiché il passaggio dei parametri in JavaScript è opzionale.
Tutti i parametri che non sono stati "forniti" avranno il undefinedvalore .

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

foo(1);

Dentro la foofunzione ora:

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

Puoi persino passare più argomenti, come:

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

È possibile conoscere la quantità di parametri forniti da arguments.lengthdall'interno della funzione.

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

Esempio di funzione utile che gestisce qualsiasi quantità di parametri:

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

Tutti gli argomenti nelle funzioni JavaScript sono opzionali (leggi "digitato in modo approssimativo").

Le funzioni JavaScript possono essere richiamate con qualsiasi numero di argomenti, indipendentemente dal numero di argomenti indicati nella definizione della funzione. Poiché una funzione è tipizzata in modo approssimativo, non è possibile dichiarare il tipo di argomenti che si aspetta ed è legale passare valori di qualsiasi tipo a qualsiasi funzione. Quando una funzione viene invocata con un numero di argomenti inferiore a quelli dichiarati, gli argomenti aggiuntivi hanno il valore indefinito.

È possibile fare riferimento agli argomenti di una funzione all'interno della funzione utilizzando le variabili dell'argomento denominato o l'oggetto arguments. Questo oggetto contiene una voce per ogni argomento passato alla funzione, l'indice della prima voce che inizia da 0. Ad esempio, se a una funzione vengono passati tre argomenti, è possibile fare riferimento all'argomento come segue:

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

• JavaScript - The Definitive Guide, 5a edizione

È così che funziona JavaScript. I parametri sono facoltativi e avranno il valore "non proprio un valore" "undefined" nella funzione se mancano da una chiamata di funzione.

Con "opzionale" intendo proprio questo: invocare qualsiasi funzione implica un elenco arbitrariamente lungo di parametri. Non è necessaria alcuna relazione tra il numero di parametri passati a una funzione e il numero dichiarato . Il modo migliore per pensare a questa dichiarazione, quindi:

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

è che si dichiara una funzione e si associa il nome "a" al primo parametro, "b" al secondo e "c" al terzo. Non è affatto garantito, tuttavia, che qualcuno di questi lo farà effettivamente associato a un valore in una data invocazione della funzione in seguito.

Allo stesso modo, puoi definire una funzione senza alcun parametro e quindi "trovarla" tramite l' argumentsoggetto:

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

Quindi non è così proprio la stessa della prima funzione, ma è vicino nella maggior parte dei modi che contano praticamente.

Il valore "undefined" in JavaScript è un valore, ma la sua semantica è piuttosto insolita per quanto riguarda i linguaggi. In particolare non è esattamente uguale al nullvalore. Inoltre, "undefined" stesso non è una parola chiave; è solo un nome di variabile semi-speciale!

JavaScript non ha valori predefiniti per i parametri di funzione come fanno gli altri linguaggi. Quindi, puoi passare tutti gli argomenti che desideri.

Se non si passa un valore, il parametro è undefined.

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

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

Se passi più parametri di quelli presenti nella firma, puoi usare arguments.

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

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

Puoi anche fornire più argomenti oltre a quello menzionato nella funzione

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

È possibile utilizzare la argumentsproprietà che è un array per visualizzare gli argomenti forniti.

Perché non ci sono errori finché la funzione non si aspetta di essere in grado di lavorare con il parametro che dovresti passare.

Per esempio:

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

Genererebbe un errore; anche se probabilmente solo a NaN(in questo caso) o a variable is undefined.

Se ometti l'argomento, il suo valore sarà undefined . Ciò consente di creare parametri opzionali abbastanza facilmente.

Un'altra caratteristica è la capacità di definire una funzione senza parametri e di chiamarla con argomenti con successo, facendo uso argumentsdell'oggetto. Ciò consente di creare facilmente array di argomenti di lunghezza variabile.

In javascript console.log all'interno di una funzione fornisce undefined come output per parametri non passati ma all'esterno della funzione fornisce un errore non definito in quanto all'interno di una funzione il browser dichiara esplicitamente la variabile. Per es

console.log(x) 

restituisce VM1533: 1 Uncaught ReferenceError: x non è definito mentre

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

dà indefinito. È perché la funzione test () viene riscritta dal browser come:

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

Un altro esempio : -

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

è ancora indefinito quando la funzione diventa

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

L'avviso nell'esempio seguente darà undefined: -

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

test(); 

La funzione di cui sopra diventerà: -

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

L'ambito della variabile javascript all'interno di una funzione è l'ambito a livello di funzione e non a livello di blocco. Per es

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à l'output come:

j is 5 
i is 10

Anche in questo caso la funzione è diventata come: -

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