patterns - Javascript: patrón de configuración

reveal pattern javascript

Question

Problema : una función de Javascript necesita pocos parámetros para trabajar:

function kick(person, reason, amount) {
// kick the *person* with the *amount*, based on the *reason*
}

Como no hay forma de sobrecargar la función en JS, como lo hace en Java , si debe diseñarse para una fácil mejora futura (adición de parámetros), se puede escribir como:

/* Function Parameters pattern */
function kick() {
// kick the person as in *arguments[0]*, with the amount as in *arguments[1]*,
// based on the reason as in *arguments[2]*, with the strength as in *arguments[3]*
}

o

/* Object Configuration Pattern */
function kick(config) {
// kick the person as in *config.person*, with the amount as in *config.amount*,
// based on the reason as in *config.reason*, with the strength as in *config.strength*
}

Sé que el Patrón de configuración de objetos permite el aumento de las propiedades predeterminadas .

Entonces, la pregunta es: si no necesito aumentar ninguna propiedad con los parámetros, ¿hay alguna razón importante para usar cualquiera de las soluciones propuestas en oposición a la otra?

Answer 1

Las funciones de JavaScript están firmadas solo por su nombre.

Por lo tanto, puedes hacer:

 function kick(x, reason, amount) {
if(reason && amount) {
// do stuff with x as person, reason and amount
}
else if(x) {
// do stuff with x as config
}
else {
// do stuff with no parameters
}
}

Otra solución es usar la variable arguments, que es una matriz que contiene todos los parámetros que pasaron a una función en javascript.

 function kick() {
alert(arguments.length);
}

Answer 2

No tienes que ir estrictamente con ninguno de los tres. Si observa cómo lo hace jQuery, examina el tipo y la cantidad y la posición de los parámetros para determinar qué sabor sobrecargado de la función se está utilizando.

Supongamos que tiene tres sabores de kick() , uno que toma persona, razón y cantidad, y uno que toma solo persona con razón y cantidad obteniendo valores predeterminados y otro que toma un objeto de configuración con al menos una persona en él. Puedes ver dinámicamente cuál de las tres opciones tienes así:

function kick(person, reason, amount) {
if (person.person) {
// must be an object as the first parameter
// extract the function parameters from that object
amount = person.amount;
reason = person.reason;
}
amount = amount || 5; // apply default value if parameter wasn''t passed
reason = reason || "dislike"; // apply default value if parameter wasn''t passed
// now you have person, reason and amount and can do normal processing
// you could have other parameters too
// you just have to be to tell which parameter is which by type and position
// process the kick here using person, reason and amount
}

Answer 3

Usar un objeto tiene algunas ventajas:

1. El código es más legible

Considere las siguientes dos llamadas:

kick({user: u,
reason: "flood",
log: true,
rejoin: false,
timeout: 60000,
privmessage: true});
kick(u, "flood", true, false, 60000, true);

e imagina a alguien más leyendo la llamada. ¿Cuál es la primera true ? Tenga en cuenta también que usted mismo en unos pocos meses estaría en la misma posición exacta (no recordar cuál es el cuarto parámetro para kick es muy similar a no saberlo).

2. Puedes tunear parámetros

Con el enfoque de objeto puede pasar una función un conjunto de parámetros que esta función debe usar para llamar a otra función

function kickgroup(users, parms) {
for (var i=0; i<users.lenght; i++) {
var uparms = Object.create(parms);
uparms.user = users[i];
kick(uparms);
}
}

Tenga en cuenta también que en el caso de arguments no es necesario que se castigue utilizando la sintaxis de arguments[x] . Puede declarar los parámetros y agregarlos a medida que la función evoluciona: cualquier parámetro que no se haya pasado se configurará como undefined (y si lo necesita, puede acceder a arguments.length para distinguir si el llamador pasó explícitamente su función undefined ).