함수형 프로그래밍

// 함수를 인수로 받는 함수
function func2(f) {
  f();
}

// 함수를 반환하는 함수
function func1() {
  return function() {};
}

function func1(x) {
  return x;
}

func1(1);
// 더 이상 변수 `x`에 접근할 수 있는 방법이 없습니다.

for (let i = 0; i < 10; i++) {
  console.log(i);
}
// 더 이상 변수 `i`에 접근할 수 있는 방법이 없습니다.

function func1(x) {
  // 여기서 반환되는 함수는 바깥 스코프에 있는 변수 `x`를 사용하고 있습니다.
  return function () {
    return x;
  }
}

const func2 = func1(1);

// `func1`의 실행은 끝났지만, `func2`를 통해서 변수 `x`를 사용할 수 있습니다.
console.log(func2()); // 1

const arr = [];

for (let i = 0; i < 10; i++) {
  // 여기서 만들어진 함수는 바깥 스코프에 있는 변수 `i`를 사용하고 있습니다.
  arr.push(function() {
    return i;
  });
}

// for 루프의 실행은 끝났지만, 루프 안에서 만들어진 함수가 배열에 저장되어 있습니다.
// 배열 안에 들어있는 함수를 통해, 해당 함수가 만들어진 시점의 변수 `i`를 사용할 수 있습니다.
console.log(arr[2]()); // 2
console.log(arr[5]()); // 5

// 고차 함수의 인수로 함수를 넘길 때, 해당 함수에서 바깥 스코프에 있는 변수를 사용할 수 있습니다.
const people = [
  {name: '윤아준', age: 19},
  {name: '신하경', age: 20}
]

function peopleOlderThan(people, threshold) {
  return people.filter(person => person.age > threshold);
}

peopleOlderThan(people, 19); // [ { name: '신하경', age: 20 } ]

// 특정한 방식으로 동작하는 함수를 만들어내는 고차 함수를 작성할 수 있습니다.
function makeAdder(x) {
  return function (y) {
    return x + y;
  }
}

[1, 2, 3].map(makeAdder(2)); // [3, 4, 5]

function makeCounter(x = 1) {
  return function() {
    return x++;
  }
}
// `x`를 직접 변경할 수 있는 방법이 없습니다!

const counter = makeCounter();
console.log(counter()); // 1
console.log(counter()); // 2

function personFactory(initialAge) {
  let age = initialAge;
  return {
    getOlder() {
      age++;
    },
    getAge() {
      return age;
    }
  };
}
// `age`를 직접 변경할 수 있는 방법이 없습니다!

const makeAdder = x => y => x + y;

const add2 = makeAdder(2);
add2(3); // 5

const makeCounter = (x = 1) => () => x++;

const counter = makeCounter();
console.log(counter()); // 1
console.log(counter()); // 2

function func() {
  func();
}

// 루프로 구현된 팩토리얼
function factorialLoop(n) {
  let result = 1;
  for (let i = 2; i <= n; i++) {
    result *= i;
  }
  return result;
}

// 재귀 함수로 구현된 팩토리얼
function factorialRec(n) {
  return n <= 1 ? 1 : n * factorialRec(n - 1);
}

// 루프로 구현된 피보나치 수
function fiboLoop(n) {
  let x = 0;
  let y = 1;
  for (let i = 0; i < n; i++) {
    [x, y] = [y, x + y];
  }
  return x;
}

// 재귀 함수로 구현된 피보나치 수
function fiboRec(n) {
  return (
    n < 1 ? 0 :
    n === 1 ? 1 :
    fiboRec(n - 1) + fiboRec(n - 2)
  );
}

function mergeSort(arr) {
  // 입력된 배열의 길이가 1 이하이면 더 이상 재귀 호출을 하지 않습니다.
  if (arr.length <= 1) return arr;

  // 배열을 절반으로 잘라 두 개의 작은 배열로 분할하고,
  // 두 작은 배열에 대해 재귀 호출을 수행합니다.
  const slicer = Math.floor(arr.length / 2);
  const arr1 = mergeSort(arr.slice(0, slicer));
  const arr2 = mergeSort(arr.slice(slicer));

  // `arr1`, `arr2`는 **이미 정렬되어있는 상태**이므로,
  // 이 성질을 이용해 두 배열을 **정렬되어있는 큰 배열**로 합칠 수 있습니다.
  const newArr = [];
  for (let i = 0, j = 0; i < arr1.length || j < arr2.length; ) {
    if (arr1[i] == undefined || arr1[i] > arr2[j]) {
      newArr.push(arr2[j]);
      j++;
    } else {
      newArr.push(arr1[i]);
      i++;
    }
  }

  // 큰 배열을 반환합니다.
  return newArr;
}

factorialRec(20000); // RangeError: Maximum call stack size exceeded

const fiboRecMemoized = (() => {
  // 계산 결과를 저장하는 저장소를 만듭니다.
  const memo = new Map();

  const fiboRec = n => {
    // 만약에 이전에 같은 인수로 계산한 적이 있다면
    // 해당 결과를 바로 반환합니다.
    let result = memo.get(n);
    if (result != undefined) return result;

    result = (
      n < 1 ? 0 :
      n === 1 ? 1 :
      fiboRec(n - 1) + fiboRec(n - 2)
    );

    // 계산 결과를 저장소에 저장한 후 반환합니다.
    memo.set(n, result);
    return result;
  }

  return fiboRec;
})();