¿Hay alguna manera de proporcionar parámetros con nombre en una llamada de función en JavaScript?

Encuentro la función de parámetros nombrados en C # bastante útil en algunos casos.

calculateBMI(70, height: 175);

¿Qué puedo usar si quiero esto en JavaScript?

Lo que no quiero es esto:

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

function myFunction(params){
  // Check if params is an object
  // Check if the parameters I need are non-null
  // Blah blah
}

Ese enfoque ya lo he usado. ¿Hay otra manera?

Estoy bien usando cualquier biblioteca para hacer esto.

ES2015 y posterior

En ES2015, la desestructuración de parámetros se puede utilizar para simular parámetros con nombre. Requeriría que la persona que llama pasara un objeto, pero puede evitar todas las comprobaciones dentro de la función si también utiliza parámetros predeterminados:

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

function myFunction({param1, param2}={}){
  // ...function body...
}

// Or with defaults, 
function myFunc({
  name = 'Default user',
  age = 'N/A'
}={}) {
  // ...function body...
}

ES5

Hay una manera de acercarse a lo que desea, pero se basa en la salida de Function.prototype.toString ^[ES5] , que depende en cierta medida de la implementación, por lo que podría no ser compatible con varios navegadores.

La idea es analizar los nombres de los parámetros de la representación de cadena de la función para que pueda asociar las propiedades de un objeto con el parámetro correspondiente.

Una llamada a la función podría verse así

func(a, b, {someArg: ..., someOtherArg: ...});

donde ay bson argumentos posicionales y el último argumento es un objeto con argumentos nombrados.

Por ejemplo:

var parameterfy = (function() {
    var pattern = /function[^(]*\(([^)]*)\)/;

    return function(func) {
        // fails horribly for parameterless functions ;)
        var args = func.toString().match(pattern)[1].split(/,\s*/);

        return function() {
            var named_params = arguments[arguments.length - 1];
            if (typeof named_params === 'object') {
                var params = [].slice.call(arguments, 0, -1);
                if (params.length < args.length) {
                    for (var i = params.length, l = args.length; i < l; i++) {
                        params.push(named_params[args[i]]);
                    }
                    return func.apply(this, params);
                }
            }
            return func.apply(null, arguments);
        };
    };
}());

Que usarías como:

var foo = parameterfy(function(a, b, c) {
    console.log('a is ' + a, ' | b is ' + b, ' | c is ' + c);     
});

foo(1, 2, 3); // a is 1  | b is 2  | c is 3
foo(1, {b:2, c:3}); // a is 1  | b is 2  | c is 3
foo(1, {c:3}); // a is 1  | b is undefined  | c is 3
foo({a: 1, c:3}); // a is 1  | b is undefined  | c is 3 

MANIFESTACIÓN

Hay algunos inconvenientes en este enfoque (¡ya te lo advertimos!):

• Si el último argumento es un objeto, se trata como un "objeto de argumento con nombre"
• Siempre obtendrá tantos argumentos como haya definido en la función, pero algunos de ellos pueden tener el valor undefined(eso es diferente de no tener ningún valor). Eso significa que no puede usar arguments.lengthpara probar cuántos argumentos se han pasado.

En lugar de tener una función que cree el contenedor, también podría tener una función que acepte una función y varios valores como argumentos, como

call(func, a, b, {posArg: ... });

o incluso extender Function.prototypepara que puedas hacer:

foo.execute(a, b, {posArg: ...});

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

Este problema ha sido una manía mía desde hace algún tiempo. Soy un programador experimentado con muchos idiomas en mi haber. Uno de mis idiomas favoritos que he tenido el placer de usar es Python. Python admite parámetros con nombre sin ningún truco ... Desde que comencé a usar Python (hace algún tiempo) todo se volvió más fácil. Creo que cada idioma debe admitir parámetros con nombre, pero ese no es el caso.

Mucha gente dice que use el truco "Pasar un objeto" para que haya nombrado los 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 IDE 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 se llama a la función, el IDE le da una pista de tipo único y eso es todo ... ¿Cómo se supone que debemos saber qué parámetros y tipos deben entrar en el objeto arg1?

