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


90

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.



2
Non vi è alcun sovraccarico basato sulle firme delle funzioni in JS, quindi non importa quanti parametri la funzione "si aspetta". Puoi anche passare parametri che la funzione non è definita per accettare e utilizzare semplicemente gli argomenti della parola chiave per recuperarli.
scrappedcola

@scrappedcola - Cosa intendi per sovraccarico e passaggio di parametri che la funzione non è definita per accettare? Puoi fare degli esempi?
PeanutsMonkey

2
@PeanutsMonkey. Voleva dire che non puoi avere due funzioni: function foo(x){...}e function foo(x,y,z){...}puoi avere solo una funzione per ogni nome.
gdoron supporta Monica

2
@PeanutsMonkey. Sì, non puoi avere function overloadingin js, hai altri modi per deriderlo.
gdoron supporta Monica

Risposte:


114

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


Grazie per la demo live. Non mi aspettavo così tante buone risposte. Quindi se ho una funzione come function myfunction (a,b){}e ho passato i valori myfunction (1,2,3,4,5), presumo che sia ancora valida? Ci si aspetta che ci siano avvisi o errori?
PeanutsMonkey

Non ho capito, ti dispiacerebbe elaborare cosa fa il comando console.logoltre a arguments.length?
PeanutsMonkey

@PeanutsMonkey. Valido! nessun avviso nessun errore, può essere utile anche, ti darò una demo tra un attimo.
gdoron supporta Monica

1
@PeanutsMonkey. Funziona anche con IE se hai installato la console degli sviluppatori, penso che sia installato di default da IE8 +. Non ho capito di cosa hai scritto alert.
gdoron supporta Monica

1
@PeanutsMonkey. 1. Non puoi avere il codice dopo returnche è stato ignorato. 2. non riceverai errori o avvisi. Guarda questa DEMO
gdoron supporta Monica

10

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

7

È 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!


Potresti approfondire cosa intendi per optionalvalore "non proprio un valore" undefined?
PeanutsMonkey

@PeanutsMonkey - Se la variabile non viene fornita, lo sarà undefined.
Derek 朕 會 功夫

@Pointy - Cosa intendi con non vi è alcuna garanzia che uno qualsiasi dei parametri dichiarati sarà effettivamente associato a un valore?
PeanutsMonkey

1
@PeanutsMonkey JavaScript è un linguaggio dinamico . Quando si chiama una funzione, la dichiarazione della funzione non è importante, incluso il numero di parametri. Pertanto, puoi dichiarare una funzione con tutti i parametri che desideri, ma ciò non pone restrizioni sul numero di parametri effettivamente passati quando la tua funzione viene chiamata. (In questo modo, è una specie di C, almeno C ai vecchi tempi.) Quindi, se dichiari un parametro e viene effettuata una chiamata senza che venga fornito alcun valore di parametro, il parametro sarà undefined.
Pointy

3

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]

Grazie. Piuttosto che cross-posting, puoi vedere il mio esempio che ho fornito a David Thomas poiché ricevo ancora l'erroreundefined
PeanutsMonkey,

@PeanutsMonkey: eh? Qual è il tuo problema?
Rocket Hazmat

Non è un problema di per sé. Mi riferivo alla mia domanda di follow-up a David sul passaggio di più parametri che hai incluso nella tua risposta. Quello che non seguo è cosa intendi con logs? Dove lo registra?
PeanutsMonkey

1
@PeanutsMonkey: lo registra nella tua "console JavaScript". Nella maggior parte dei browser puoi premere F12o Ctrl+Shift+Jper accedervi.
Rocket Hazmat

1
La prima frase è scaduta a partire da ES2015 ...
Scimmia eretica

2

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.


@albert arguments non è un array il suo array come l'oggetto vedi
Mahi

1

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.


Va bene, finché non faccio riferimento al parametro nella funzione, non riceverò un errore? È giusto?
PeanutsMonkey

Ora, se elaboro l'esempio che fornisci ie function myfunction(a,b) { var calc = a+b; return;}quindi richiamo la funzione, document.write(myfunction(1.2));perché ottengo ancora il valore di undefinedanche se sto passando un parametro?
PeanutsMonkey

1
Perché non stai restituendo nulla. Devi esplicitamente, nel tuo esempio, restituire un valore: o return calc; o return a+b;(come ultima riga, ovviamente; e quest'ultimo returnal posto di var calc).
David dice di reintegrare Monica il

Quindi vuoi dire che non devo dichiarare una variabile se lo faccio return a+b;?
PeanutsMonkey

@PeanutsMonkey - Puoi leggere di più return qui .
Derek 朕 會 功夫

0

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.


0

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);
    }
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.