// 함수를 인수로 받는 함수
function moong1(moong2) {
  moong2();
}

// 함수를 변환하는 함수
function moong1() {
  return moong2() {};
}

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

cosnt 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: "moong2", age: 29 }, { name: "min_zzz", age: 24 }];

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

whoIsOlder(people, people[1].age);

// 특정한 방식으로 동작하는 함수를 만들어내는 고차 함수를 작성할 수 있습니다.
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 gettingOlder(yourage) {
  let age = yourage;

  return {
    getOlder() {
      age++;
    },
    getAge() {
      return age;
    }
  };
}
// 'age'를 직접 변경할 수 있는 방법이 없습니다.

const me = gettingOlder(29);
me.getOlder(); // 29++
me.getAge(); // 30...ㅠㅠ

// const makeAdder = x => (y => x + y);
// 화살표함수가 여러개가 나온다면 맨 우측에 있는 식부터 계산후 반환이라고 생각하면 됩니다!
const makeAdder = x => y => x + y;

// 밑의 코드와 위의 한줄과 같습니다.
// function makeAdder (x) {
//   return function (y) {
//     return x + y;
//   }
// }

const add2 = makeAdder(2);
add2(3); //  5
// makeAdder(2)(3)과 같습니다.

// 번외
const makeAdder = x => y => z => x + y + z;
makeAdder(2)(3)(4);
// 길게 길게 쓸수도 있습니다.

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

// 밑의 코드와 위의 한줄과 같습니다.
// function makeCounter(x = 1) {
//   return function() {
//     return x++;
//   };
// }

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

function func() {
  func();
}

// 무한 루프로 빠져든다아..

// 루프로 구현된 팩토리얼
function factorial(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;
}

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

function fiboRec(n) {
  return n < 1 ? 0 : n === 1 ? 1 : fiboRec(n - 1) + fiboRec(n - 2);
}

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

console.time("fiboRec");
fiboRec(40); //  1417ms
console.timeEnd("fiboRec");

console.time("fiboRecMemoized");
fiboRecMemoized(40); //  0ms
console.timeEnd("fiboRecMemoized");