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

set default value function parameter javascript

Question

Recientemente he aprendido que puede usar una instrucción de cambio ordenada con paso a paso para establecer valores de argumento predeterminados 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";
}
}

Me ha gustado mucho, ya que no solo es muy corto, sino que también funciona en función de los parámetros realmente aprobados, sin depender de tener una clase especial de valores (null, falsy, etc.) que sirvan como marcadores de posición, como en el caso más tradicional. versiones:

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

Sin embargo, después de ver la versión usando el interruptor, debería considerar usarla "por defecto" sobre || versión.

El interruptor de caída no lo hace mucho más largo y tiene la ventaja de que es mucho más "robusto", ya que no se preocupa por los tipos de parámetros. En el caso general, parece una buena idea no tener que preocuparse por lo que sucedería con todos los valores falsos ('''', 0, nulo, falso ...) siempre que tenga que realizar una función con parámetros predeterminados.

Entonces me reservaría el arg = arg || x arg = arg || x para los casos reales en los que quiero verificar la veracidad en lugar de reutilizarla como la regla general para el parámetro predeterminado.

Sin embargo, encontré muy pocos ejemplos de este patrón cuando hice una búsqueda de código , así que tuve que ponerme mi sombrero escéptico. ¿Por qué no encontré más ejemplos de este idioma?

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

Algunas razones en las que yo (y algunos de los comentarios) se me ocurrieron para evitar el switch(arguments.length) :

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

• Tal vez la mayor parte del tiempo queremos verificar la veracidad? El uso de una categoría de valores como marcadores también permite que los parámetros predeterminados aparezcan en el medio en lugar de solo al final: myFunc(''arg1'', null, ''arg3'')

• Quizás la mayoría de la gente simplemente prefiere el arg = arg || "default" muy corto arg = arg || "default" arg = arg || "default" y la mayoría de las veces simplemente no nos importan los valores falsos?

• Tal vez acceder a los arguements es malo / no tiene arguements ?

• Quizás este tipo de cambio de caso de cambio tiene una parte mala en la que no pensé?

¿Son estas desventajas suficientes para evitar el uso de switch(arguments.length) como un patrón de argumento predeterminado básico o es un truco ordenado que debería mantener y usar en mi código?

Answer 1

Dado que la pregunta ha sido actualizada, es realmente una cuestión de opinión. Hay una serie de funciones de javascript que muchas personas sugieren evitar, como switch y ternary. Esta es la razón por la que 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 no usan esas funciones y crean problemas en su código. Los errores a veces son difíciles de detectar y puede ser difícil para otros entender lo que hace su código (especialmente aquellos que no están familiarizados con javascript o nuevos programadores).

Entonces, si te gusta hacerlo de esa manera y no estás preocupado por las opiniones (o nivel de habilidad) de nadie que trabaje en tu código. Por supuesto, su enfoque funcionará. En ocasiones, he usado el comando switch en alguna ocasión, y aunque no creo que sea realmente "bueno" o "malo", es difícil encontrar una situación que lo requiera .

Usted preguntó cómo podría hacer esto sin una cadena if-else:

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 suposición, pero Doug Crockford desalienta el uso de declaraciones de cambio en "JavaScript: las partes buenas". Su lógica es que las instrucciones de conmutación son una fuente común de errores porque es difícil localizarlos cuando se usa la lógica de "falla". Es fácil ver cuándo se desencadena un caso, pero a menudo es difícil determinar si se ha cubierto cada caso en un conjunto de resultados, especialmente si no es su código.