์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ, class๋ฅผ ๋ฌธ๋ฒ•์  ์„คํƒ•(syntactic sugar)์ด๋ผ ๋ถ€๋ฅด๋Š” ์ด์œ 

function์œผ๋กœ ๊ตฌํ˜„ํ•˜๋Š” class์˜ ๋™์ž‘ ๋ฐฉ์‹

‘๋ฌธ๋ฒ•์  ์„คํƒ•’์€ ํ†ต์šฉ๋˜๋Š” ๋‹จ์–ด์ด์ง€๋งŒ ์–ด๊ฐ์ด ์ด์ƒํ•œ ๊ฑด ์–ด์ฉ” ์ˆ˜ ์—†๋‹ค. ์˜์—ญํ•˜์—ฌ ‘ํŽธ๋ฆฌํ•œ ๊ตฌ๋ฌธ ์šฉ๋ฒ•’ ์ •๋„๊ฐ€ ๋” ์ดํ•ดํ•˜๊ธฐ ์‰ฌ์šธ ๊ฒƒ ๊ฐ™๋‹ค.

์œ„ํ‚ค์—์„œ syntactic sugar์˜ ์ •์˜๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

In computer science, syntactic sugar is syntax within a programming language that is designed to make things easier to read or to express.
์ปดํ“จํ„ฐ ๊ณผํ•™ ๋ถ„์•ผ์—์„œ ‘ํŽธ๋ฆฌํ•œ ๊ตฌ๋ฌธ ์šฉ๋ฒ•’์ด๋ž€ ์ฝ๊ธฐ ์‰ฝ๊ณ  ํ‘œํ˜„ํ•˜๊ธฐ ์‰ฝ๋„๋ก ๊ตฌ์„ฑ๋œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด ๋‚ด์˜ ๊ตฌ๋ฌธ์ด๋‹ค.

์ฆ‰, ๋‹ฌ์ฝคํ•œ ์ดˆ์ฝœ๋ฆฟ์ฒ˜๋Ÿผ ์†์ด ์ž์ฃผ ๊ฐ€๋Š” ๊ตฌ๋ฌธ์ด๋ผ๊ณ  ๋ณผ ์ˆ˜ ์žˆ์„ ๊ฒƒ ๊ฐ™๋‹ค.

์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ๋Š” ์ฒ˜์Œ๋ถ€ํ„ฐ ๋ชจ๋“  ๊ธฐ๋Šฅ์„ ๊ฐ–๊ณ  ํƒœ์–ด๋‚˜์ง€ ์•Š์•˜์œผ๋ฏ€๋กœ ES ๋ฒ„์ „์œผ๋กœ ๋Œ€ํ‘œ๋˜๋Š” ์ถ”๊ฐ€ ๊ธฐ๋Šฅ์€ ๊ธฐ์กด์˜ ๋ฌธ๋ฒ•์œผ๋กœ ๊ตฌํ˜„๋œ ๊ฒƒ์ด ๋งŽ๋‹ค.

class ๋˜ํ•œ ๊ธฐ์กด์˜ OOP์—์„œ ์ฐจ์šฉํ•œ ๊ฐœ๋…์„ ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ์—์„œ ๊ตฌํ˜„ํ•œ ๊ฒƒ์œผ๋กœ ๊ตฌํ˜„ ๋ฐฉ์‹์€ ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ์˜ ๋ฌธ๋ฒ•์„ ๋ฒ—์–ด๋‚˜์ง€ ์•Š๋Š”๋‹ค.

๋”ฐ๋ผ์„œ ์‚ฌ์šฉ์ž๊ฐ€ ์„ ์–ธํ•˜๊ณ  ์‚ฌ์šฉํ•˜๋Š” ๋ฐฉ์‹์€ ๋‹ค๋ฅด์ง€๋งŒ ๋‹ค์Œ์—์„œ ํ™•์ธํ•  ๋‘ ์ฝ”๋“œ์˜ ์ž‘๋™ ๋ฐฉ์‹์€ ๋™์ผํ•˜๋‹ค.

function์œผ๋กœ ์„ ์–ธ๋œ ๋ถ€๋ถ„์ด ๊ธฐ๋ณธ ๋™์ž‘ ๋ฐฉ์‹์ด๋ฉฐ class๊ฐ€ ์„ ์–ธ๋˜๋ฉด ์ด function๊ณผ ์™„์ „ํžˆ ๋™์ผํ•œ ๋ฐฉ์‹์œผ๋กœ ๊ตฌํ˜„๋œ๋‹ค.

๊ฐ™์€ ๊ธฐ๋Šฅ์„ ๊ตฌํ˜„ํ•  ๋•Œ function๊ณผ class ์ค‘ ์–ด๋–ค ๊ฒƒ์— ๋” ์„ ๋œป ์†์ด ๊ฐ€๋Š”์ง€๋ฅผ ๋ฌป๋Š”๋‹ค๋ฉด ์„คํƒ•์˜ ์˜๋ฏธ๋ฅผ ์ƒ๊ฐํ•ด๋ณผ ์ˆ˜ ์žˆ๋‹ค.

function ์‚ฌ์šฉ

function createGame( user, point ) {
  this.user = user;
  this.point = point;
}

createGame.prototype.addPoint = function() { this.point++; };

const myGame = new createGame("Yoon", 0);

myGame.addPoint();

class ์‚ฌ์šฉ

class CreateGame {
  constructor (user, point) {
    this.user = user;
    this.point = point;
  }
  addPoint() { this.point++; }
}

const myGame = new CreateGame("Yoon", 0);
myGame.addPoint();

์‚ฝ์ž… ์ •๋ ฌ(insertion sort), ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ๋กœ ์ž‘์„ฑํ•˜๊ธฐ

์•ž์—์„œ๋ถ€ํ„ฐ ์ˆœ์„œ๋Œ€๋กœ ์ •๋ ฌํ•˜์—ฌ ์ž์‹ ์˜ ์œ„์น˜์— ์‚ฝ์ž…ํ•˜๋Š” ๋ฐฉ๋ฒ•

์‚ฝ์ž… ์ •๋ ฌ์€ ๋ฐฐ์—ด์˜ ์•ž์—์„œ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•˜์—ฌ ์ž์‹ ์˜ ์•ž์— ์žˆ๋Š” ๋ชจ๋“  ์š”์†Œ์™€ ํฌ๊ธฐ ๋น„๊ต๋ฅผ ํ†ตํ•ด ์ž์‹ ์—๊ฒŒ ๋งž๋Š” ์œ„์น˜์— ์š”์†Œ๋ฅผ ์‚ฝ์ž…ํ•œ๋‹ค.

๋‹ค์Œ ๊ทธ๋ฆผ๊ณผ ๊ฐ™์€ ๋ฐฉ์‹์ด๋‹ค.

3์„ [6]์˜ ์ ์ ˆํ•œ ์œ„์น˜์— ์‚ฝ์ž…ํ•˜๊ณ  ๋‹ค์Œ์œผ๋กœ๋Š” 5๋ฅผ [3, 6]์˜ ์ ์ ˆํ•œ ์œ„์น˜์— ์‚ฝ์ž…ํ•œ๋‹ค. ๋‹ค์Œ์œผ๋กœ๋Š” 1์„ [3, 5, 6]์˜ ์ ์ ˆํ•œ ์œ„์น˜์— ์‚ฝ์ž…ํ•˜๊ณ  ์ด ๋ฐฉ์‹์œผ๋กœ ์‚ฝ์ž… ์ž‘์—…์ด ๋ฐ˜๋ณต๋œ๋‹ค.

์ฝ”๋“œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

const insertionSort = (arr) => {

  for(let i=1;i<arr.length;i++){
    const checkValue = arr[i];
    let left = i-1;

    while(left>=0&&arr[left]>checkValue){
      arr[left+1] = arr[left];
      left--;
    }
    arr[left+1] = checkValue;
  }
  return arr;
}

console.log(insertionSort([6,3,5,1,9,4,8,2,7]));

๋‹ค๋ฅธ ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์ด ํ•„์š”ํ•˜์ง€ ์•Š๊ณ  ์•ˆ์ • ์ •๋ ฌ(stable sort)์ด๋ฉฐ ์‹œ๊ฐ„ ๋ณต์žก๋„๋Š” O(N)์ด๋‹ค. ๋‹จ์ ์œผ๋กœ ์ตœ์•…์˜ ์‹œ๊ฐ„ ๋ณต์žก๋„๋Š” O(N^2)๊ฐ€ ๋  ์ˆ˜ ์žˆ์œผ๋ฉฐ ๋ฐฐ์—ด์ด ์ปค์งˆ์ˆ˜๋ก ๋น„ํšจ์œจ์ ์ด๋‹ค.

ํ€ต ์ •๋ ฌ(quick sort), ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ๋กœ ๊ตฌํ˜„ํ•˜๊ธฐ

๋ฌธ์ œ๋ฅผ ์„ธ๋ถ„ํ™”ํ•˜๋Š” ๋ถ„ํ•  ์ •๋ณต(divide and conquer)๊ณผ ํ€ต ์ •๋ ฌ

