Controllo per parametro mancante nella funzione

Question

È questo il modo corretto per verificare un parametro mancante in una funzione? Funzionerebbe in tutti i browser? Che ne dici di IE?

function getName(name){ 
    name = name != null ? name : "default"; 
    return name; 
} 

Answer 1

si può fare:

name = name || 'default'; 

che dice che se name è indefinito o falsy (null, 0, "", false, {}, []), impostarlo su "default".

js (h | l) int si lamenterà, ma funziona almeno fino a IE7. Non è nemmeno un codice non valido o si basa su qualche comportamento non documentato.

Answer 2

Il modo corretto per controllare è

if (typeof name === "undefined") { 
    // ... 
} 

dei chiamanti corso può ancora "ingannare" si chiamando getName(undefined), quando un parametro è stato fornito, ma l'assegno sarà di bandiera come non-ha fornito comunque . Ma questo è davvero uno scenario patologico.

Answer 3

Sì questo dovrebbe funzionare in tutti i browser anche se si vuole vedere se è definito è possibile utilizzare:

function getName(name){ 
    name = typeof(name) !== "undefined" ? name : "default"; 
    return name; 
} 

Answer 4

Il modo per verificare la presenza di parametri dipende da che tipo di informazioni si sta passando alla funzione e come vuoi che la tua funzione gestisca i casi limite.

Nella maggior parte dei casi, si può semplicemente utilizzare:

function foo(bar) { 
    bar = bar || ...default value here...; 
} 

Tuttavia, potrebbe essere un problema se il codice è simile al seguente:

function foo(bar) { 
    bar = bar || 5; 
    alert(bar); 
} 
foo(0); //alerts 5, probably not what you wanted 

Così, invece, si potrebbe in genere controlla contro undefined :

function foo(bar) { 
    if (bar == undefined) { 
     bar = ...default value... 
    } 
} 

...tuttavia utilizzando il controllo sciolto consente sia null e undefined da sovrascrivere (null == undefined):

function foo(bar) { 
    if (bar == undefined) { 
     bar = 0; 
    } 
    alert(bar); 
} 
foo(); //alerts 0 
foo(null); //alerts 0 

Così, invece, un confronto di uguaglianza rigorosa (===) è generalmente preferito (null !== undefined):

function foo(bar) { 
    //if you're worried that undefined may be overwritten for any horrible reason 
    //use `typeof bar === 'undefined'` instead 
    if (bar === undefined) { 
     bar = ...default value... 
    } 
} 

Tuttavia, questo potrebbe causare problemi se è necessario sapere se è stato passato il parametro undefined come parametro:

Se si vuole essere assolutamente certi che non stai passando su un argomento che è stato fornito, è possibile controllare il numero di argomenti passati alla funzione:

function foo(bar) { 
    if (arguments.length < 1) { 
     bar = ...default value...; 
    } 
} 

Il che significa che si può superare con successo undefined come un argomento, mentre anche la scelta di utilizzare un default diverso:

function foo(bar) { 
    if (arguments.length < 1) { 
     bar = 0; 
    } 
    alert(bar); 
} 
foo(undefined); //alerts undefined 
foo(); //alerts 0 

---

Se si dispone di più parametri, si consiglia di utilizzare più valori predefiniti. Recentemente ho trovato un caso d'uso per falltrough su un'istruzione switch, anche se the utility is questionable:

function foo(bar, baz, fizz, buzz) { 
    switch (arguments.length) { 
    case 0: 
     bar = 1; 
     //continue; might as well point out that implicit fall-through is desired 
    case 1: 
     baz = 2; 
     //continue; 
    case 2: 
     fizz = 3; 
     //continue; 
    case 3: 
     buzz = 4; 
     //continue; 
    } 
    ...code... 
}