함수형 코드 만들기, 별 그리기 & 구구단

이번에는 별 그리기, 구구단 코드를 함수형 코드로 변경하고자 한다.
시작하기에 앞서 while문은 함수형으로 어떻게 변경할 수 있는지 알아보자!

1. while문은 range로 변경할 수 있다.

1) 변경 전

• while문은 조건이 참이면 계속 실행되는 반복문이다.
• 아래 코드는 while문을 사용해, 0 ~ 9를 출력하는 코드이다.

  function f10(end) {
  let i = 0;
  while(i < end) {
    ++i;
    console.log(i)
  }
  }
  f10(10);

2) while => range로 변경하자

• while은 함수형에서 .range로 변경할 수 있다.
• L.range(start, end, interval)는 start ~ end 범위에 해당하는 이터러블이다.
• _.each(발생시킬 코드, 이터러블)는 이러터블을 반복할 때, 발생시킨 코드를 실행시킬 수 있다.
• .range, .each를 사용하면 아래와 같은 반복문을 만들어 사용할 수 있다.

  function f13(end) {
  _.each(console.log, L.range(1, end, 2));
  }
  f13(10);

이제 본격적으로 함수형 코드로 변경하는 과정을 진행해보자! 별 그리기와 구구단 코드를 사용해보자

2. 함수형 코드로 변경하기

1) 별 그리기

(1) 방법1, 한 개의 go()만 사용

• 첫 번째 방법은 한 개의 go()를 사용하는 방법이다.
• L.func를 하면 결과값을 산출하지 않아 더 효율적이다.
• 단지 이터러블(반복가능)이 될 뿐이다.

  _.go(
  L.range(1, 6),           //while
  L.map(L.range),          //원소값 변형 + while
  L.map(L.map(_ => '*')),  // 원소값 변형 + 원소값 변형
  L.map(_.reduce((a, b)=> `${a}${b}`)), //원소값 변형 + 합치기
  _.reduce((a,b) => `${a}\n${b}`),      //합치기
  console.log
  )

(2) 방법2, 두 개의 go()만 사용

• 두 번째 방법은 2개의 go()를 사용하는 방법이다.

  _.go(
  L.range(1, 6),       // 1~6 범위
  L.map(s => _.go(     //   인자 1  
    L.range(s),        //   범위 ~1
    L.map(_ => '*'),   //   원소를 *로 변형
    _.reduce((a, b)=> `${a}${b}`)   //(acculate, 인자)
  )),
  _.reduce((a,b) => `${a}\n${b}`),
  console.log
  )

(3) 방법3, reduce() 변형

• 세 번째 방법은 reduce()를 사용하는 방법이다.

  const join = sep =>  _.reduce((a,b) => `${a}${sep}${b}`);
  _.go(
  L.range(1, 6), 
  L.map(L.range),
  L.map(L.map(_ => '*')),
  L.map(join('')),
  join('\n'),
  console.log
  )

3) 구구단

• 구구단의 경우 2개의 go()를 사용하는 방법으로 변경해보았다.
  

  

  _.go(
  L.range(2, 10),                    //while
  L.map(a => _.go (                    //원소변형
    L.range(1, 10),                    //while
    L.map(b => `${a}x${b}=${a*b}`),      //원소변형
    join('\n')
  )),
  join('\n\n'),
  console.log
  )