ํ€ต ์ •๋ ฌ์€ ํ•˜๋‚˜์˜ ์ค‘์‹ฌ(pivot) ๊ฐ’์„ ๊ธฐ์ค€์œผ๋กœ ํฐ ๊ฐ’๊ณผ ์ž‘์€ ๊ฐ’์„ ๋ถ„๋ฅ˜ํ•˜๊ณ  ์ด ์ž‘์—…์„ ๋ฐ˜๋ณตํ•˜์—ฌ ์ •๋ ฌํ•˜๋Š” ๋ฐฉ๋ฒ•์ด๋‹ค.

๊ทธ๋ฆผ์œผ๋กœ ๋ณด๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

์ฒซ ์š”์†Œ์ธ 6์„ ๊ธฐ์ค€์œผ๋กœ ์žก์•„์„œ ์ด๋ณด๋‹ค ์ž‘์€ ์ˆ˜๋ฅผ left, ํฐ ์ˆ˜๋ฅผ right๋กœ ๋ถ„๋ฅ˜ํ•˜๊ณ  ์ด ์ž‘์—…์„ ์„ธ๋ถ„ํ™”ํ•ด์„œ ๋ฐ˜๋ณต ์ง„ํ–‰ํ•˜๋ฉด ์ตœ์ข…์ ์œผ๋กœ ์ •๋ ฌ๋œ ๋ฐฐ์—ด์„ ๋ฐ˜ํ™˜ํ•  ์ˆ˜ ์žˆ๋‹ค.

const quickSort = (arr) => {
  if(arr.length<=1){
    return arr;
  }

  const pivot = arr[0];
  const left = [];
  const right = [];

  for(let i=1; i<arr.length; i++){
    if(arr[i]<pivot){
      left.push(arr[i]);
    }else{
      right.push(arr[i]);
    }
  }
  return [...quick(left), pivot, ...quick(right)]
}

console.log(quickSort([6,3,5,1,9,4,8,2,7]));

ํ€ต ์ •๋ ฌ์€ ์ตœ์•…์˜ ๊ฒฝ์šฐ๋ฅผ ์ œ์™ธํ•˜๋ฉด O(NlogN)์˜ ์‹œ๊ฐ„ ๋ณต์žก๋„๋ฅผ ๊ฐ–๋Š” ์†๋„๊ฐ€ ์žฅ์ ์ด์ง€๋งŒ ๋‹จ์ ์€ ์ตœ์•…์˜ ๊ฒฝ์šฐ(์ด๋ฏธ ์ •๋ ฌ๋œ ๋ฐฐ์—ด) ์‹œ๊ฐ„ ๋ณต์žก๋„๊ฐ€ O(N^2)๋กœ ๋Œ€ํญ ์ฆ๊ฐ€ํ•˜๊ณ  ๋ถˆ์•ˆ์ • ์ •๋ ฌ(unstable sort, ๋™์ผํ•œ ๊ฐ’์— ๋Œ€ํ•ด์„œ๋Š” ์ˆœ์„œ๊ฐ€ ๋ฐ”๋€” ์ˆ˜ ์žˆ์Œ)์ด๋ผ๋Š” ์ ์ด๋‹ค.

์˜ต์…”๋„ ์ฒด์ด๋‹(optional chaining)์˜ ์œ ์šฉํ•จ(javascript)

ES2020, typescript3.7, Babel 7.8.0, CRA 3.3.0 Node.js 14 ์ง€์›

์˜ต์…”๋„ ์ฒด์ด๋‹์˜ ์—ฐ์‚ฐ์ž๋Š” ?. ์ž…๋‹ˆ๋‹ค.

์ตœ์‹  ๋ฒ„์ „(ES2020)์—์„œ ์‚ฌ์šฉ ๊ฐ€๋Šฅํ•œ ๊ธฐ๋Šฅ์œผ๋กœ ๊ฐ์ฒด ์ฒด์ธ ์†์„ฑ์˜ ์กด์žฌ ์—ฌ๋ถ€๋ฅผ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.

์• ํ”Œ์›Œ์น˜ ๊ตฌ๋งค๋ฅผ ๊ณ ๋ฏผํ•˜๋Š” ์นœ๊ตฌ์—๊ฒŒ ํ•˜๋˜ ๋ง์ฒ˜๋Ÿผ ‘์žˆ์œผ๋ฉด ๋ชจ๋ฅด๊ฒ ์ง€๋งŒ ์—†์œผ๋ฉด ๋„ˆ๋ฌด ๋ถˆํŽธํ•œ’ (๊ฒฐ๋ก ์€ ์ต์ˆ™ํ•ด์ง€๋ฉด ์•„์ฃผ ์œ ์šฉํ•œ) ๊ธฐ๋Šฅ์˜ ์—ฐ์‚ฐ์ž์ž…๋‹ˆ๋‹ค.

์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ๋กœ ๊ฐ์ฒด ๋‚ด๋ถ€์˜ ์†์„ฑ์— ์ ‘๊ทผํ•  ๋•Œ, ์กด์žฌํ•˜์ง€ ์•Š๋Š” ๊ฐ์ฒด(undefined)์˜ ๋‚ด๋ถ€ ์†์„ฑ์— ์ ‘๊ทผํ•˜๋ฉด ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

const myObject = {
   myOne:{
      name:'one'
   }
}

console.log(myObject.myTwo); // undefined
console.log(myObject.myTwo.name); // error

์œ„์™€ ๊ฐ™์ด ์กด์žฌํ•˜๋Š” ๊ฐ์ฒด์˜ ํ•˜๋ถ€ ์†์„ฑ์ด ์กด์žฌํ•˜์ง€ ์•Š์œผ๋ฉด undefined๋ฅผ ๋ฐ˜ํ™˜ํ•˜์ง€๋งŒ ์กด์žฌํ•˜์ง€ ์•Š๋Š” ๊ฐ์ฒด์˜ ํ•˜๋ถ€ ์†์„ฑ์— ์ ‘๊ทผํ•˜๋ฉด ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

๊ฐ์ฒด์™€ ์†์„ฑ์ด ์กด์žฌํ•˜์ง€ ์•Š๋Š” ์ƒํ™ฉ์„ ๊ฐ€์ •ํ•˜์—ฌ ์ฝ”๋“œ๋ฅผ ๋ณด์ˆ˜์ ์œผ๋กœ ์งœ๋Š” ๊ฒƒ์€ ์Šต๊ด€ํ™”๋˜์–ด ์žˆ์ง€ ์•Š์œผ๋ฉด ๋†“์น˜๊ธฐ ์‰ฝ์Šต๋‹ˆ๋‹ค.


1. ์˜ต์…”๋„ ์ฒด์ด๋‹ ์‚ฌ์šฉ

์•ž์˜ ์—๋Ÿฌ๋ฅผ ๋ฐฉ์ง€ํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๋จผ์ € ๊ฐ์ฒด์˜ ์กด์žฌ ์—ฌ๋ถ€๋ฅผ ํ™•์ธ ํ›„ ์กด์žฌํ•˜๋Š” ๊ฒฝ์šฐ์—๋งŒ ์†์„ฑ์— ์ ‘๊ทผํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์‚ฌ์šฉํ• ํ…๋ฐ์š”.

const myObject = {
   myOne:{
      name:'one'
   }
}

console.log(myObject.myTwo&&myObject.myTwo.name); // undefined

&&๋ฅผ ์‚ฌ์šฉํ•ด ์กด์žฌ ์—ฌ๋ถ€๋ฅผ ๋จผ์ € ์ฒดํฌํ•ฉ๋‹ˆ๋‹ค.

A && B๋ฅผ ์˜ˆ๋กœ ๋“ค์–ด,

A = true๋ฉด return B,
A = false๋ฉด return A

์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

false์˜ ์กฐ๊ฑด์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

  • undefined
  • null
  • NaN
  • 0
  • empty string
  • “”

์œ„ ์ฝ”๋“œ๋Š” ์กด์žฌ ์‹œ name ์†์„ฑ์„ ๋ฐ˜ํ™˜ํ•˜์ง€๋งŒ ์†์„ฑ์ด ์กด์žฌํ•˜์ง€ ์•Š๋”๋ผ๋„ undefined๊ฐ€ ๋ฐ˜ํ™˜๋˜๋ฏ€๋กœ ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

์ด ์ฒดํฌ ๋ถ€๋ถ„์˜ ์ฝ”๋“œ๋ฅผ ๊ฐ„๋žตํ•˜๊ฒŒ ๋งŒ๋“ค์–ด ์ฝ”๋“œ์˜ ๊ฐ€๋…์„ฑ์„ ๋†’์ผ ์ˆ˜ ์žˆ๋Š” ๊ฒƒ์ด ์˜ต์…”๋„ ์ฒด์ด๋‹์ž…๋‹ˆ๋‹ค.

const myObject = {
   myOne:{
      name:'one'
   }
}
console.log(myObject.myTwo?.name); // undefined

