JavaScript
기능적 JavaScript

비고

인자를 함수로 받아들이 기

function transform(fn, arr) {
    let result = [];
    for (let el of arr) {
        result.push(fn(el)); // We push the result of the transformed item to result
    }
    return result;
}

console.log(transform(x => x * 2, [1,2,3,4])); // [2, 4, 6, 8]

보시다시피 transform 함수는 두 개의 매개 변수 인 함수와 컬렉션을 허용합니다. 그런 다음 컬렉션을 반복하고 각 값을 fn 을 호출하여 결과로 푸시합니다.

친숙한가요? 이것은 Array.prototype.map() 작동하는 것과 매우 유사합니다!

console.log([1, 2, 3, 4].map(x => x * 2)); // [2, 4, 6, 8]

고차 함수

일반적으로 다른 함수를 인수로 사용하거나 반환하는 함수를 상위 함수라고합니다.

고차 함수는 다른 함수를 인수로 취할 수있는 함수입니다. 콜백을 전달할 때 상위 함수를 사용하고 있습니다.

function iAmCallbackFunction() {
    console.log("callback has been invoked");
}

function iAmJustFunction(callbackFn) {
    // do some stuff ...

    // invoke the callback function.
    callbackFn();
}

// invoke your higher-order function with a callback function.
iAmJustFunction(iAmCallbackFunction);

고차 함수는 다른 함수를 결과로 반환하는 함수이기도합니다.

function iAmJustFunction() {
    // do some stuff ...

    // return a function.
    return function iAmReturnedFunction() {
        console.log("returned function has been invoked");
    }
}

// invoke your higher-order function and its returned function.
iAmJustFunction()();

신원 모나드

이것은 자바 스크립트로 신원 모나드를 구현 한 예이며, 다른 모나드를 만드는 출발점 역할을 할 수 있습니다.

Douglas Crockford의 모나드 및 생식선 에 대한 회의

이 접근법을 사용하면 함수를 재사용하는 것이이 모나드가 제공하는 유연성과 구성 악몽 때문에 더 쉬울 것입니다.

f(g(h(i(j(k(value), j1), i2), h1, h2), g1, g2), f1, f2)

읽기 쉽고, 좋고 깨끗한 :

identityMonad(value)
    .bind(k)
    .bind(j, j1, j2)
    .bind(i, i2)
    .bind(h, h1, h2)
    .bind(g, g1, g2)
    .bind(f, f1, f2);

function identityMonad(value) {
    var monad = Object.create(null);
    
    // func should return a monad
    monad.bind = function (func, ...args) {
        return func(value, ...args);
    };

    // whatever func does, we get our monad back
    monad.call = function (func, ...args) {
        func(value, ...args);

        return identityMonad(value);
    };
    
    // func doesn't have to know anything about monads
    monad.apply = function (func, ...args) {
        return identityMonad(func(value, ...args));
    };

    // Get the value wrapped in this monad
    monad.value = function () {
        return value;
    };
    
    return monad;
};

프리미티브 값과 함께 작동합니다.

var value = 'foo',
    f = x => x + ' changed',
    g = x => x + ' again';

identityMonad(value)
    .apply(f)
    .apply(g)
    .bind(alert); // Alerts 'foo changed again'

또한 사물들

var value = { foo: 'foo' },
    f = x => identityMonad(Object.assign(x, { foo: 'bar' })),
    g = x => Object.assign(x, { bar: 'foo' }),
    h = x => console.log('foo: ' + x.foo + ', bar: ' + x.bar);

identityMonad(value)
    .bind(f)
    .apply(g)
    .bind(h); // Logs 'foo: bar, bar: foo'

모든 것을 시도해 봅시다.

var add = (x, ...args) => x + args.reduce((r, n) => r + n, 0),
    multiply = (x, ...args) => x * args.reduce((r, n) => r * n, 1),
    divideMonad = (x, ...args) => identityMonad(x / multiply(...args)),
    log = x => console.log(x),
    substract = (x, ...args) => x - add(...args);

identityMonad(100)
    .apply(add, 10, 29, 13)
    .apply(multiply, 2)
    .bind(divideMonad, 2)
    .apply(substract, 67, 34)
    .apply(multiply, 1239)
    .bind(divideMonad, 20, 54, 2)
    .apply(Math.round)
    .call(log); // Logs 29

순수 함수

함수형 프로그래밍의 기본 원칙은 응용 프로그램 상태 (무국적)와 범위를 벗어나는 변수 ( 변경 불가능)를 변경하지 않는 것입니다.

순수 함수는 다음과 같은 기능을합니다.

• 주어진 입력으로 항상 동일한 출력을 반환합니다.
• 그들은 범위 밖의 변수에 의존하지 않습니다.
• 그들은 응용 프로그램의 상태를 수정하지 않습니다 ( 부작용 없음 ).

몇 가지 예를 살펴 보겠습니다.

순수 함수는 범위 밖의 변수를 변경해서는 안됩니다.

불순한 기능

let obj = { a: 0 }

const impure = (input) => {
  // Modifies input.a
  input.a = input.a + 1;
  return input.a;
}

let b = impure(obj)
console.log(obj) // Logs { "a": 1 }
console.log(b) // Logs 1

이 함수는 범위 밖에있는 obj.a 값을 변경했습니다.

순수한 기능

let obj = { a: 0 }

const pure = (input) => {
  // Does not modify obj
  let output = input.a + 1;
  return output;
}

let b = pure(obj)
console.log(obj) // Logs { "a": 0 }
console.log(b) // Logs 1

함수가 객체 obj 값을 변경하지 않았습니다.

순수 함수는 범위를 벗어나는 변수에 의존해서는 안됩니다.

불순한 기능

let a = 1;

let impure = (input) => {
  // Multiply with variable outside function scope
  let output = input * a;
  return output;
}

console.log(impure(2)) // Logs 2
a++; // a becomes equal to 2
console.log(impure(2)) // Logs 4

이 불순한 기능은 범위 밖에 정의 된 변수 a 에 의존합니다. 따라서 a가 수정되면 impure 결과가 달라집니다.

순수한 기능

let pure = (input) => {
  let a = 1;
  // Multiply with variable inside function scope
  let output = input * a;
  return output;
}

console.log(pure(2)) // Logs 2

pure 함수 결과 는 범위 밖의 변수에 의존하지 않습니다 .