¿Es una buena idea usar un conmutador con Fallthrough para manejar los argumentos predeterminados en Javascript?

Question

he sabido recientemente que se puede utilizar una sentencia switch ordenada con fallthrough para establecer valores de los argumentos por defecto en Javascript:

function myFunc(arg1, arg2, arg3) { 
    //replace unpassed arguments with their defaults: 
    switch (arguments.length) { 
     case 0 : arg1 = "default1"; 
     case 1 : arg2 = "default2"; 
     case 2 : arg3 = "default3"; 
    } 
} 

que han crecido a gustar mucho, ya que no sólo es muy corto, pero también obras basadas en parámetros pasados ​​realmente, sin depender de tener una clase especial de valores (null, Falsy, etc.) sirven como marcadores de posición al igual que en las versiones más tradicionales:

function myFunc(arg1, arg2, arg3){ 
    //replace falsy arguments with their defaults: 
    arg1 = arg1 || "default1"; 
    arg2 = arg2 || "default2"; 
    arg3 = arg3 || "default3"; 
} 

Mi inital aunque después de ver la versión que utiliza el cambio fue que debería considerar usarlo "por defecto" sobre la versión ||.

El interruptor se carece aunque hace que no sea mucho más largo y tiene la ventaja de que es mucho más "robusto" en cuanto a que no se preocupa por los tipos de los parámetros. En el caso general, parece una buena idea no tener que preocuparse por lo que sucedería con todos los valores falsy ('', 0, null, false ...) cada vez que tuviera que hacer una función con parámetros predeterminados.

Yo reservaría el arg = arg || x para los casos reales en los que deseo verificar la verosimilitud en lugar de reutilizarlo como la regla general para el incumplimiento de parámetros.

Sin embargo, encontré very few ejemplos de este patrón cuando hice un code search para él así que tuve que ponerme mi sombrero escéptico. ¿Por qué no encontré más ejemplos de este modismo?

• ¿Es ahora muy conocido?
• ¿No busqué lo suficiente? ¿Me confundí con la gran cantidad de falsos positivos?
• ¿Hay algo que lo haga inferior a las alternativas?

Algunas de las razones que yo (y algunos de los comentarios) podía imaginar para evitar switch(arguments.length):

• Uso de parámetros con nombre pasados ​​a través de un objeto literal que es muy flexible y extensible. Tal vez los lugares donde más argumentos pueden ser opcionales están usando esto en su lugar?

• Tal vez la mayoría de las veces ¿ quiere comprobar la veracidad? Usando una categoría de valores como palceholders también permite a los parámetros por defecto aparecen en el medio en lugar de sólo al final: myFunc('arg1', null, 'arg3')

• Tal vez la mayoría de la gente simplemente prefieren el muy corto arg = arg || "default" y la mayoría de las veces simplemente no importa valores falsy?

• Quizás accediendo arguements es malo/unperformant?

• Tal vez este tipo de casos interruptor fallthrough tiene una parte mala Yo no pienso?

Son estos inconvenientes suficientes para evitar el uso de switch(arguments.length) como un patrón argumento por defecto básico o es un truco que debería tener y usar en mi código?

Answer 1

Dado que la pregunta se ha actualizado, es realmente una cuestión de opinión. Hay una serie de características de javascript que muchas personas sugieren evitar, como el cambio y el ternario. Esta es la razón por la cual no hay mucha información sobre algunas de esas características.

La razón por la que se hace esta sugerencia es porque muchas personas pierden el uso de esas características y crean problemas en su código. Los errores a veces son difíciles de detectar y puede ser difícil para otros comprender qué está haciendo su código (especialmente aquellos que no están familiarizados con javascript o programadores nuevos).

Así que si le gusta hacerlo de esa manera, y no le preocupan las opiniones (o el nivel de habilidad) de cualquiera que trabaje en su código. Por supuesto, su enfoque funcionará. En ocasiones, he usado la declaración de cambio y, aunque no creo que sea realmente "buena" o "mala", es difícil encontrar una situación que requiera.

Se preguntó cómo podría ir sobre esto sin una cadena de else if-:

function myFunc(args) { 
    var allArgs = { 
     arg1:"default1", 
     arg2:"default2", 
     arg3:"default3" 
    }; 
    for (var key in args) { 
     allArgs[key] = args[key];   
    } 
} 
myFunc({arg1:null, arg3:'test'}) 

Answer 2

Solo una conjetura, pero Doug Crockford desalienta el uso de declaraciones de interruptor en 'JavaScript: las partes buenas'. Su lógica es que las declaraciones de cambio son una fuente común de errores porque es difícil ubicarlos cuando se utiliza la lógica de 'atravesar'. Es fácil de ver cuando se desencadena un caso, pero a menudo es difícil determinar si se han cubierto todos los casos en un conjunto de resultados, especialmente si no es su código.