์•ž์˜ ์ฝ”๋“œ์™€ ์™„์ „ํžˆ ๋™์ผํ•œ ๊ฒฐ๊ณผ๊ฐ€ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

๊ต‰์žฅํžˆ ๋‹จ์ˆœํ•˜๊ณ  ์ง๊ด€์ ์ธ ๊ฒƒ์ด ๋งค๋ ฅ์ ์ž…๋‹ˆ๋‹ค.

๋ฌผ๋ก  ์†์„ฑ ์ด์™ธ์— ๋ฉ”์„œ๋“œ๋‚˜ ํ•จ์ˆ˜ ํ˜ธ์ถœ์—๋„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

const myObject = {
   show(){
     console.log('show');
   }
}
console.log(myObject.show?.()); // show

console.log(myObject.exist?.()); // undefined
console.log(myObject.exist()); // error

ํ˜ธ์ถœํ•œ ๋ฉ”์„œ๋“œ๊ฐ€ ์กด์žฌํ•˜์ง€ ์•Š์œผ๋ฉด ์˜ต์…”๋„ ์ฒด์ด๋‹์€ undefined๋ฅผ ๋ฐ˜ํ™˜ํ•˜์ง€๋งŒ ์‚ฌ์šฉํ•˜์ง€ ์•Š์œผ๋ฉด ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

์ด์™€ ๊ฐ™์ด ์˜ต์…”๋„ ์ฒด์ด๋‹์„ ์‚ฌ์šฉํ•˜๋ฉด null, undefined๋กœ ๋ฐœ์ƒํ•˜๋Š” ์—๋Ÿฌ๋ฅผ ๋งŽ์ด ๋•Œ๋ ค ์žก์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๊ทธ๋Ÿฌ๋‚˜ ๊ณผ์œ ๋ถˆ๊ธ‰์„ ์žŠ์ง€ ๋ง์•„์•ผ ํ•ฉ๋‹ˆ๋‹ค.

์—ฌ๊ธฐ ์ €๊ธฐ ๋‚จ๋ฐœํ•˜๋ฉด ์—๋Ÿฌ ๋ฐœ์ƒ์€ ํ˜„์ €ํ•˜๊ฒŒ ์ค„์–ด๋“ค๊ฒ ์ง€๋งŒ ์ •์ž‘ ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•ด์•ผ ํ•˜๋Š” ๋ถ€๋ถ„์—์„œ๋„ ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•˜์ง€ ์•Š์•„

๋””๋ฒ„๊น…์ด ์–ด๋ ค์›Œ์ง€๋Š” ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•˜๋ฏ€๋กœ ๊ผญ ํ•„์š”ํ•œ ๋ถ€๋ถ„์—๋งŒ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค.

map, reduce, filter ์„œ๋กœ ๋Œ€์ฒด๊ฐ€ ๊ฐ€๋Šฅํ• ๊นŒ (javascript)

์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ ๋ฐฐ์—ด์„ ์ฒ˜๋ฆฌํ•˜๋Š” ๋ฉ”์„œ๋“œ map, reduce, filter

์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ์—์„œ ๋ฐฐ์—ด์˜ ์š”์†Œ์— ์ ‘๊ทผํ•˜๋Š” ๋Œ€ํ‘œ ๋ฉ”์„œ๋“œ์ธ map, reduce, filter๋Š” ๊ฐœ๋ฐœ์ž๋ผ๋ฉด ํ•„์ˆ˜์ ์œผ๋กœ ๊ทธ๋ฆฌ๊ณ  ์ข€ ๋” ์ƒ์„ธํžˆ ์•Œ๊ณ  ๊ฐ€๋ฉด ์ข‹์„ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๊ฐ๊ฐ์˜ ํŠน์ง•์— ๋Œ€ํ•ด ์ด์•ผ๊ธฐํ•˜๋ฉด ๋Œ€๋ถ€๋ถ„์€ ์•„๋งˆ๋„

  • map -> ๋ชจ๋“  ์š”์†Œ์— ํ•œ ๋ฒˆ์”ฉ ์ ‘๊ทผํ•˜๊ธฐ
  • reduce -> ๋ชจ๋“  ์š”์†Œ๋ฅผ ํ•˜๋‚˜๋กœ ํ•ฉ์น˜๊ธฐ
  • filter -> ๋ชจ๋“  ์š”์†Œ์—์„œ ์›ํ•˜๋Š” ๊ฒƒ๋งŒ ๊ณจ๋ผ๋‚ด๊ธฐ

์ •๋„์˜ ๊ฐœ๋…์„ ๊ฐ–๊ณ  ์žˆ์„ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๊ตณ์ด ์œ„ ๋ฉ”์„œ๋“œ๊ฐ€ ์•„๋‹ˆ๋ผ forEach ๋ฌธ ๋“ฑ ๋‹ค๋ฅธ ๋ฐฉ์‹์„ ์‚ฌ์šฉํ•ด๋„ ๊ฐ™์€ ๋กœ์ง์˜ ๊ตฌํ˜„์ด ๊ฐ€๋Šฅํ•œ๋ฐ์š”.

๊ทธ๋ ‡๋‹ค๋ฉด ์œ„ ๋ฉ”์„œ๋“œ๋ผ๋ฆฌ๋„ ์„œ๋กœ ๋ณ€๊ฒฝํ•˜์—ฌ ๊ฐ™์€ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋„๋ก ์‚ฌ์šฉ์ด ๊ฐ€๋Šฅํ• ๊นŒ์š”?

๊ฐ ๋ฉ”์„œ๋“œ์˜ ๊ธฐ๋Šฅ์„ ์‚ดํŽด๋ณด๋ฉด์„œ ์•Œ์•„๋ณด๋„๋ก ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.


1. map

๋จผ์ € ๋ฉ”์„œ๋“œ๋Š” ์œ„์™€ ๊ฐ™์œผ๋ฉฐ *๊ฐ€ ๋ถ™์–ด์žˆ๋Š” ํŒŒ๋ผ๋ฏธํ„ฐ๋Š” ์ƒ๋žตํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ธ๋ฑ์Šค๋Š” ํ˜„์žฌ๊ฐ’์˜ ์ธ๋ฑ์Šค, ๋ฐฐ์—ด์€ map์ด ์ˆœํšŒํ•˜๋Š” ๋ฐฐ์—ด array๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.

์ด์ œ map์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ธ ์ฝ”๋“œ๋ฅผ ํ™•์ธํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

const myArray = [10, 20, 30, 40, 50];

const newArray = myArray.map((value) => { return value });

console.log(newArray);  // [10, 20, 30, 40, 50]
console.log(myArray===newArray); //false

map์€ ํ•ด๋‹น ๋ฐฐ์—ด ์ž์ฒด๋ฅผ ๋ฐ”๊พธ๋Š” ๊ฒƒ์ด ์•„๋‹ˆ๋ฏ€๋กœ ๋ฆฌํ„ด๊ฐ’์„ ์‚ฌ์šฉํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ๋‹ค๋ฅธ ๋ณ€์ˆ˜์— ๋„ฃ์–ด ์ฃผ์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

ํŒŒ๋ผ๋ฏธํ„ฐ์—์„œ index๋Š” ํ˜„์žฌ ์ ‘๊ทผํ•œ ์š”์†Œ์˜ index์ด๋ฉฐ array๋Š” ์ˆœํšŒํ•˜๋Š” ๋ฐฐ์—ด ์ „์ฒด๋ฅผ ์ „๋‹ฌํ•ฉ๋‹ˆ๋‹ค.

const myArray = [10, 20, 30, 40, 50];

const newArray = myArray.map((value, index, array) => {
   if(index%2){
     return value-array[1];   
   }else{
     return value-array[0];
   }                              
});

console.log(newArray);

๋‹ค์Œ ์ฝ”๋“œ๋Š” ์ž์ฃผ ์ ‘ํ•˜๋Š” ์‹ค์ˆ˜ ์ค‘ ํ•˜๋‚˜๋กœ ์ฝ”๋“œ์˜ ๋™์ž‘ ์—ฌ๋ถ€๋ฅผ ์ƒ๊ฐํ•ด ๋ณผ ํ•„์š”๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

const myData = {10, 20, 30, 40, 50};

const newData = myData.map((value) => {return value+1});

console.log(newData);

์œ„ ์ฝ”๋“œ๋Š” ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

๋ฐ”๋กœ map์˜ ํŠน์„ฑ ๋•Œ๋ฌธ์ธ๋ฐ์š”. map์€ ๋ฐฐ์—ด์—์„œ ๋™์ž‘ํ•˜๋Š” ๋ฉ”์„œ๋“œ์ด๋ฉฐ ๊ฐ์ฒด object์—์„œ๋Š” ๋™์ž‘ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

ํ•˜์ง€๋งŒ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๋ฐฐ์—ด ๋‚ด๋ถ€์˜ object๋Š” ์ ‘๊ทผ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

const myData = [{name:'chamchi', age:3},{name:'ggongchi', age:2},{name:'myulchi', age:1}];

