Come passare il valore 'indefinito' a una funzione con più parametri?

Question

Voglio passare il valore di "non definito" su una funzione a parametri multipli ma senza omettere il parametro.

Cosa intendo con "senza omettere il parametro". Voglio dire che non dovremmo semplicemente omettere il parm2 come in questo esempio:

function myFunction (parm1, parm2) {} 
myFunction("abc"); 

questo sarà davvero fare parm2 indefinito, ma comunque non mi è permesso di farlo in questo modo perché ho bisogno di specificare altri parametri dopo l'omesso parametro.

Quindi nel caso in cui voglio rendere non definito parm1 MA, anche altri parametri dopo questo per contenere un valore non funzioneranno con il metodo precedente.

ho provato con:

myFunction(,"abc"); //don't seem to work 

E:

myFunction(undefined,"abc"); //neither work 

Answer 1

Un approccio migliore potrebbe essere di passaggio oggetto con gli attributi di nome e poi cercare quei valori specifici degli attributi. In questo modo non devi essere dipendente dal numero di argomenti.

Answer 2

penso che il più vicino si arriva a questo sta passando null come parametro. Non è undefined, ma per la maggior parte dei casi è abbastanza vicino.

Answer 3

ho appena avuto un'idea e sembra funzionare:

var undf; 

myFunction(undf, "abc"); 

Sono sicuro che ci sono modi migliori, ma vi posto questo

Answer 4

myFunction(undefined,"abc"); questo modo dovrebbe funzionare, qual è il problema?

vedere here

Here is undefined documentation da Mozilla, supportato da tutti i browser

Answer 5

tenta di utilizzare questo metodo se si ha intenzione di aggiunta di una quantità indefinita di parametri:

function myFunc(params) { 
    // Define default values 
    var name = 'John'; 
    var age = '40'; 
    // You can loop through them 
    for (var p in params) { 
     alert(p + ':' + params[p]); 
    } 
    // And read them in like this 
    if (typeof params.name != 'undefined') { 
     name = params.name; 
    } 
    if (typeof params.age != 'undefined') { 
     age = params.age; 
    } 
    alert(name + ' ' + age); 
} 

alert('test1'); 
myFunc({name:'Bob', age:'30'}); 
alert('test2'); 
myFunc({name:'Bob'}); 

Answer 6

myFunction(undefined,"abc") deve assolutamente lavorare, a meno che qualcuno crudele non abbia ridefinitoundefined! Se si vuole essere sicuri, ci sono decine di modi per ottenere il valore indefinito che evitano l'ipotesi che la cosa chiamata "indefinito" in effetti ha lo speciale valore indefinito:

void 0 
var undef; undef 
[][0] 
{}.foo 
// `undef` is guaranteed to have the undefined value within this closure 
(function(undef){ undef }()) 
// this expression evaluates as undefined 
(function(){}()) 

void 0 è il più utilizzato (compilato CoffeeScript include questo ovunque sia richiesto il valore non definito).

Answer 7

Se la sua possibile, si potrebbe riorganizzare la funzione myFunction (parm2, parm1)

es. cercare di garantire che i parametri non definiti siano gli ultimi nella funzione, questo potrebbe non funzionare se vengono introdotti più parametri.

Answer 8

Il void operator sembra essere il modo più comune per ottenere esplicitamente undefined.

Si potrebbe usare in questo modo nel tuo esempio:

myFunction(void 0, "abc"); 

E 'anche un metodo affidabile per il confronto contro undefined che è custodito contro undefined accidentale sovrascritto in ambienti JavaScript anziani:

var x; 
if (x === void 0) { 
    // this will execute 
} 

Answer 9

È possibile utilizzare apply e una serie di parametri per passare "non definito" come uno dei parametri. Ad esempio, si voleva passare parm1 come "indefinito":

function myFunction (parm1, parm2) { 

    if(typeof (parm1) === "undefined"){ 
     alert("parm1 is undefined") 
    } 

    if(typeof (parm2) === "undefined"){ 
     alert("parm2 is undefined") 
    } 

} 

var myParameters = [undefined, "abc"]; 

myFunction.apply(valueForThis, myParameters); 

Answer 10

Un modo semplice di fare questo, quando accettabile è quello di passare indefinito. Ma meglio ancora come segue per W3C

Javascript-missing arguments

function myFunction(x, y) { 
if (y === undefined) { 
     y = 0; 
    } 
} 

Answer 11

tanto per fare un esempio su ciò che @dbrin stavo spiegando, e @alphapilgrim avrebbe desiderato per controllare.

simpleFunction({params1:12, params2:"abc"}); //use expected arguments 
 
simpleFunction({params2:"abc"}); //use only one 
 
simpleFunction({params2:"abc", params1:12, iDoNotExist:"I will not be included"}); //use expected arguments in any order 
 
simpleFunction(); //ignore arguments and uses defaults 
 
simpleFunction(2123); //ignores non object arguments 
 

 
function simpleFunction(someParams){ 
 
    var myParams = { 
 
    params1:null, 
 
    params2:"cde" //default value for second parameter 
 
    }; 
 
    simpleExtend(myParams, someParams); 
 
    
 
    console.log(myParams); 
 

 
} 
 

 

 
//to include in your utilities 
 
function simpleExtend(currentParams, newParams){ 
 
    
 
    if(typeof currentParams !== "undefined" && typeof newParams !== "undefined"){ 
 
    Object.keys(newParams).forEach(function(key){ 
 
    
 
     if(typeof currentParams[key] !== "undefined"){ 
 
     currentParams[key] = newParams[key];  
 
     } 
 

 
    }); 
 
    
 
    
 
    } 
 
    
 
    
 

 
}