πŸ“œ λͺ©μ°¨

μ•Œκ³ λ¦¬μ¦˜

ν–‰λ ¬μ˜ λ§μ…ˆ

내적

NestJS

μ •κ·œν™”(Normalization)

ERD(Entity-Relation-Diagram)

μ•Œκ³ λ¦¬μ¦˜

ν‰μ†Œμ—λŠ” forλ₯Ό μ΄μš©ν•œ λ°˜λ³΅λ¬Έμ„ μœ„μ£Όλ‘œ μ‚¬μš©ν•˜λŠ”λ° μ΅œκ·Όμ— **reduce()**와 **map()**을 μ΄μš©ν•œ μ•Œκ³ λ¦¬μ¦˜ 풀이가 λ¦¬νŒ©ν† λ§μ— 효과적인 것 κ°™κ³  μ΄ν•΄λŠ” λ”°λ‘œ μ•ˆλ˜μ–΄μ„œ μ •λ¦¬ν–ˆλ‹€!

πŸ’‘ 이 λ©”μ†Œλ“œλ“€μ„ μ“°λŠ”λ° κ°€μž₯ μ€‘μš”ν•œ 점은 λ°°μ—΄μ—μ„œλ§Œ μ‚¬μš©ν•  수 μžˆλŠ” λ©”μ†Œλ“œλΌλŠ” 점! κ·Έλ ‡κΈ° λ•Œλ¬Έμ— 배열이 μ•„λ‹Œ 곳에 μ‚¬μš©ν•˜κΈ° μœ„ν•΄μ„œλŠ” μ›λž˜μ˜ 값을 λ°°μ—΄λ‘œ λ³€ν™˜ν•˜λŠ” 과정이 κΌ­ ν•„μš”ν•˜λ‹€! ( split() 을 이용)

πŸ“Œ reduce( )

// λ°°μ—΄μ˜ 각 μš”μ†Œλ₯Ό μˆœνšŒν•œ μ‹€ν–‰ 값을 λˆ„μ ν•΄μ„œ ν•˜λ‚˜μ˜ κ²°κ³Ό 값을 λ°˜ν™˜ν•˜λŠ” λ©”μ†Œλ“œ
// arr.reduce(callbackFx, μ΄ˆκΈ°κ°’)
// μ΄ˆκΈ°κ°’μ„ μ„€μ •ν•˜μ§€ μ•ŠμœΌλ©΄ λ°°μ—΄μ˜ 첫 번째 μΈλ±μŠ€κ°€ μ΄ˆκΈ°κ°’μ΄ λœλ‹€.

// 예제 1 :: λ°°μ—΄μ˜ λͺ¨λ“  κ°’ λ”ν•˜κΈ°

const numbers = [1,2,3,4,5,6,7,8,9,10]

const sum = numbers.reduce((acc, cur) => acc+ cur)
console.log(sum) // 55

Array.prototype.reduce() - JavaScript | MDN

πŸ“Œ map( )

// λ°°μ—΄μ˜ λ°°μ—΄ λ‚΄μ˜ λͺ¨λ“  μš”μ†Œμ— 주어진 ν•¨μˆ˜λ₯Ό ν˜ΈμΆœν•œ κ²°κ³Όλ₯Ό λͺ¨μ•„ μƒˆλ‘œμš΄ λ°°μ—΄λ‘œ λ°˜ν•˜λŠ” λ©”μ†Œλ“œ
// arr.map((μš”μ†Œ, 인덱슀, λ°°μ—΄) => {return μš”μ†Œ})

const numbers = [1, 2, 3, 4, 5]
const result = numbers.map( num => num * num ) 

console.log(result) //[ 1, 4, 9, 16, 25 ]

Array.prototype.map() - JavaScript | MDN


πŸ’­ ν–‰λ ¬μ˜ λ§μ…ˆ