const newData = myData.map((value) => value.name );

console.log(newData); //['chamchi', 'ggongchi', 'myulchi']

๊ทธ๋ ‡๋‹ค๋ฉด map์„ ์‚ฌ์šฉํ•ด reduce๋‚˜ filter ๋ฉ”์„œ๋“œ์™€ ๊ฐ™์€ ๋กœ์ง์„ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์„๊นŒ์š”?

๋‹ค์Œ ์ฝ”๋“œ๋ฅผ ํ†ตํ•ด ํ™•์ธํ•  ์ˆ˜ ์žˆ์„ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.

const myArray = [1, 2, 3, 4, 5];

const newArray = myArray.map((value) => {
   if(value%2){
     return value;   
   }                            
});

console.log(newArray); //[1, undefined, 3, undefined, 5]

ํ™€์ˆ˜์˜ ์š”์†Œ๋งŒ ๋ฐ˜ํ™˜ํ•˜๊ณ ์ž ์œ„์™€ ๊ฐ™์ด ์ž‘์„ฑํ•˜๋”๋ผ๋„ map์€ ๋ชจ๋“  ์š”์†Œ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

์ง์ˆ˜ ๋ถ€๋ถ„์€ ๋ฆฌํ„ด๊ฐ’์ด ์ •์˜๋˜์ง€ ์•Š์•„ undefined๋กœ ๋ฐ˜ํ™˜๋œ ๊ฒƒ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋”ฐ๋ผ์„œ map์€ reduce, filter์˜ ๊ธฐ๋Šฅ์€ ๊ตฌํ˜„ํ•  ์ˆ˜ ์—†์„ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.


2. reduce

๋จผ์ € ๋ฉ”์„œ๋“œ๋Š” ์œ„์™€ ๊ฐ™์œผ๋ฉฐ *๊ฐ€ ๋ถ™์–ด์žˆ๋Š” ํŒŒ๋ผ๋ฏธํ„ฐ๋Š” ์ƒ๋žตํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋ˆ„์ ๊ฐ’์€ ๋ฐฐ์—ด์„ ์ˆœํšŒํ•˜๋ฉด์„œ ์ž‘์—…์˜ ์ฒ˜๋ฆฌ ๊ฒฐ๊ณผ๋ฅผ ๋ˆ„์ ํ•˜๋Š” ๊ฐ’์œผ๋กœ ์ˆœํšŒ๊ฐ€ ์ข…๋ฃŒ๋˜๋ฉด ์ตœ์ข… ๋ฆฌํ„ด๊ฐ’์ด ๋ฉ๋‹ˆ๋‹ค.

reduce์˜ ์˜ˆ์‹œ๋กœ ๋ชจ๋“  ์š”์†Œ๋ฅผ ๋”ํ•˜๋Š” ์˜ˆ์‹œ๊ฐ€ ๋งŽ๋‹ค๋ณด๋‹ˆ ์šฉ๋„๋Š” ์ „์ฒด ์š”์†Œ ๋”ํ•˜๊ฑฐ๋‚˜ ๋นผ์„œ ํ•˜๋‚˜๋กœ ๋งŒ๋“ค๊ธฐ๋ผ๊ณ 

์•Œ๊ณ  ์žˆ์„ ์ˆ˜ ์žˆ์ง€๋งŒ ๋ˆ„์ ๊ฐ’ ์„ค์ •์„ ํ†ตํ•ด ๋‹ค์–‘ํ•œ ๋ฐฉ์‹์œผ๋กœ ํ™œ์šฉ์ด ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

์ธ๋ฑ์Šค๋Š” ํ˜„์žฌ๊ฐ’์˜ ์ธ๋ฑ์Šค, ๋ฐฐ์—ด์€ reduce๊ฐ€ ์ˆœํšŒํ•˜๋Š” array ๋ฐฐ์—ด์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.

๋งˆ์ง€๋ง‰์— ์žˆ๋Š” ์‹œ์ž‘๊ฐ’์€ ๋ˆ„์ ๊ฐ’์˜ ์ฒ˜์Œ ๊ธฐ๋ณธ๊ฐ’์„ ์ „๋‹ฌํ•ฉ๋‹ˆ๋‹ค.

์ƒ๋žตํ•˜๋ฉด 0์ด ๊ธฐ๋ณธ๊ฐ’์ด ๋ฉ๋‹ˆ๋‹ค.

const myArray = [10, 20, 30, 40, 50];
const newArray = myArray.reduce((acc, value) => { return acc + value });

console.log(newArray); // 150

์‹œ์ž‘๊ฐ’์ด ์ƒ๋žต๋˜์—ˆ์œผ๋ฏ€๋กœ acc์˜ ๊ธฐ๋ณธ๊ฐ’์€ 0์ด ๋ฉ๋‹ˆ๋‹ค.

๊ทธ๋Ÿผ ์ดˆ๊ธฐ๊ฐ’์„ ์„ค์ •ํ•œ ์ƒ˜ํ”Œ์„ ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

const myArray = [10, 20, 30, 40, 50];
const newArray = myArray.reduce((acc, value) => { return acc + value },100);

console.log(newArray); // 250

์ด๋ฅผ ์‘์šฉํ•˜์—ฌ ์ดˆ๊ธฐ๊ฐ’์„ ์„ค์ •ํ•˜๋ฉด ๋‹ค์–‘ํ•œ ๊ฒฐ๊ณผ๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋จผ์ € ๋ฐฐ์—ด์„ ๋‹ค๋ฅธ ๋ฐฐ์—ด๋กœ ๋ณต์‚ฌํ•˜๋Š” ๊ธฐ๋Šฅ์„ ๊ตฌํ˜„ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

const myArray = [10, 20, 30, 40, 50];
const newArray = myArray.reduce((acc, value) => { 
     acc.push(value);
     return acc; 
 },[]);

console.log(newArray); // [10, 20, 30, 40, 50]

์ด๊ฒƒ์œผ๋กœ map๊ณผ ๋˜‘๊ฐ™์€ ๋กœ์ง์˜ ๊ตฌํ˜„์ด ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๋ ‡๋‹ค๋ฉด filter๋ฅผ ๊ตฌํ˜„ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

const myArray = [10, 20, 30, 40, 50];
const newArray = myArray.reduce((acc, value, index) => { 
     if(index%2){
       acc.push(value);
     }
     return acc; 
 },[]);

console.log(newArray); // [20, 40]

์ฝ”๋“œ๋ฅผ ํ†ตํ•ด ํ™•์ธํ•ด๋ณด๋‹ˆ reduce๋Š” ์ดˆ๊ธฐ๊ฐ’ ์„ค์ •์„ ํ†ตํ•ด map์ด๋‚˜ filter์™€ ๊ฐ™์€ ๋กœ์ง์˜ ๊ตฌํ˜„์ด ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.


3. filter

filter๋Š” ๋ง ๊ทธ๋Œ€๋กœ ๋ฐฐ์—ด์˜ ์š”์†Œ๋ฅผ ํ•„ํ„ฐ๋งํ•˜์—ฌ ์กฐ๊ฑด์ด ์ฐธ์ด ๋˜๋Š” ์š”์†Œ๋งŒ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

const myArray = [10, 20, 30, 40, 50];

const newArray = myArray.filter((value) => { 
    return value%20 === 0
 });

console.log(newArray); // [20, 40]

filter๋Š” ํ•„ํ„ฐ๋ง ๊ธฐ๋Šฅ๋งŒ ๊ฐ–๊ณ  ์žˆ์–ด map์ด๋‚˜ reduce์˜ ๋กœ์ง์„ ๋งŒ๋“ค๊ธด ์–ด๋ ค์šธ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.



map๊ณผ filter๋Š” ์šฉ๋„๊ฐ€ ์กฐ๊ธˆ ๋” ํŠน์ •๋˜์–ด ์žˆ๋‹ค๋ณด๋‹ˆ ๋‹ค๋ฅธ ๋ฉ”์„œ๋“œ์˜ ๋กœ์ง์„ ๊ทธ๋Œ€๋กœ ๊ตฌํ˜„ํ•˜๊ธฐ๋Š” ์–ด๋ ต์ง€๋งŒ reduce๋Š” ์ดˆ๊ธฐ๊ฐ’์„ ํ†ตํ•ด ๋‹ค์–‘ํ•œ ๋กœ์ง์˜ ๊ตฌํ˜„์ด ๊ฐ€๋Šฅํ•ด ๋‹ค์žฌ๋‹ค๋Šฅํ•œ ๋ฉ”์„œ๋“œ์ธ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.

์ด์ง„ ํƒ์ƒ‰(binary search), ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ๋กœ ๊ตฌํ˜„ํ•˜๊ธฐ

์ด์ง„ ํƒ์ƒ‰๊ณผ ๊ตฌํ˜„๋ฐฉ๋ฒ•

