자 바스 크 립 트 함수 코 리 화 (자 바스 크 립 트 모드 참조)

일부 함수 식 프로 그래 밍 언어 에서 함수 에 대한 설명 은 호출 되 는 것 이 아니 라 응용 된다.JS 에서 우 리 는 Function. prototype. apply () 로 함 수 를 응용 할 수 있 습 니 다.

// define a function
var sayHi = function (who) {
    return "Hello" + (who ? ", " + who : "") + "!";
};

// invoke a function
sayHi(); // "Hello"
sayHi('world'); // "Hello, world!"

// apply a function
sayHi.apply(null, ["hello"]); // "Hello, hello!"

이상 에서 우 리 는 하나의 함 수 를 호출 하 는 것 이 사실상 그것 에 한 무더기 의 인 자 를 응용 하 는 것 이 라 고 볼 수 있다.그럼 일부 인자 만 전달 하고 전 부 를 전달 하지 않 을 수 있 습 니까?
함수 add () 가 있다 고 가정 하면 x 와 y 를 추가 하 는 데 사 용 됩 니 다. 다음은 계산 절차 입 니 다.

// for illustration purposes
// not valid JavaScript

// we have this function
function add(x, y) {
    return x + y;
}

// and we know the arguments
add(5, 4);

// step 1 -- substitute one argument
function add(5, y) {
    return 5 + y;
}

// step 2 -- substitute the other argument
function add(5, 4) {
    return 5 + 4;
}

step 1 은 일부 응용 프로그램 입 니 다. 우 리 는 그것 에 하나의 인자 만 적 용 했 습 니 다.
한 부분 을 실행 할 때 결 과 를 얻 지 못 하고 다른 함수 입 니 다.우 리 는 함수 curry () 가 있다 고 가정 합 니 다. add () 의 일부 응용 을 처리 합 니 다.

var add = function (x, y) {
    return x + y;
};

// full application
add(5, 4); // 9

//a new function
var newadd = curry(add, 5);

// applying an argument to the new function
newadd(4); // 9

일부 응용 은 우리 에 게 다른 함 수 를 주 었 는데, 이 함 수 는 잠시 후에 호출 될 때 다른 인 자 를 받 을 수 있다.
함수 로 하여 금 일부 응용 과정 을 이해 하고 처리 하 게 하 는 것 을 코 리 화 (Currying) 라 고 합 니 다.
우 리 는 add () 자체 가 일부 응용 프로그램 을 처리 하도록 시도 합 니 다.

// a curried add

function add(x, y) {
    if (typeof y === "undefined") { 
        return function (y) {
            return x + y;
        };
    }

    // full application
    return x + y;
}

돌아 오 는 함수 가 패 킷 을 만 들 었 습 니 다. 외부 함수 에 접근 할 수 있 는 인자 입 니 다.
더 나 아가 고려: 임의의 함 수 를 처리 하고 새로운 함 수 를 얻어 일부 인 자 를 처리 할 수 있 습 니까?(즉, 위 에서 가설 한 curry () 함수) 아래 에서 curry () 함 수 를 실현 합 니 다.

function curry(fn) {
    var slice = Array.prototype.slice,
    stored_args = slice.call(arguments, 1);
    return function () {
        var new_args = slice.call(arguments),
        args = stored_args.concat(new_args);
        return fn.apply(null, args);
    };
}

❶ curry () 는 좀 복잡 하 다.JS 에서 arguments 는 진정한 배열 이 아니 라 Array. prototype. slice () 를 이용 하여 배열 로 전환 하여 더욱 잘 조작 할 수 있 음 을 알 수 있 습 니 다.
카레이 가 처음 호출 되 었 을 때, storedargs 는 호출 할 때 첫 번 째 를 제외 한 인 자 를 저장 합 니 다. 첫 번 째 인 자 는 코 리 화 된 함수 이기 때 문 입 니 다.
수천수만 카레 () 는 새로운 함 수 를 되 돌려 주 었 습 니 다. 이 새로운 함수 가 호출 되 었 을 때 폐쇄 적 으로 일부 매개 변 수 를 저장 한 stored 에 접근 할 수 있 습 니 다.args 와 slice.
마지막 으로 새 함 수 는 오래된 부분 에 적 용 된 인자 (stored args) 와 새로운 인자 (new args) 를 합 쳐 원래 함수 fn (패 킷 을 통 해 접근) 에 적용 하면 됩 니 다.
다음은 테스트 입 니 다.

// a normal function
function add(x, y) {
    return x + y;
}

// curry a function to get a new function
var newadd = curry(add, 5);
newadd(4); // 9

// another option -- call the new function directly
curry(add, 6)(7); // 13

————————————————————————————————

// a normal function
function add(a, b, c, d, e) {
    return a + b + c + d + e;
}

// works with any number of arguments
curry(add, 1, 2, 3)(5, 5); // 16

// two-step currying
var addOne = curry(add, 1);
addOne(10, 10, 10, 10); // 41
var addSix = curry(addOne, 2, 3);
addSix(5, 5); // 16