// ν–‰λ ¬μ˜ λ§μ…ˆμ€ ν–‰κ³Ό μ—΄μ˜ 크기가 같은 두 ν–‰λ ¬μ˜ 같은 ν–‰, 같은 μ—΄μ˜ 값을 μ„œλ‘œ λ”ν•œ κ²°κ³Όκ°€ λ©λ‹ˆλ‹€.
// 2개의 ν–‰λ ¬ arr1κ³Ό arr2λ₯Ό μž…λ ₯λ°›μ•„, ν–‰λ ¬ λ§μ…ˆμ˜ κ²°κ³Όλ₯Ό λ°˜ν™˜ν•˜λŠ” ν•¨μˆ˜, solution을 μ™„μ„±ν•΄μ£Όμ„Έμš”.

// ν–‰λ ¬ arr1, arr2의 ν–‰κ³Ό μ—΄μ˜ κΈΈμ΄λŠ” 500을 λ„˜μ§€ μ•ŠμŠ΅λ‹ˆλ‹€

arr1 = [[1, 2], [2, 3],];
arr2 = [[3, 4], [5, 6],];

function solution(arr1, arr2) {
  const answer = [[]];

  for (let i = 0; i < arr1.length; i++) {
    for (let j = 0; j < arr1[i].length; j++) {
      const sum = arr1[i][j] + arr2[i][j];

      // 0번째 λ°°μ—΄ μ΄ν›„μ˜ 인덱슀둜 μ ‘κ·Όν•˜λ €κ³  ν•˜λŠ”λ° κ·Έ 배열이 μ—†λ‹€λ©΄ (undefined)
      // κ·Έ μΈλ±μŠ€μ— 빈 배열을 λ§Œλ“€μ–΄μ€€λ‹€
      if (answer[i] === undefined) {
        answer[i] = [];
      }

      answer[i][j] = sum;
    }
  }
  return answer;
}

// map() μ‚¬μš©
function solution(arr1, arr2) {
  const answer = arr1.map((num1, i) => {
    return num1.map((num2, j) => {
      return num2 + arr2[i][j];
    });
  });
  return answer;
}

πŸ’­ 내적

// 길이가 같은 두 1차원 μ •μˆ˜ λ°°μ—΄ a, bκ°€ λ§€κ°œλ³€μˆ˜λ‘œ μ£Όμ–΄μ§‘λ‹ˆλ‹€. 
// a와 b의 내적을 return ν•˜λ„λ‘ solution ν•¨μˆ˜λ₯Ό μ™„μ„±ν•΄μ£Όμ„Έμš”.
// μ΄λ•Œ, a와 b의 내적은 a[0]*b[0] + a[1]*b[1] + ... + a[n-1]*b[n-1] μž…λ‹ˆλ‹€. 
// (n은 a, b의 길이)

// a, b의 κΈΈμ΄λŠ” 1 이상 1,000 μ΄ν•˜μž…λ‹ˆλ‹€.
// a, b의 λͺ¨λ“  μˆ˜λŠ” -1,000 이상 1,000 μ΄ν•˜μž…λ‹ˆλ‹€.

a = [1, 2, 3, 4];
b = [-3, -1, 0, 2];

solution(a, b); // 3

function solution(a, b) {
  let answer = 0;
  // a λ˜λŠ” b의 각각의 μš”μ†Œ 데이터 κ°€μ Έμ˜€κΈ°
  // 길이가 κ°™μœΌλ―€λ‘œ ν•˜λ‚˜μ˜ forλ¬Έμ—μ„œ 같은 인덱슀 κ°’μœΌλ‘œ 접근이 κ°€λŠ₯
  for (let i = 0; i < a.length; i++) {
    const sum = a[i] * b[i];
    answer += sum;
  }
  return answer;
}

// reduce() μ‚¬μš©
function solution(a, b) {
  const answer = a.reduce((acc, cur, i) => {
    return acc + cur * b[i];
  }, 0);
  return answer;
}


NestJS

πŸ’¬ λ°μ΄ν„°λ² μ΄μŠ€λ₯Ό μ–΄λ–»κ²Œ μ €μž₯ν•  것인지 μ–΄λ–»κ²Œ λ‚˜λˆŒ 것인지 감을 μž‘μ„ 수 μžˆμ„ κ±°μ•Ό!