์ด์ง„ ํƒ์ƒ‰(binary search)์€ ๋ฐ์ดํ„ฐ ์ง‘ํ•ฉ์—์„œ ์›ํ•˜๋Š” ๋ฐ์ดํ„ฐ๋ฅผ ์ฐพ์„ ๋•Œ๊นŒ์ง€ ์ง‘ํ•ฉ์„ ์ด๋ถ„(ไบŒๅˆ†)ํ•˜์—ฌ ํƒ์ƒ‰ํ•˜๋Š” ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค.

๋ฐ์ดํ„ฐ ์ง‘ํ•ฉ์„ ๋‘˜๋กœ ๋‚˜๋ˆ„๊ณ  ์ฐพ๋Š” ๋ฐ์ดํ„ฐ๊ฐ€ ์žˆ๋Š” ์ง‘ํ•ฉ์„ ์„ ํƒํ•˜์—ฌ ๋‹ค์‹œ ๋ฐ˜์œผ๋กœ ๋‚˜๋ˆ„๊ณ  ๋‹ค์‹œ ๋ฐ์ดํ„ฐ๊ฐ€ ์žˆ๋Š” ์ง‘ํ•ฉ์— ๊ฐ™์€ ๊ณผ์ •์„ ๊ณ„์† ๋ฐ˜๋ณตํ•ฉ๋‹ˆ๋‹ค.

๋”ฐ๋ผ์„œ ์•„๋ฌด๋ฆฌ ํฐ ๋ฐ์ดํ„ฐ๋ผ๋„ ๋ช‡ ๋ฒˆ์˜ ์—ฐ์‚ฐ๋งŒ์œผ๋กœ ์›ํ•˜๋Š” ๋ฐ์ดํ„ฐ๋ฅผ ์ฐพ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

ํ•˜์ง€๋งŒ ์ด์ง„ ํƒ์ƒ‰์€ ์กฐ๊ฑด์ด ์žˆ๋Š”๋ฐ์š”.

๋ฐ์ดํ„ฐ๊ฐ€ ๋ฐ˜๋“œ์‹œ ์ˆœ์„œ๋Œ€๋กœ ์ •๋ ฌ๋œ ์ƒํƒœ์—ฌ์•ผ ํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๋ฆผ์„ ํ†ตํ•ด ํƒ์ƒ‰์˜ ๊ณผ์ •์„ ํ™•์ธํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

์œ„์™€ ๊ฐ™์€ ๋ฐ์ดํ„ฐ ์ง‘ํ•ฉ์—์„œ 2๋ฅผ ์ฐพ์œผ๋ ค๋ฉด ๋จผ์ € ์ง‘ํ•ฉ์„ ๋ฐ˜์œผ๋กœ ๋‚˜๋ˆ„๊ณ  ์ฐพ๋Š” ๋ฐ์ดํ„ฐ๊ฐ€ ์†ํ•œ ์ง‘ํ•ฉ์„ ์„ ํƒํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๋Ÿผ ์ฒซ ๋ฒˆ์งธ๋กœ ์„ ํƒํ•œ ์ง‘ํ•ฉ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๋˜ ๋ฐ˜์„ ๋‚˜๋ˆ„๊ณ  2๊ฐ€ ์†ํ•œ ์ง‘ํ•ฉ๋งŒ์„ ์„ ํƒํ•ฉ๋‹ˆ๋‹ค.

์—ฌ๊ธฐ์„œ ๋ฐ˜์„ ๋‚˜๋ˆ„๊ณ  2๊ฐ€ ์†ํ•œ ์ง‘ํ•ฉ์„ ์„ ํƒํ•˜๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

์ด์ œ ๋‘˜ ์ค‘ ํ•˜๋‚˜๋ฅผ ํ™•์ธํ•˜์—ฌ ์›ํ•˜๋Š” ๋ฐ์ดํ„ฐ๋ฅผ ์„ ํƒํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค.

์ด์ง„ ํƒ์ƒ‰ ์ฝ”๋“œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

const binarySearch=(target, data)=>{

  let low = 0;
  let high = data.length-1;
  
  while(low<=high){
    
    let mid = Math.floor((low+high)/2);    
  
    if(target===data[mid]){
       return mid;
    }else if(target>data[mid]){
      low = mid+1 
    }else if(target<data[mid]){
      high = mid-1
    }
  }

  return undefined;
}

์ด ํƒ์ƒ‰ ๋ฐฉ๋ฒ•์€ ๋ฐ์ดํ„ฐ์˜ ์–‘์ด ๋งŽ์•„์ง€๋ฉด ์—„์ฒญ๋‚œ ํšจ์œจ์„ ์ž๋ž‘ํ•ฉ๋‹ˆ๋‹ค.

๋ฐ์ดํ„ฐ๊ฐ€ 10000๊นŒ์ง€ ์žˆ์„ ๋•Œ 8000์„ ์ฐพ๊ธฐ ์œ„ํ•ด์„œ ๋ฌด์ฐจ๋ณ„ ๋Œ€์ž…์€ 7999๋ฒˆ์˜ ์—ฐ์‚ฐ์„ ์ง„ํ–‰ํ•ด์•ผ ํ•˜์ง€๋งŒ ์ด์ง„ ํƒ์ƒ‰ ๋ฐฉ๋ฒ•์€ 13๋ฒˆ์˜ ์—ฐ์‚ฐ์ด๋ฉด ์›ํ•˜๋Š” ๋ฐ์ดํ„ฐ๋ฅผ ์ฐพ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ๋ฅผ ์ด์šฉํ•œ BFS, DFS ๊ตฌํ˜„ํ•˜๊ธฐ(javascript)

๋ฐ์ดํ„ฐ๋Š” ์„ ํ˜• ๊ตฌ์กฐ(๋ฐฐ์—ด, ์—ฐ๊ฒฐ๋ฆฌ์ŠคํŠธ, ์Šคํƒ, ํ) ๋˜๋Š” ๋น„์„ ํ˜• ๊ตฌ์กฐ(ํŠธ๋ฆฌ, ๊ทธ๋ž˜ํ”„)๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์œผ๋ฉฐ, ์ˆœ์ฐจ์ ์œผ๋กœ ๋‚˜์—ด๋œ ์„ ํ˜• ๊ตฌ์กฐ์— ๋น„ํ•ด ๋น„์„ ํ˜• ๊ตฌ์กฐ์˜ ๋ฐ์ดํ„ฐ๋Š” ํƒ์ƒ‰์ด ์–ด๋ ต์Šต๋‹ˆ๋‹ค.

ํ•˜์ง€๋งŒ ๋น„์„ ํ˜• ๊ตฌ์กฐ์˜ ๋Œ€ํ‘œ์ ์ธ ํƒ์ƒ‰ ๋ฐฉ๋ฒ•์ธ BFS, DFS๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๊น”๋”ํ•˜๊ฒŒ ํƒ์ƒ‰์ด ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

๋‘ ๋ฐฉ๋ฒ• ๋ชจ๋‘ ๋ฌด์ฐจ๋ณ„ ํƒ์ƒ‰(Brute Force Search, ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ํ•˜๋‚˜์”ฉ ํƒ์ƒ‰) ๋ฐฉ๋ฒ•์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.


DFS๋Š” ๊นŠ์ด ์šฐ์„  ํƒ์ƒ‰ ๋ฐฉ๋ฒ•์œผ๋กœ ํŠธ๋ฆฌ ๊ตฌ์กฐ์˜ ๋ฐ์ดํ„ฐ์—์„œ ๋…ธ๋“œ๋งˆ๋‹ค ๊ฐ€์žฅ ๊นŠ์ด๊นŒ์ง€ ํƒ์ƒ‰ํ•œ ๋’ค ๋‹ค์Œ ๋…ธ๋“œ๋กœ ์ด๋™ํ•˜๋Š” ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค.

์œ„์™€ ๊ฐ™์€ ํŠธ๋ฆฌ ๊ตฌ์กฐ์˜ ๋ฐ์ดํ„ฐ๊ฐ€ ์žˆ์„ ๋•Œ, DFS๋Š” ํ•œ๋ฒˆ ์„ ํƒํ•œ ๊ธธ์€ ๋๊นŒ์ง€ ๊ฐ€๋ณธ ๋’ค ๋‹ค์Œ ๊ธธ์„ ํƒ์ƒ‰ํ•˜๋Š” ๋ฐฉ์‹๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๊ทธ๋ฆผ์œผ๋กœ ๋‚˜ํƒ€๋‚ด๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๊ฒ€์ƒ‰ ์†๋„๋Š” BFS์— ๋น„ํ•ด์„œ ๋А๋ฆฌ์ง€๋งŒ ์กฐ๊ธˆ ๋” ๊ฐ„๋‹จํ•ฉ๋‹ˆ๋‹ค.

๊ฒฝ๋กœ์˜ ํŠน์ง•์ด ํ•„์š”ํ•œ ๋ฌธ์ œ๋ฅผ ํ’€ ๋•Œ DFS๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

