Parámetros con nombre en javascript

No - el enfoque de objetos es la respuesta de JavaScript a esto. No hay problema con esto siempre que su función espere un objeto en lugar de parámetros separados.

Este tema ha sido una molestia para mí durante algún tiempo. Soy un programador experimentado con muchos idiomas en mi haber. Uno de mis lenguajes favoritos que he tenido el placer de usar es Python. Python soporta parámetros con nombre sin ningún truco.... Desde que empecé a usar Python (hace algún tiempo) todo se hizo más fácil. Creo que todos los idiomas deben admitir parámetros con nombre, pero ese no es el caso.

Mucha gente dice que simplemente use el truco de "Pasar un objeto" para que ha nombrado parámetros.

/**
 * My Function
 *
 * @param {Object} arg1 Named arguments
 */
function myFunc(arg1) { }

myFunc({ param1 : 70, param2 : 175});

Y eso funciona muy bien, excepto..... cuando se trata de la mayoría de los IDE, muchos de nosotros los desarrolladores confiamos en sugerencias de tipo / argumento dentro de nuestro IDE. Yo personalmente uso PHP Storm (Junto con otros IDEs de JetBrains como PyCharm para python y AppCode para Objective C)

Y el mayor problema con el uso del truco "Pasar un objeto" es que cuando está llamando a la función, el IDE le da una pista de tipo único y eso es todo... Cómo se supone que vamos a ¿sabe qué parámetros y tipos deben entrar en el objeto arg1?

So... el truco de "Pasar un objeto" no funciona para mí... En realidad causa más dolores de cabeza con tener que mirar docblock de cada función antes de saber qué parámetros espera la función.... Claro, es genial para cuando se está manteniendo el código existente, pero es horrible para escribir código nuevo.

Bueno, esta es la técnica que uso.... Ahora, puede haber algunos problemas con él, y algunos desarrolladores pueden dime que lo estoy haciendo mal, y tengo una mente abierta cuando se trata de estas cosas... Siempre estoy dispuesto a buscar mejores formas de lograr una tarea... Por lo tanto, si hay un problema con esta técnica, entonces los comentarios son bienvenidos.

/**
 * My Function
 *
 * @param {string} arg1 Argument 1
 * @param {string} arg2 Argument 2
 */
function myFunc(arg1, arg2) { }

var arg1, arg2;
myFunc(arg1='Param1', arg2='Param2');

De esta manera, tengo lo mejor de ambos mundos... el nuevo código es fácil de escribir ya que mi IDE me da todas las pistas de argumento adecuadas... Y, manteniendo el código más adelante, puedo ver de un vistazo, no solo el valor pasado a la función, sino también el nombre del argumento. La única sobrecarga que veo es declarar los nombres de sus argumentos como variables locales para evitar contaminar el espacio de nombres global. Claro, es un poco de escritura extra, pero trivial en comparación con el tiempo que lleva buscar docblocks mientras se escribe código nuevo o se mantiene el código existente.

Si desea dejar claro cuáles son cada uno de los parámetros, en lugar de simplemente llamar a

someFunction(70, 115);

¿Por qué no hacer lo siguiente

var width = 70, height = 115;
someFunction(width, height);

Claro, es una línea de código extra, pero gana en legibilidad.

Otra forma sería usar atributos de un objeto adecuado, por ejemplo:

function plus(a,b) { return a+b; };

Plus = { a: function(x) { return { b: function(y) { return plus(x,y) }}}, 
         b: function(y) { return { a: function(x) { return plus(x,y) }}}};

sum = Plus.a(3).b(5);

Por supuesto, para este ejemplo inventado no tiene sentido. Pero en los casos en que la función se ve como

do_something(some_connection_handle, some_context_parameter, some_value)

Podría ser más útil. También podría combinarse con la idea" parameterfy " para crear tal objeto a partir de una función existente de una manera genérica. Es decir, para cada parámetro se crearía un miembro que puede evaluar a una versión parcial evaluada de la función.

Esta idea está, por supuesto, relacionada con Schönfinkeling también conocido como Currying.

Hay otro camino. Si pasa un objeto por referencia, las propiedades de ese objeto aparecerán en el ámbito local de la función. Sé que esto funciona para Safari (no he comprobado otros navegadores) y no se si esta característica tiene un nombre, pero el siguiente ejemplo ilustra su uso.

Aunque en la práctica no creo que esto ofrezca ningún valor funcional más allá de la técnica que ya está utilizando, es un poco más limpio semánticamente. Y todavía requiere pasar un objeto referencia o un objeto literal.

function sum({ a:a, b:b}) {
    console.log(a+'+'+b);
    if(a==undefined) a=0;
    if(b==undefined) b=0;
    return (a+b);
}

// will work (returns 9 and 3 respectively)
console.log(sum({a:4,b:5}));
console.log(sum({a:3}));

// will not work (returns 0)
console.log(sum(4,5));
console.log(sum(4));

Probando Node-6.4.0 ( process.versiones.v8 = '5.0.71.60') y el nodo Chakracore-v7.0.0-pre8 y luego Chrome-52 (V8=5.2.361.49), he notado que los parámetros nombrados están casi implementados, pero ese orden todavía tiene prioridad. No puedo encontrar lo que dice la norma ECMA.

>function f(a=1, b=2){ console.log(`a=${a} + b=${b} = ${a+b}`) }

> f()
a=1 + b=2 = 3
> f(a=5)
a=5 + b=2 = 7
> f(a=7, b=10)
a=7 + b=10 = 17

Pero se requiere orden!! Es el comportamiento estándar?

> f(b=10)
a=10 + b=2 = 12