Comprobación de la falta de parámetro en la función

Question

¿Es esta la forma correcta de verificar si falta un parámetro en una función? ¿Esto funcionaría en todos los navegadores? ¿Qué hay de IE?

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

Answer 1

que puede hacer:

name = name || 'default'; 

que dice que si no está definido name o Falsy (null, 0, "", false, {}, []), la pusieron a "default".

js (h | l) int se quejarán de ello, pero funciona al menos hasta IE7. Tampoco es un código inválido o depende de algún comportamiento no documentado.

Answer 2

La forma correcta de comprobar es

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

de las personas que llaman por supuesto, todavía puede "engañar" a usted llamando getName(undefined), cuando un parámetro se ha proporcionado, pero el cheque será marcarlo como no siempre-sin embargo, . Pero eso es realmente un escenario patológico.

Answer 3

Si esto funcionaría en todos los navegadores, aunque si quieres para ver si se define que podría utilizar:

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

Answer 4

La forma de comprobar los parámetros depende de qué tipo de información que está pasando a la función, y cómo desea que su función maneje casos extremos.

En la mayoría de los casos, sólo tiene que utilizar:

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

Sin embargo, podría ser un problema si su código es el siguiente:

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

Así que en lugar, normalmente se puede comprobar en contra undefined :

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

...sin embargo el uso de la verificación de suelta permite tanto null y undefined a sobrescribir (null == undefined):

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

Así que en lugar, se prefiere generalmente una comparación de igualdad estricta (===) (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... 
    } 
} 

Sin embargo, esto podría ocasionar problemas si necesita saber si se pasó undefined como parámetro:

function foo(bar) { 
    if (bar === undefined) { 
     bar = 0; 
    } 
    alert(bar); 
} 
foo(undefined); //alerts 0, which may or may not be desired 

Si quieres estar absolutamente seguro de que usted no está pasando por un argumento que se proporcionó, se puede comprobar el número de argumentos pasados ​​a la función:

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

Lo que significa que puede pasar con éxito como undefined un argumento a la vez que la elección de utilizar un valor predeterminado diferente:

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

---

Si tiene varios parámetros, es posible que desee utilizar múltiples incumplimientos. He descubierto recientemente un caso de uso para fallthrough en una sentencia switch, aunque 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... 
}