const graph = {
  A: ["B", "C"],
  B: ["A", "D"],
  C: ["A", "E"],
  D: ["B", "F"],
  E: ["C","G"],
  F: ["D","H","I"],
  G: ["E","J","K"],
  H: ["F","L"],
  I: ["F", "M"],
  J: ["G","N"],
  K: ["G","O"],
  L: ["H"],
  M: ["I","P"],
  N: ["J"],
  O: ["K"],
  P: ["M"]
};

const bfs = (graph, start) => {

    const checked = [];    // ํƒ์ƒ‰ ์™„๋ฃŒ ๋ฐ์ดํ„ฐ
    const willCheck = [];  // ํƒ์ƒ‰ ์˜ˆ์ • ๋ฐ์ดํ„ฐ
    
    willCheck.push(start);
    
    while(willCheck.length!==0){
      const node = willCheck.pop();  // ์Šคํƒ(Last In First Out)
      if(!checked.includes(node)){
       	 checked.push(node);
         //reverse() ์ œ๊ฑฐ ์‹œ ๊ทธ๋ฆผ์˜ 4,3,2,1 ์ˆœ์„œ๋กœ ํƒ์ƒ‰     
      	 willCheck.push(...graph[node].reverse());  
        
      }
   }
	return checked;
}

console.log(bfs(graph, "A"));
// ['A', 'B', 'D', 'F', 'H', 'L', 'I', 'M', 'P', 'C', 'E', 'G', 'J', 'N', 'K', 'O']

BFS๋Š” ๋„ˆ๋น„ ์šฐ์„  ํƒ์ƒ‰ ๋ฐฉ๋ฒ•์œผ๋กœ ํŠธ๋ฆฌ ๊ตฌ์กฐ ๋ฐ์ดํ„ฐ์—์„œ ๋…ธ๋“œ์˜ ์ธ์ ‘ ๋ฐ์ดํ„ฐ๋ฅผ ๋ชจ๋‘ ํƒ์ƒ‰ํ•œ ๋’ค ๋‹ค์Œ ๋ฐ์ดํ„ฐ๋กœ ์ด๋™ํ•˜๋Š” ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค.

๊ทธ๋ฆผ์œผ๋กœ ๋‚˜ํƒ€๋‚ด๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

ํƒ์ƒ‰ ์†๋„๋Š” DFS๋ณด๋‹ค ๋น ๋ฅด๋ฉฐ ์ตœ๋‹จ ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ•˜๋Š” ๋ฌธ์ œ์—์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

const graph = {
  A: ["B", "C"],
  B: ["A", "D"],
  C: ["A", "E"],
  D: ["B", "F"],
  E: ["C","G"],
  F: ["D","H","I"],
  G: ["E","J","K"],
  H: ["F","L"],
  I: ["F", "M"],
  J: ["G","N"],
  K: ["G","O"],
  L: ["H"],
  M: ["I","P"],
  N: ["J"],
  O: ["K"],
  P: ["M"]
};

const bfs = (graph, start) => {

    const checked = [];
    const willCheck = [];
    
    willCheck.push(start);
    
    while(willCheck.length!==0){
      const node = willCheck.shift(); // ํ(First In First Out)
      if(!checked.includes(node)){
       	 checked.push(node);
      	 willCheck.push(...graph[node]);       
      }
   }
	return checked;
}

console.log(bfs(graph, "A"));
// ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P']

textContent, innerText, innerHTML ๊ฐ„๋‹จ ๋น„๊ต(javascript)

์š”์†Œ์˜ ํ…์ŠคํŠธ๋ฅผ ๋‹ค๋ฃจ๋Š” textContent, innerText, innerHTML์˜ ์ฐจ์ด์ ๊ณผ ์œ ์˜ ์‚ฌํ•ญ

์š”์†Œ์— ์ ‘๊ทผํ•ด ๋ฐ์ดํ„ฐ๋ฅผ ์„ค์ •ํ•˜๊ฑฐ๋‚˜ ๊ฐ€์ ธ์˜ฌ ๋•Œ ์‚ฌ์šฉํ•˜๋Š” ํ”„๋กœํผํ‹ฐ์ธ textContent, innerText, innerHTML์— ๋Œ€ํ•ด ์•Œ์•„๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

<div id=1 onClick=(check(event))>click
    <div id=2>child1</div>
    <div id=3>child2
      <div id=4>grandchild</div>
    </div>
</div>

onClick ์ด๋ฒคํŠธ๋ฅผ ํ†ตํ•ด div์š”์†Œ์˜ ํ…์ŠคํŠธ์— ์ ‘๊ทผํ•  ๋•Œ ๊ฐ๊ฐ์˜ ํ”„๋กœํผํ‹ฐ๋ฅผ ์‚ฌ์šฉํ•œ ๊ฒฐ๊ณผ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.


1. ์‹คํ–‰ ๊ฒฐ๊ณผ

const check = (event) => {
    console.log(event.target.textContent); 
}
const check = (event) => {
    console.log(event.target.innerText); 
}
const check = (event) => {
    console.log(event.target.innerHTML); 
}

textContent

text/plain์œผ๋กœ ํŒŒ์‹ฑํ•˜์—ฌ ๋ชจ๋“  ์š”์†Œ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. <script>, <style> ์š”์†Œ๋ฅผ ํฌํ•จํ•ด CSS๋ฅผ ์‚ฌ์šฉํ•ด ์ˆจ๊ฒจ์ง„ ์š”์†Œ๋„ ํ•จ๊ป˜ ๋ฐ˜ํ™˜ํ•˜๋ฉฐ ์š”์†Œ์˜ ์›์‹œ ํ…์ŠคํŠธ๋ฅผ ์‚ฌ์šฉํ•˜๋ฏ€๋กœ ์„ฑ๋Šฅ์ด ์ข‹์Šต๋‹ˆ๋‹ค.

innerText

text/plain์œผ๋กœ ํŒŒ์‹ฑํ•˜์—ฌ ๋ Œ๋”๋ง ํ›„์˜ ์š”์†Œ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. <script>, <style> ์š”์†Œ๋Š” ๋ฐ˜ํ™˜ํ•˜์ง€ ์•Š์œผ๋ฉฐ ์ˆจ๊ฒจ์ง„ ์š”์†Œ๋„ ๋ฐ˜ํ™˜ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์ž์‹ ๋…ธ๋“œ๋ฅผ ๋ชจ๋‘ ์ œ๊ฑฐํ•˜๊ณ  ํ•˜๋‚˜์˜ ํ…์ŠคํŠธ๋กœ ๋ฐ˜ํ™˜๋˜๋ฉฐ ์„ฑ๋Šฅ์€ ๋ณดํ†ต์ž…๋‹ˆ๋‹ค.

innerHTML

text/html๋กœ ํŒŒ์‹ฑํ•˜์—ฌ ์š”์†Œ์˜ html, xml ์ „์ฒด๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. html์„ ๋‹ค๋ฃจ๋ฏ€๋กœ ๋ณด์•ˆ ์ด์Šˆ ์ค‘ ํ•˜๋‚˜์ธ XSS(Cross Site Scripting)์— ์ทจ์•ฝํ•ฉ๋‹ˆ๋‹ค. HTML5์—์„œ๋Š” innerHTML์— ์‚ฝ์ž…๋œ <script> ํƒœ๊ทธ๋Š” ์‹คํ–‰๋˜์ง€ ์•Š๋„๋ก ๋ณ€๊ฒฝ๋˜์—ˆ์ง€๋งŒ <img>๋“ฑ ๋‹ค๋ฅธ ํƒœ๊ทธ๋ฅผ ํ†ตํ•ด ์ ‘๊ทผํ•˜๋ฉด ์—ฌ์ „ํžˆ ์ทจ์•ฝ์ ์ด ๋‚จ์Šต๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ innerHTML์€ ๋ณ„๋„๋กœ ๋ฌธ์ œ ๋ฐฉ์ง€๋ฅผ ์œ„ํ•œ ์„ค์ •์ด ์—†๋‹ค๋ฉด ์‚ฌ์šฉ์„ ๊ถŒ์žฅํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.



๊ตฌํ˜„๋„ ์ค‘์š”ํ•˜์ง€๋งŒ ์ƒํ™ฉ์— ๋งž๊ณ  ์ ์ ˆํ•œ ๋ฐฉ์‹์„ ํ†ตํ•ด ๊ตฌํ˜„ํ•œ ์‹œ์Šคํ…œ์— ๋ฌธ์ œ๊ฐ€ ์ƒ๊ธฐ์ง€ ์•Š๋„๋ก ์‚ฌ์ „์— ๋ฐฉ์ง€ํ•˜๋Š” ๊ฒƒ์ด ๋” ์ค‘์š”ํ•œ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค. ์ ์ ˆํ•œ ๋ฐฉ์‹์„ ์„ ํƒํ•˜๋Š” ๊ฒƒ์€ ๊ฒฐ๊ตญ ๊ฐ ๊ธฐ๋Šฅ์˜ ์ดํ•ด๋ฅผ ํ†ตํ•ด์„œ์•ผ ๋น„๋กœ์†Œ ๊ฐ€๋Šฅํ•œ ๋ถ€๋ถ„์ด๋ฏ€๋กœ ํ•„์š”ํ•  ๋•Œ ์ •๋ฆฌ๋ฅผ ํ•ด๋‘๋ฉด ๋„์›€์ด ๋  ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.

