1. 다형성

다형성 : 하나의 메소드나 클래스가 있을 때 이들이 다양한 방법으로 동작하는 것

메서드 : 객체지향 프로그래밍 / 해당하는 클래스에 준비되어 있지 않은 메서드는 사용불가! -> 다형성을 지원하기 어렵다.

• 다형성 선언부분 : 인터페이스(Interface)와 추상클래스(abstract class)
• 다형성 구현부분 : 클래스(class)

2. Curry

함수에 인자를 하나씩 적용해나가다가 필요한 인자가 모두 채워지면 함수본체를 실행하는 기법

자바스크립트에서 커링이 지원되지 않지만 일급함수가 지원되고 평가시점을 마음대로 다룰 수 있기 때문에 커링과 같은 기법을 구현할 수 있다.

2) _curry

/* curry */
function _curry(fn) {
    return function (a) {
        return function (b) {
            return fn(a, b);
        }
    }
}
/* 커리를 사용하면 일반적으로 함수를 정의하지만 커링이 되도록 만들어줌 */
var add = _curry(function(a, b) {
    return a + b ;
});

var add10 = add(10);
console.log( add10(5) );
console.log( add(5)(3) );

2) _curryr

var sub = _curryr(function(a, b) {
    return a - b;
});

/* 오른쪽(right)에서 부터 인자를 정하는 _curryr */
function _curryr() {
    return function (a, b) {
        return arguments.length == 2 ? fn(a, b) : function (b) { return fn(b, a); };
    }
}
var sub10 = sub(10);
console.log( sub10(5) );

3.reduce

reduce() 메서드는 배열의 각 요소에 대해 주어진 리듀서(reducer) 함수를 실행하고, 하나의 결과값을 반환한다.

/* _reduce 만들기*/
    function _reduce(list, iter, memo) {
        _each(list, function (val) {
            memo = iter(memo, val)
        })
        return memo;
    }

    console.log(
        _reduce([1, 2, 3], function (a, b) {
            return a + b; //재귀적 호출
        }, 0)); //6

4. pipe

함수를 리턴하는 함수

/* 파이프라인 */
    // 함수들을 인자로 받아서 이 함수를 연속적으로 실행함
    function _pipe() {
        var fns = arguments;
        return function (arg) {
            return _reduce(fns, function (arg, fn){
                return fn(arg);
            }, arg);
        }
    }

    var f1 = _pipe(
        function (a) { return a + 1; },  // 1 + 1
        function (a) { return a * 2; });  // 2 * 2;

    console.log( f1(1) );

5. go

var slice = Array.prototype.slice;
function _rest(list, num) {
    return slice.call(list, num || 1);
}

function _go(arg) {
    var fns = _rest(arguments);
    _pipe.apply(null, fns)(arg);
}

_go(1,
    function (a) { return a + 1; },
    function (a) { return a * 2; },
    function (a) { return a * a; },
    console.log);

※ go를 사용해서 코드를 더 간결하게 만들기

console.log(
  _map(
    _filter(users, function(user) { return user.age >= 30; }),
    _get('name')));

console.log(
  _map(
    _filter(users, function(user) { return user.age < 30; }),
    _get('age')));

/* 위의 코드와 동일하지만 더 간단하다 */
_go(users,
  _filter(function(user) { return user.age >= 30; }),
  _map(_get('name')),
  console.log);

_go(users,
  _filter(user => user.age < 30),
  _map(_get('age')),
  console.log);

이렇게 함수가 함수를 실행하고, 함수가 함수를 리턴하는 것이 함수형 프로그래밍

6. 화살표함수 쓰는 법

var a = function(user) { return user.age >= 30; };
var a = user => user.age >= 30;


var add = (a, b) => {
     //
     return a + b;
    };
    var add = (a, b) => ({ val: a + b });

8. 다형성 높이기 , _keys

/* _each의 외부 다형성 높이기 */

// 1. _each에 null 넣어도 에러 안나게
    // _each(null, console.log); -> 에러 발생
    console.log( _filter(null, function(v) { return v; }) ); //map도 가능


// 2. _keys 만들기
    function _is_object(obj) {
      return typeof obj == 'object' && !!obj;
    }

    function _keys(obj) {
  return _is_object(obj) ? Object.keys(obj) : [];
    }

// 3. _keys에서도 _is_object인지 검사하여 null 에러 안나게
    console.log( _keys({ name: 'ID', age: 33 }) );
    console.log( _keys([1, 2, 3, 4]) );
    console.log( _keys(10) );
    console.log( _keys(null) );


// 4. _each 외부 다형성 높이기
    _each({
        13: 'ID',
        19: 'HD',
        29: 'YD'
    }, function(name) {
        console.log(name);
    });

    console.log( _map({
        13: 'ID',
        19: 'HD',
        29: 'YD'
    }, function(name) {
        return name.toLowerCase();
    }) );

    _go({
            1: users[0],
            3: users[2],
            5: users[4]
        },
        _map(function(user) {
            return user.name.toLowerCase();
        }),
        console.log);