Есть ли способ предоставить именованные параметры в вызове функции в JavaScript?

Я считаю функцию именованных параметров в C # весьма полезной в некоторых случаях.

calculateBMI(70, height: 175);

Что я могу использовать, если я хочу это в JavaScript?

Чего я не хочу, так это:

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
}

Такой подход я уже использовал. Есть ли другой способ?

Я в порядке, используя любую библиотеку, чтобы сделать это.

ES2015 и позже

В ES2015 деструктуризация параметров может использоваться для моделирования именованных параметров. Требуется, чтобы вызывающая сторона передала объект, но вы можете избежать всех проверок внутри функции, если вы также используете параметры по умолчанию:

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

Есть способ приблизиться к тому, что вы хотите, но он основан на выводе Function.prototype.toString ^[ES5] , который в некоторой степени зависит от реализации, поэтому он может быть несовместим с браузерами.

Идея состоит в том, чтобы проанализировать имена параметров из строкового представления функции, чтобы можно было связать свойства объекта с соответствующим параметром.

Вызов функции может выглядеть так

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

где aи bявляются позиционными аргументами, а последний аргумент является объектом с именованными аргументами.

Например:

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

Который вы бы использовали как:

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 

DEMO

У этого подхода есть некоторые недостатки (вас предупредили!):

• Если последний аргумент является объектом, он обрабатывается как «объекты именованного аргумента»
• Вы всегда получите столько аргументов, сколько вы определили в функции, но некоторые из них могут иметь значение undefined(это отличается от отсутствия значения вообще). Это означает, что вы не можете использовать, arguments.lengthчтобы проверить, сколько аргументов было передано.

Вместо того, чтобы иметь функцию, создающую оболочку, вы также можете иметь функцию, которая принимает функцию и различные значения в качестве аргументов, такие как

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

или даже расширить, Function.prototypeчтобы вы могли сделать:

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

Нет - объектный подход является ответом JavaScript на это. С этим нет проблем, если ваша функция ожидает объект, а не отдельные параметры.

Эта проблема была моей любимой мозолью в течение некоторого времени. Я опытный программист со многими языками под моим поясом. Один из моих любимых языков, которые я имел удовольствие использовать, это Python. Python поддерживает именованные параметры без каких-либо хитростей .... С тех пор, как я начал использовать Python (некоторое время назад), все стало проще. Я считаю, что каждый язык должен поддерживать именованные параметры, но это не так.

Многие люди говорят, что нужно просто использовать трюк «Передать объект», чтобы вы назвали параметры.

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

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

И это прекрасно работает, за исключением ..... когда речь идет о большинстве IDE, многие из нас, разработчиков, полагаются на подсказки типа / аргумента в нашей IDE. Я лично использую PHP Storm (наряду с другими средами разработки JetBrains, такими как PyCharm для python и AppCode для Objective C)

И самая большая проблема с использованием трюка «Передача объекта» состоит в том, что когда вы вызываете функцию, IDE дает вам подсказку одного типа, и все ... Как мы должны знать, какие параметры и типы должны входить в объект arg1?

Итак ... трюк "Передача объекта" у меня не работает ... На самом деле он вызывает больше головной боли, когда приходится смотреть на докблок каждой функции, прежде чем я узнаю, какие параметры ожидает функция .... Конечно, это здорово для когда вы поддерживаете существующий код, но это ужасно для написания нового кода.

Что ж, это техника, которую я использую .... Теперь могут быть некоторые проблемы с этим, и некоторые разработчики могут сказать мне, что я делаю это неправильно, и я непредвзято отношусь к этим вещам ... Я всегда готов искать лучшие способы выполнения задачи ... Так что, если есть проблема с этой техникой, тогда комментарии приветствуются.

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

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

Таким образом, у меня есть лучшее из обоих миров ... новый код легко написать, так как моя IDE дает мне все правильные подсказки аргументов ... И, поддерживая код позже, я могу сразу увидеть, не только значение, переданное функции, а также имя аргумента. Единственные накладные расходы, которые я вижу, это объявление имен ваших аргументов в качестве локальных переменных, чтобы не допустить загрязнения глобального пространства имен. Конечно, это немного лишняя типизация, но она тривиальна по сравнению со временем, которое требуется для поиска докблоков при написании нового кода или поддержке существующего кода.

Если вы хотите прояснить, каков каждый из параметров, а не просто вызывать

someFunction(70, 115);

почему бы не сделать следующее

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

конечно, это дополнительная строка кода, но она выигрывает по удобству чтения.

Другой способ - использовать атрибуты подходящего объекта, например, так:

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

Конечно, для этого выдуманного примера это несколько бессмысленно. Но в тех случаях, когда функция выглядит

do_something(some_connection_handle, some_context_parameter, some_value)

это может быть более полезным. Это также может быть объединено с идеей «parameterfy» для создания такого объекта из существующей функции универсальным способом. Это значит, что для каждого параметра будет создан член, который может оценивать версию функции с частичной оценкой.

Эта идея, конечно, связана с Schönfinkeling aka Curry.

Есть другой способ. Если вы передаете объект по ссылке, свойства этого объекта появятся в локальной области действия функции. Я знаю, что это работает для Safari (не проверял другие браузеры), и я не знаю, есть ли у этой функции имя, но приведенный ниже пример иллюстрирует ее использование.

Хотя на практике я не думаю, что это дает какую-то функциональную ценность помимо техники, которую вы уже используете, семантически немного чище. И это все еще требует передачи ссылки на объект или литерала объекта.

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

Пробуя Node-6.4.0 (process.versions.v8 = '5.0.71.60') и Node Chakracore-v7.0.0-pre8, а затем Chrome-52 (V8 = 5.2.361.49), я заметил, что именованные параметры почти реализован, но этот порядок все еще имеет приоритет. Я не могу найти то, что говорит стандарт 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

Но порядок обязателен !! Это стандартное поведение?

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

Вызов функции fс именованными параметрами, переданными как объект

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

в основном вызывает его композицию, f(...g(o))где я использую синтаксис распространения, и gпредставляет собой «привязывающую» карту, соединяющую значения объекта с их позициями параметров.

Карта привязки - это точно отсутствующий компонент, который может быть представлен массивом его ключей:

// 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}))

Обратите внимание на три разделенных компонента: функцию, объект с именованными аргументами и привязку. Эта развязка обеспечивает большую гибкость в использовании этой конструкции, где привязка может быть произвольно настроена в определении функции и произвольно расширена во время вызова функции.

Например, вы можете захотеть сократить heightи widthкак hи wвнутри определения вашей функции, чтобы сделать ее короче и чище, в то время как вы все еще хотите назвать ее с полными именами для ясности:

// 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})

Эта гибкость также более полезна для функционального программирования, где функции могут быть произвольно преобразованы с потерянными их первоначальными именами параметров.

Исходя из Python, это меня раздражало. Я написал простую оболочку / Прокси для узла, которая будет принимать как позиционные, так и ключевые объекты.

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

Вопреки распространенному мнению, именованные параметры могут быть реализованы в стандартном старом школьном JavaScript (только для логических параметров) с помощью простого, аккуратного соглашения о кодировании, как показано ниже.

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

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

Предостережения:

• Порядок аргументов должен быть сохранен - ​​но шаблон все еще полезен, так как он делает очевидным, какой фактический аргумент предназначен для какого формального параметра, без необходимости искать в сигнатуре функции или использовать IDE.

• Это работает только для логических значений. Однако я уверен, что подобный шаблон может быть разработан для других типов с использованием уникальной семантики приведения типов в JavaScript.