ํ…œํ”Œ๋ฆฟ ๋ฆฌํ„ฐ๋Ÿด(template literal)๊ณผ ์‰ฌ์šด ์‘์šฉ(feat.`)

`๋กœ ์‹œ์ž‘ํ•ด์„œ `๋กœ ๋๋‚˜๋Š” ํ…œํ”Œ๋ฆฟ ๋ฆฌํ„ฐ๋Ÿด

ํ…œํ”Œ๋ฆฟ ๋ฆฌํ„ฐ๋Ÿด(template literal)์€ ES6๋ถ€ํ„ฐ ๋„์ž…๋œ ๊ธฐ๋Šฅ์œผ๋กœ ๋ฌธ์ž์—ด ๋‹ค๋ฃจ๊ธฐ์— ํŠนํ™”๋œ ๊ธฐ๋Šฅ์ธ๋ฐ์š”.

` (backtick, grave accent)

ํ…œํ”Œ๋ฆฟ ๋ฆฌํ„ฐ๋Ÿด์€ ` ๊ธฐํ˜ธ๋กœ ์‹œ์ž‘ํ•ด ` ๊ธฐํ˜ธ๋กœ ๋๋‚˜๋ฉฐ, ๋ฌธ์ž์—ด๊ณผ ๋ณ€์ˆ˜๋ฅผ ํ•จ๊ป˜ ์ „๋‹ฌํ•˜๊ฑฐ๋‚˜ ํƒœ๊ทธ๋ฅผ ํŽธ๋ฆฌํ•˜๊ฒŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋˜ํ•œ ๋‹ค์Œ๊ณผ ๊ฐ™์€ ๋ฐฉ์‹๋„ ์‚ฌ์šฉ๋„ ๊ฐ€๋Šฅํ•œ๋ฐ์š”.

const printData = (text) => {
    console.log(text[0]); // 'Hello everyone!'
}

printData`Hello everyone!`;

ํ•จ์ˆ˜์— ํ…œํ”Œ๋ฆฟ ๋ฆฌํ„ฐ๋Ÿด์„ ์ „๋‹ฌํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

์ด๋ฅผ ํƒœ๊ทธ๋“œ ํ…œํ”Œ๋ฆฟ(tagged template)์ด๋ผ๊ณ  ํ•˜๋Š”๋ฐ์š”.

ํ˜ธ์ถœ๋œ ํ•จ์ˆ˜๋Š” ํ…œํ”Œ๋ฆฟ ๋ฆฌํ„ฐ๋„ ๋‚ด ๋ฌธ์ž์—ด ์กฐ๊ฐ์ด๋‚˜ ํ‘œํ˜„์‹ ๋“ฑ์„ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ๋ฐ›์Šต๋‹ˆ๋‹ค.

styled-components์—์„œ ์‚ฌ์šฉ๋˜๋Š” ๋ฐฉ์‹๋„ ํƒœ๊ทธ๋“œ ํ…œํ”Œ๋ฆฟ์ž…๋‹ˆ๋‹ค.


1. ํ…œํ”Œ๋ฆฟ ๋ฆฌํ„ฐ๋Ÿด(template literal)

ํ…œํ”Œ๋ฆฟ ๋ฆฌํ„ฐ๋Ÿด์€ ์‹œ์ž‘๊ณผ ๋์— ๋ฐ˜๋“œ์‹œ `(backtick)์„ ๋ถ™์—ฌ์•ผ ํ•˜๋ฉฐ, ‘(ํ™‘๋”ฐ์˜ดํ‘œ), “(์Œ๋”ฐ์˜ดํ‘œ)์™€ ๋ฐ˜๋“œ์‹œ ๊ตฌ๋ถ„ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

const name = 'clint Eastwood';
const age = '92';
const city = 'San Francisco';
const occupation = 'director';

// ํ‘œํ˜„์‹
console.log('His name is '+name+ '\n' + 'and '+age+'.');

// ํ…œํ”Œ๋ฆฟ ๋ฆฌํ„ฐ๋Ÿด
console.log(`He was born in ${city}
and he is a ${occupation}`);

ํ…œํ”Œ๋ฆฟ ๋ฆฌํ„ฐ๋Ÿด์—์„œ ${ }๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋ธ”๋ก ๋‚ด ๋ณ€์ˆ˜ ๋˜๋Š” ํ•จ์ˆ˜์— ์ ‘๊ทผ์ด ๊ฐ€๋Šฅํ•˜๋ฉฐ, \n ๋“ฑ ์ด์Šค์ผ€์ดํ”„๋ฅผ ์‚ฌ์šฉํ•˜์ง€ ์•Š๊ณ ๋„ ์ž…๋ ฅํ•œ๋Œ€๋กœ ์ถœ๋ ฅํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

ํ…œํ”Œ๋ฆฟ ๋ฆฌํ„ฐ๋Ÿด์€ ์‰ฝ๊ฒŒ ์‘์šฉ์ด ๊ฐ€๋Šฅํ•˜๋‹ˆ ํƒœ๊ทธ๋“œ ํ…œํ”Œ๋ฆฟ์— ๋Œ€ํ•ด ์•Œ์•„๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

2. ํƒœ๊ทธ๋“œ ํ…œํ”Œ๋ฆฟ(tagged template)

const TextBox = styled.div`
  display: inline-block;
  color: gray;
  margin: 0 auto;
`;

const StyledInput = styled.input`
    font-size: 1rem;
    border: none;
    border-bottom: 1px solid gray;
    outline: none;
    width: 100%;
`;

์œ„์™€ ๊ฐ™์ด styled-components์—์„œ ํƒœ๊ทธ๋“œ ํ…œํ”Œ๋ฆฟ์ด ๋ฐฅ ๋จน๋“ฏ์ด ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.

ํ…œํ”Œ๋ฆฟ ๋ฆฌํ„ฐ๋Ÿด๋กœ ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•˜๋ฉด ์–ด๋–ป๊ฒŒ ์‚ฌ์šฉํ• ๊นŒ์š”?

ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•˜๋ฉด ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ๋ฌธ์ž์—ด๊ณผ ๋ณ€์ˆ˜๊ฐ€ ์ „๋‹ฌ๋ฉ๋‹ˆ๋‹ค.

const name = 'clint';
const age = '92';
const city = 'LA';

const showString = (text, ...args) => {
    console.log(text);
    console.log(args);
    console.log(text[2]);
    console.log(args[2]);
}

showString`He is ${name} and ${age}. From ${city}`;

์ „๋‹ฌ๋œ ๋งค๊ฐœ๋ณ€์ˆ˜๋Š” ํ…์ŠคํŠธ์™€ ${ }์— ๋„ฃ์€ ๋ณ€์ˆ˜์ด๋ฉฐ, ๊ฐ๊ฐ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

ํ…์ŠคํŠธ์™€ ๋ณ€์ˆ˜์— ์ ‘๊ทผํ•˜๋ ค๋ฉด ์ธ๋ฑ์Šค๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค.

ํ…์ŠคํŠธ์˜ ๊ฒฝ์šฐ ${ }์ด ๋“ค์–ด๊ฐ„ ๋ถ€๋ถ„์—์„œ ๋Š์–ด์ฃผ๋ฏ€๋กœ ‘He is’, ‘ and ‘, ‘. From ‘, ”์ด๋ ‡๊ฒŒ ๋„ค ๋ถ€๋ถ„์œผ๋กœ ๋‚˜๋‰˜์–ด์ง€๋ฉฐ, ์ˆœ์„œ๋Œ€๋กœ 0, 1, 2, 3์˜ ์ธ๋ฑ์Šค๋ฅผ ๊ฐ–์Šต๋‹ˆ๋‹ค.

ํƒœ๊ทธ๋“œ ํ…œํ”Œ๋ฆฟ์„ ์‚ฌ์šฉํ•˜๋Š” ์ด์œ ๋Š” ๋ฌธ์ž์—ด์„ ์›ํ•˜๋Š” ํ˜•์‹์œผ๋กœ ์žฌ๊ฐ€๊ณตํ•˜์—ฌ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ์žฅ์ ์ด ์žˆ๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.



styled-components๋ฅผ ๋ฌดํ„ฑ๋Œ€๊ณ  ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ๋ณด๋‹ค ๊ตฌ์กฐ๋ฅผ ์•Œ๊ณ  ์‚ฌ์šฉํ•˜๋ฉด ๋” ๋„์›€์ด ๋  ๊ฒƒ ๊ฐ™์•„ ํƒœ๊ทธ๋“œ ๋ฆฌํ„ฐ๋Ÿด์— ๋Œ€ํ•ด ์•Œ์•„๋ณด์•˜์Šต๋‹ˆ๋‹ค. ํ…œํ”Œ๋ฆฟ ๋ฆฌํ„ฐ๋Ÿด์€ ์ด์ œ ๋„ˆ๋ฌด ์œ ์šฉํ•˜๊ณ  ํŽธ๋ฆฌํ•œ ๊ธฐ๋Šฅ์ด๋ฏ€๋กœ ๊ผญ ์•Œ์•„๋‘์–ด์•ผ ํ•  ๊ธฐ๋Šฅ ์ค‘ ํ•˜๋‚˜์ธ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.

target์œผ๋กœ ๋ถ€๋ชจ ์š”์†Œ, ์ž์‹ ์š”์†Œ ์ ‘๊ทผํ•˜๊ธฐ(์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ,target)

event์™€ target์œผ๋กœ ๋ถ€๋ชจ ์š”์†Œ์™€ ์ž์‹ ์š”์†Œ์— ์ ‘๊ทผํ•˜๋Š” ๋ฐฉ๋ฒ•

์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ๋Š” ๋ณดํ†ต ์ด๋ฒคํŠธ์™€ target์„ ํ†ตํ•ด ์š”์†Œ์— ์ ‘๊ทผํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๋ฆฌ๊ณ  <div>์™€ ๊ฐ™์€ ์š”์†Œ๋ฅผ ์ค‘์ฒฉํ•ด์„œ ์‚ฌ์šฉํ•˜๋‹ค ๋ณด๋ฉด ์ด๋ฒคํŠธ ๋ฐœ์ƒ ์‹œ ๋ถ€๋ชจ ์š”์†Œ ๋˜๋Š” ์ž์‹ ์š”์†Œ์— ์ ‘๊ทผ์ด ํ•„์š”ํ•œ ๊ฒฝ์šฐ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

์˜ˆ๋ฅผ ๋“ค๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์ด id=2์ธ div ์š”์†Œ์˜ ์ด๋ฒคํŠธ๊ฐ€ ๋ฐœ์ƒํ–ˆ์„ ๋•Œ ๋ถ€๋ชจ div ์š”์†Œ id=1์— ์ ‘๊ทผํ•˜๊ณ  ์‹ถ์€ ๊ฒฝ์šฐ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

const check = (event) => {
    console.log(event.target.id);
}

<body>
  <div id=1>    
        <div id=2 onClick=(check(event))>click
            <div id=3></div>
            <div id=4></div>
        </div>
  </div>
</body>

๊ทธ๋ ‡๋‹ค๋ฉด ์–ด๋–ป๊ฒŒ ์ ‘๊ทผ์„ ํ•ด์•ผ ํ• ๊นŒ์š”?

1. ์ด๋ฒคํŠธ๋ฅผ ํ†ตํ•ด ๋ถ€๋ชจ ์š”์†Œ ์†์„ฑ ์ ‘๊ทผํ•˜๊ธฐ

ํ˜„์žฌ ์ด๋ฒคํŠธ๊ฐ€ ๋ฐœ์ƒํ•œ ์š”์†Œ๋ฅผ ๊ฐ์‹ธ๊ณ  ์žˆ๋Š” ๋ถ€๋ชจ ์š”์†Œ์— ์ ‘๊ทผํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” target๊ณผ parentElement๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋ถ€๋ชจ ์š”์†Œ์˜ id ์†์„ฑ์— ์ ‘๊ทผํ•˜๋Š” ์ฝ”๋“œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

const check = (event) => {
    console.log(event.target.parentElement.id);    // 1
}

<body>
  <div id=1>    
        <div id=2 onClick=(check(event))>click
            <div id=3></div>
            <div id=4></div>
        </div>
  </div>
</body>

์‹คํ–‰ํ•ด๋ณด๋ฉด ์ฝ˜์†”์— 1์„ ํ”„๋ฆฐํŠธํ•ฉ๋‹ˆ๋‹ค.

๋งŒ์•ฝ id๊ฐ€ ์•„๋‹Œ ๋‹ค๋ฅธ ์†์„ฑ์— ์ ‘๊ทผํ•˜๊ณ  ์‹ถ์€ ๊ฒฝ์šฐ์—๋Š” id ๋Œ€์‹  ํ•ด๋‹น ์†์„ฑ๋ช…์„ ๊ทธ๋Œ€๋กœ ์‚ฌ์šฉํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค.

๊ตฌ์กฐ๋ฅผ ํ™•์ธํ•˜๊ณ  ์‹ถ์€ ๊ฒฝ์šฐ์—๋Š” console.log(event.target.parentElement)์„ ์ž…๋ ฅํ•˜์—ฌ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

console.log(event.target.parentElement)๊ฒฐ๊ณผ

ํ˜„์žฌ ์š”์†Œ๋ฅผ ๊ธฐ์ ์œผ๋กœ ์ ‘๊ทผ์„ ์ง„ํ–‰ํ•˜๋ฏ€๋กœ target์„ ์‚ฌ์šฉํ•˜๋ฉฐ, ์ด๋ฒคํŠธ๊ฐ€ ๊ธฐ์ ์ด ๋˜๋Š” ๊ฒฝ์šฐ currentTarget๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

๊ด€๋ จ ํฌ์ŠคํŠธ : target, currentTarget ์ฐจ์ด๊ฐ€ ๋ญ˜๊นŒ?


2. ์ด๋ฒคํŠธ๋ฅผ ํ†ตํ•ด ์ž์‹ ์š”์†Œ ์†์„ฑ ์ ‘๊ทผํ•˜๊ธฐ

์œ„ ์ฝ”๋“œ์—์„œ ๋ณด๋ฉด <div id=2>์˜ ์ž์‹ ์š”์†Œ๋Š” <div id=3>๊ณผ <div id=4>์ž…๋‹ˆ๋‹ค.

์ž์‹ ์š”์†Œ๋Š” target๊ณผ children์„ ํ†ตํ•ด ์ ‘๊ทผํ•˜๋Š”๋ฐ์š”.

๋ถ€๋ชจ ์š”์†Œ๋Š” ํ•˜๋‚˜๋ฐ–์— ์—†์ง€๋งŒ ์ž์‹ ์š”์†Œ๋Š” ์—ฌ๋Ÿฟ ์กด์žฌํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋”ฐ๋ผ์„œ ์ž์‹ ์š”์†Œ๋Š” ์ธ๋ฑ์Šค๋ฅผ ํ†ตํ•ด ์ ‘๊ทผํ•ด์•ผ ํ•˜๋ฉฐ, ๋ฆฌ์•กํŠธ ์ฝ”๋“œ๋ฅผ ํ†ตํ•ด ์ž์‹ ์š”์†Œ์˜ ๊ตฌ์กฐ๋ฅผ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

const accessChildren = () => {

const check = (e) => {
    console.log(e.target.children)
}

    return (
        <div id={1}>    
            <div id={2} onClick={check}>click
                <div id={3}>I'm a first child</div>
                <div id={4}></div>
            </div>
        </div>
    )
}

export default accessChildren;

์ฝ˜์†”์— ์ฐํžˆ๋Š” children์˜ ๊ตฌ์กฐ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๋‘ ๊ฐœ์˜ object๋ฅผ ๊ฐ–์Šต๋‹ˆ๋‹ค.

๋”ฐ๋ผ์„œ ์ฒซ ๋ฒˆ์งธ ์ž์‹ ์š”์†Œ์˜ id์— ์ ‘๊ทผํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์‚ฌ์šฉํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค.

const check = (e) => {
    console.log(typeof(e.target.children[0].id)) // 3
}

๊ทธ๋ ‡๋‹ค๋ฉด ์ฒซ ๋ฒˆ์งธ ์ž์‹ ์š”์†Œ์˜ ํ…์ŠคํŠธ์ธ I’m a first child๋Š” ์–ด๋–ป๊ฒŒ ์ ‘๊ทผํ• ๊นŒ์š”?

๊ฐ„๋‹จํ•˜๊ฒŒ ์œ„ children ๊ตฌ์กฐ๋ฅผ ์—ด์–ด์„œ ์‚ดํŽด๋ณด๋ฉด ๋‹ต์ด ๋‚˜์˜ต๋‹ˆ๋‹ค.

textContent๋ฅผ ์‚ฌ์šฉํ•ด์„œ ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. (innerHTML์€ XSS์— ์ทจ์•ฝ)

const check = (e) => {
    console.log(e.target.children[0].textContent) //I'm a first child
}


ํŠน์ • ์š”์†Œ๊ฐ€ ์†ํ•œ ์†์„ฑ ์ „์ฒด(์˜ˆ๋ฅผ ๋“ค๋ฉด e.target)๋ฅผ ์ฝ˜์†”์— ์ถœ๋ ฅํ•˜๋ฉด ๋‹ค์–‘ํ•œ ํ•˜์œ„ ์†์„ฑ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ ์›ํ•˜๋Š” ์†์„ฑ์„ ์ฐพ๊ฑฐ๋‚˜ ์—๋Ÿฌ๋ฅผ ํ•ด๊ฒฐํ•  ๋•Œ ์œ ์šฉํ•˜๊ฒŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.