어드민

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: ...});

답변

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

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

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

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

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)

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

>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