Entonces ... el truco "Pasar un objeto" no funciona para mí ... En realidad, causa más dolores de cabeza al tener que mirar el bloque de documentos de cada función antes de saber qué parámetros espera la función ... Claro, es genial para cuando mantiene 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 ella, y algunos desarrolladores pueden decirme 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 ... Entonces, 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 sugerencias de argumento adecuadas ... Y, mientras mantengo el código más adelante, puedo ver de un vistazo, no solo el valor pasado a la función, pero 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 tipeo adicional, pero trivial en comparación con el tiempo que lleva buscar docblocks mientras escribe un código nuevo o mantiene el código existente.

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

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 utilizar los atributos de un objeto adecuado, por ejemplo, así:

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 es algo sin sentido. Pero en casos donde 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 de "parameterfy" para crear dicho objeto a partir de una función existente de forma genérica. Es decir, para cada parámetro crearía un miembro que puede evaluar una versión parcial evaluada de la función.

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

Hay otra manera 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 sé 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 una referencia de objeto o un literal de objeto.

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));

Al probar Node-6.4.0 (process.versions.v8 = '5.0.71.60') y Node Chakracore-v7.0.0-pre8 y luego Chrome-52 (V8 = 5.2.361.49), noté que los parámetros con nombre son casi implementado, pero ese orden todavía tiene precedencia. No puedo encontrar lo que dice el estándar 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

Función fde llamada con parámetros con nombre pasados ​​como objeto

o = {height: 1, width: 5, ...}

básicamente está llamando a su composición f(...g(o))donde estoy usando la sintaxis de propagación y ges un mapa "vinculante" que conecta los valores de los objetos con sus posiciones de parámetros.

El mapa de enlace es precisamente el ingrediente que falta, que puede representarse por la matriz de sus claves:

// map 'height' to the first and 'width' to the second param
binding = ['height', 'width']

// take binding and arg object and return aray of args
withNamed = (bnd, o) => bnd.map(param => o[param])

// call f with named args via binding
f(...withNamed(binding, {hight: 1, width: 5}))

Tenga en cuenta los tres ingredientes desacoplados: la función, el objeto con argumentos con nombre y el enlace. Este desacoplamiento permite mucha flexibilidad para usar esta construcción, donde el enlace puede personalizarse arbitrariamente en la definición de la función y ampliarse arbitrariamente en el momento de la llamada a la función.

Por ejemplo, es posible que desee abreviar heighty widthcomo hy wdentro de la definición de su función, para que sea más corta y limpia, mientras que aún desea llamarlo con nombres completos para mayor claridad:

// use short params
f = (h, w) => ...

// modify f to be called with named args
ff = o => f(...withNamed(['height', 'width'], o))

// now call with real more descriptive names
ff({height: 1, width: 5})

Esta flexibilidad también es más útil para la programación funcional, donde las funciones pueden transformarse arbitrariamente con la pérdida de sus nombres de parámetros originales.

Viniendo de Python esto me molestó. Escribí un contenedor / Proxy simple para el nodo que aceptará objetos posicionales y de palabras clave.

https://github.com/vinces1979/node-def/blob/master/README.md

Al contrario de lo que comúnmente se cree, los parámetros con nombre pueden implementarse en JavaScript estándar de la vieja escuela (solo para parámetros booleanos) mediante una convención de codificación simple y ordenada, como se muestra a continuación.

function f(p1=true, p2=false) {
    ...
}

f(!!"p1"==false, !!"p2"==true); // call f(p1=false, p2=true)

Advertencias:

• Se debe preservar el orden de los argumentos, pero el patrón sigue siendo útil, ya que deja en claro qué argumento real se entiende para qué parámetro formal sin tener que buscar la firma de la función o usar un IDE.

• Esto solo funciona para booleanos. Sin embargo, estoy seguro de que se podría desarrollar un patrón similar para otros tipos utilizando la semántica de coerción de tipos única de JavaScript.