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 

デモ

いくつかの欠点がありますこのアプローチにます（警告されています！）：

• 最後の引数がオブジェクトの場合、「名前付き引数オブジェクト」として扱われます
• 関数で定義した引数と同じ数の引数を常に取得しますが、それらの一部は値を持つ場合がありますundefined（まったく値がない場合とは異なります）。つまり、を使用arguments.lengthして、渡された引数の数をテストすることはできません。

ラッパーを作成する関数を使用する代わりに、引数として関数とさまざまな値を受け入れる関数を使用することもできます。

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

Function.prototypeあなたができるように拡張することもできます：

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

いいえ -オブジェクトアプローチはこれに対するJavaScriptの答えです。関数が個別のパラメータではなくオブジェクトを想定している場合、これには問題はありません。

この問題は、長い間私の頭を悩ませてきました。私は、多くの言語を身につけている熟練したプログラマーです。私が使用して喜んでいる私のお気に入りの言語の1つはPythonです。Pythonはトリックなしで名前付きパラメーターをサポートします。...（少し前に）Pythonを使い始めて以来、すべてが簡単になりました。すべての言語が名前付きパラメーターをサポートする必要があると私は信じていますが、それは事実ではありません。

多くの人は、「オブジェクトを渡す」トリックを使用して、パラメータに名前を付けていると言います。

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

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

そして、それはうまくいきますが、それ以外のほとんどのIDEに関しては、多くの開発者がIDE内の型/引数のヒントに依存しています。私は個人的にPHPストームを使用しています（PythonのPyCharmやObjective CのAppCodeなどの他のJetBrains IDEと一緒に）

そして、「オブジェクトを渡す」トリックを使用する上での最大の問題は、関数を呼び出すときに、IDEが単一の型ヒントを提供することです。それだけです...どのパラメーターと型がarg1オブジェクト？

だから... "オブジェクトを渡す"トリックは私にはうまくいきません...実際に、関数が期待するパラメーターを知る前に、各関数のdocblockを調べる必要があると、さらに頭痛の種になります。...確かに、既存のコードを維持しているが、新しいコードを書くのは恐ろしいことです。

さて、これは私が使用する手法です。...今、それにはいくつかの問題があるかもしれません、そして一部の開発者は私が間違っていると私に言うかもしれません、そして私はこれらのことになると心を開いています...私は常にタスクを達成するためのより良い方法を検討したいと思っています...したがって、この手法に問題がある場合は、コメントを歓迎します。

/**
 * 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が適切な引数のヒントをすべて提供するので、新しいコードは簡単に書くことができます...そして、後でコードを維持しながら、一目でわかるだけでなく、関数に渡される値だけでなく、引数の名前も。私が目にする唯一のオーバーヘッドは、グローバル名前空間を汚染しないようにするために、引数名をローカル変数として宣言することです。確かに、少し余分な入力が必要ですが、新しいコードを記述したり、既存のコードを維持したりするときにdocblockを検索するのにかかる時間と比べると、取るに足りません。

単に呼び出すのではなく、各パラメータを明確にしたい場合

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"アイデアと組み合わせて、既存の関数から一般的な方法でそのようなオブジェクトを作成することもできます。つまり、パラメーターごとに、関数の部分評価バージョンに評価できるメンバーを作成します。

このアイデアはもちろんシェーンフィンケリング、別名カリーに関連しています。

別の方法があります。参照によってオブジェクトを渡す場合、そのオブジェクトのプロパティは関数のローカルスコープに表示されます。これは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}))

3つの分離された要素に注意してください。関数、名前付き引数を持つオブジェクト、バインディングです。この分離により、この構成を柔軟に使用できるようになります。バインディングは、関数の定義で任意にカスタマイズし、関数呼び出し時に任意に拡張できます。

たとえば、あなたは、省略することもできます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)

警告：

• 引数の順序は維持する必要がありますが、パターンは有用です。これにより、関数のシグネチャをgrepしたり、IDEを使用したりしなくても、どの実引数がどの仮パラメーターを意味するかが明らかになります。

• これはブール値でのみ機能します。ただし、JavaScriptの一意の型強制セマンティクスを使用して、他の型についても同様のパターンを開発できると確信しています。