์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ, 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();

React์—์„œ iframe ์ „์ฒดํ™”๋ฉด ์ „ํ™˜ํ•˜๊ธฐ(์†์„ฑ ์ฒดํฌ ํฌํ•จ)

allowfullscreen ๊ทธ๋ฆฌ๊ณ  document.fullscreenEnabled

ํ™”๋ฉด ๋‚ด๋ถ€์— ์‚ฝ์ž…๋œ iframe์—์„œ ์ „์ฒด ํ™”๋ฉด ์„ค์ •, ํ•ด์ œ ๊ธฐ๋Šฅ์„ ๊ตฌํ˜„ํ•˜๋ ค๊ณ  ํ•œ๋‹ค.
๊ตฌํ˜„์€ ์ƒ๊ฐ๋ณด๋‹ค ๊ฐ„๋‹จํ•˜๋‹ค.

๋จผ์ € iframe ํƒœ๊ทธ์— allowfullscreen ์†์„ฑ์„ ์ถ”๊ฐ€ํ•ด์•ผ ํ•œ๋‹ค.
allowfullscreen ์†์„ฑ์„ ๊ฐ–๋Š” iframe์€ ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ์—์„œ ์ œ๊ณตํ•˜๋Š” ๋ฉ”์„œ๋“œ๋ฅผ ํ†ตํ•ด ์ „์ฒดํ™”๋ฉด ์„ค์ •, ํ•ด์ œ๊ฐ€ ๊ฐ€๋Šฅํ•˜๋ฉฐ ESC๋„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.

<iframe src=”https://choonse.com” allowfullscreen />

์ „์ฒด ํ™”๋ฉด ์„ค์ • ๋ฉ”์„œ๋“œ document.documentElement.requestFullscreen()
์ „์ฒด ํ™”๋ฉด ํ•ด์ œ ๋ฉ”์„œ๋“œ document.exitFullscreen()

์ „์ฒดํ™”๋ฉด ์„ค์ •/ํ•ด์ œ ๋ฒ„ํŠผ์— ์ด๋ฒคํŠธ๋ฅผ ๊ฑธ์–ด์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์œผ๋ฉฐ, ๋ฐ˜ํ™˜ํ˜•์€ Promise์ด๋‹ค.

๋งŒ์•ฝ allowfullscreen ์†์„ฑ์ด ์—†๋Š” iframe์—์„œ ํ•ด๋‹น ๋ฉ”์„œ๋“œ๋ฅผ ํ˜ธ์ถœํ•˜๋ฉด ์–ด๋–ป๊ฒŒ ๋ ๊นŒ?disallowed by permissions policy ์—๋Ÿฌ๋กœ ์‚ฌ๋žŒ์„ ๋‹นํ™ฉ์‹œํ‚จ๋‹ค.

์ด ๋•Œ๋Š” allowfullscreen ์†์„ฑ์˜ ์กด์žฌ ์—ฌ๋ถ€(true)๋ฅผ ์ฒดํฌํ•ด์ฃผ๋ฉด ๋˜๋Š”๋ฐ, ํ•ด๋‹น ์†์„ฑ์€
document.fullscreenEnabled ์†์„ฑ์„ ์‚ฌ์šฉํ•ด true/false๋กœ ํ™•์ธํ•œ๋‹ค.

๋งŒ์•ฝ iframe์— allowfullscreen ์†์„ฑ์ด ์—†์„ ๋•Œ ์ „์ฒด ํ™”๋ฉด ๋ฒ„ํŠผ์„ ๋น„ํ™œ์„ฑํ™”ํ•˜๊ณ  ์‹ถ์„ ๋•Œ๋Š” ์–ด๋–ป๊ฒŒ ํ• ๊นŒ?

document.fullscreenEnabled๋ฅผ ์ฒดํฌํ•ด์„œ ํ™œ์„ฑ/๋น„ํ™œ์„ฑ์„ ๊ฒฐ์ •ํ•˜๋ฉด ๋˜๋Š”๋ฐ document is not defined์™€ ๊ฐ™์€ ์—๋Ÿฌ๋ฅผ ํ”ผํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” useEffect ๋‚ด๋ถ€์—์„œ ํ•ด๋‹น ์ž‘์—…์„ ์ฒ˜๋ฆฌํ•˜์—ฌ ๋ Œ๋”๋ง์ด ์™„๋ฃŒ๋œ ์‹œ์ ์— document์— ์ ‘๊ทผํ•˜๋„๋ก ํ•ด์•ผ ํ•œ๋‹ค.

for๋ฌธ์—์„œ setTimeout๊ณผ console ์‚ฌ์šฉํ•˜๊ธฐ(var,let)

for๋ฌธ์—์„œ setTimeout์„ ์˜๋„๋Œ€๋กœ ์‚ฌ์šฉํ•˜๊ธฐ

๋‹ค์Œ ๋‘ ์‹คํ–‰๋ฌธ์€ ๊ฐ๊ฐ ๋ณ€์ˆ˜๋กœ let๊ณผ var๋ฅผ ์‚ฌ์šฉํ•œ ์ ์ด ๋‹ค๋ฆ…๋‹ˆ๋‹ค. ๊ทธ๋ ‡๋‹ค๋ฉด ์ถœ๋ ฅ๋˜๋Š” ๊ฒฐ๊ณผ๋Š” ์–ด๋–จ๊นŒ์š”?

for (let i=0; i<5; i++){
  setTimeout(()=>{console.log(i)},1000);
} // 0, 1, 2, 3, 4

for(var i=0; i<5; i++){
  setTimeout(()=>{console.log(i)},1000);
} // 5, 5, 5, 5, 5

let์„ ์‚ฌ์šฉํ•˜๋ฉด 0, 1, 2, 3, 4๊ฐ€ ์•ฝ 1์ดˆ ๋’ค ํ•œ๋ฒˆ์— ์ถœ๋ ฅ๋˜๋Š” ๊ฒƒ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ๊ณ  var๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด 5๊ฐ€ ๋‹ค์„ฏ ๋ฒˆ ์ถœ๋ ฅ๋˜๋Š” ๊ฒƒ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์šฐ์„  var๋Š” ์™œ 5๋ฅผ ๋‹ค์„ฏ ๋ฒˆ ์ถœ๋ ฅํ• ๊นŒ์š”?

์ด๋Š” ์ด๋ฒคํŠธ ๋ฃจํ”„์˜ ์ฒ˜๋ฆฌ์— ๋”ฐ๋ผ setTimeout ๋ฉ”์„œ๋“œ๊ฐ€ ํ˜ธ์ถœ ์Šคํƒ์—์„œ ๋ฐฑ๊ทธ๋ผ์šด๋“œ๋ฅผ ๊ฑฐ์ณ ํƒœ์Šคํฌ ํ๋กœ ์ด๋™ํ–ˆ๋‹ค๊ฐ€ ๋‹ค์‹œ ์ฝœ ์Šคํƒ์œผ๋กœ ๋Œ์•„์˜ค๋Š” ๋™์•ˆ for ๋ฌธ์ด ๋ชจ๋‘ ์ข…๋ฃŒ(์ฝœ ์Šคํƒ์ด ๋น„์–ด ์žˆ์–ด์•ผ ํƒœ์Šคํฌ ํ์—์„œ ์ฝœ ์Šคํƒ์œผ๋กœ ์ด๋™)๋˜์–ด ์ถœ๋ ฅํ•  ๋ฐ์ดํ„ฐ๋Š” i=5์ธ ํด๋กœ์ €๋ฅผ ์ฐธ์กฐํ•˜๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.

๊ทธ๋ ‡๋‹ค๋ฉด var์™€ ๋‹ฌ๋ฆฌ let์€ ์™œ ์ˆœ์„œ๋Œ€๋กœ ์ˆซ์ž๊ฐ€ ์ถœ๋ ฅ๋ ๊นŒ์š”?

์ด๋Š” ์Šค์ฝ”ํ”„์™€ ๊ด€๋ จ์ด ์žˆ์Šต๋‹ˆ๋‹ค.

var๋Š” ํ•จ์ˆ˜ ์Šค์ฝ”ํ”„๋ฅผ ๊ฐ€์ง€๋ฏ€๋กœ for ๋ฃจํ”„๋งˆ๋‹ค ๊ฐ™์€ ์ฐธ์กฐ๋ฅผ ๋ฐ”์ธ๋”ฉํ•˜๊ณ  let์€ ๋ธ”๋ก ์Šค์ฝ”ํ”„์ด๋ฏ€๋กœ for ๋ฃจํ”„๋งˆ๋‹ค ์ƒˆ๋กœ์šด ์ฐธ์กฐ๋ฅผ ๋ฐ”์ธ๋”ฉํ•˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

๊ทธ๋ ‡๋‹ค๋ฉด var๋ฅผ ์‚ฌ์šฉํ•˜๋”๋ผ๋„ for ๋ฃจํ”„๋งˆ๋‹ค ์ƒˆ๋กœ์šด ์ฐธ์กฐ๋ฅผ ๋ฐ”์ธ๋”ฉํ•˜๋ฉด ๊ฒฐ๊ณผ๊ฐ€ ๋‹ฌ๋ผ์ง€์ง€ ์•Š์„๊นŒ์š”?

for(var i=0; i<5; i++){
  setTimeout(console.log.bind(console,i), 1000);
}

for(var i=0; i<5; i++){
  setTimeout(console.log, 1000,i);
}

๋˜๋Š” ์ฆ‰์‹œ์‹คํ–‰ํ•จ์ˆ˜(IIFE)์‚ฌ์šฉํ•ด๋„ ๋ฉ๋‹ˆ๋‹ค.

for (var i=0; i<5; i++) {
  (i => setTimeout(() => console.log(i), 1000))(i);
}

๊ทธ๋Ÿฌ๋‚˜ var๋Š” ์ด์ œ ์‚ฌ์šฉ์„ ๊ถŒ์žฅํ•˜์ง€ ์•Š์œผ๋ฉฐ let์œผ๋กœ ๊ฐ™์€ ํšจ๊ณผ๋ฅผ ๋‚ผ ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ ๊ตฌ์กฐ์™€ ์ž‘๋™ ์›๋ฆฌ ์ฐจ์›์—์„œ๋งŒ ์•Œ์•„๋‘๋ฉด ์ข‹์„ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.


๊ทธ๋ ‡๋‹ค๋ฉด ์ž ์‹œ ์•ž์œผ๋กœ ๋Œ์•„๊ฐ€์„œ ์™œ setTimeout์€ ๋จผ ๊ธธ์„ ๋Œ์•„์„œ ์‹คํ–‰๋˜๋Š” ๊ฑธ๊นŒ์š”?

์ด๋ฒคํŠธ ๋ฃจํ”„๊ฐ€ ๋น„๋™๊ธฐ๋‚˜ ์ฝœ๋ฐฑ ํ•จ์ˆ˜๋ฅผ ๋ชจ๋‘ ๋ฐฑ๊ทธ๋ผ์šด๋“œ๋กœ ์ „๋‹ฌํ•˜์—ฌ ์ž‘์—… ํšจ์œจ์„ ๋†’์ด๋ ค๊ณ  ํ•˜๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.

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

for (let i=0; i<3; i++){
  console.log('start');
  setTimeout(()=>{console.log(i)},0);
  console.log('end');
}

์ด์ฒ˜๋Ÿผ setTimeout์— 0์ดˆ๋ฅผ ์„ค์ •ํ•ด๋„ ์ž‘์—…์ด ๋’ค๋กœ ๋ฐ€๋ฆฌ๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค(0์ด๋ผ๊ณ  ํ•ด๋„ ์‹ค์ œ๋กœ๋Š” 4ms ์†Œ์š”).

๊ทธ๋Ÿผ i์ดˆ๋งˆ๋‹ค i๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ ์ƒ์„ฑํ•ด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

//for ๋ฌธ ์‚ฌ์šฉ
for (let i=0; i<5; i++) {
  setTimeout(() => console.log(i), i*1000);
}

// async, await ์‚ฌ์šฉ
const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
(async function loop() {
    for (let i=0; i<5; i++) {
        await delay(1000);
        console.log(i);
    }
})();

//promise ์‚ฌ์šฉ
for(let i=0; i<5; i++){
   new Promise((resolve, reject)=>{
      setTimeout(()=>{     
       	resolve(i);
      }, i*1000);
   }).then((data)=>{
      console.log(data);
   })
}

์˜ต์…”๋„ ์ฒด์ด๋‹(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๋Š” ์ดˆ๊ธฐ๊ฐ’์„ ํ†ตํ•ด ๋‹ค์–‘ํ•œ ๋กœ์ง์˜ ๊ตฌํ˜„์ด ๊ฐ€๋Šฅํ•ด ๋‹ค์žฌ๋‹ค๋Šฅํ•œ ๋ฉ”์„œ๋“œ์ธ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.

์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ ๋ฐฐ์—ด+๋ฐ˜๋ณต๋ฌธ์˜ ์†๋„ ํ…Œ์ŠคํŠธ(map, for, while, for…in, for…of)

๋ฐ˜๋ณต๋ฌธ์˜ ๋ฐฐ์—ด ์ž‘์—… ์†๋„๋ฅผ ํ™•์ธํ•˜๊ธฐ

๋ฐฐ์—ด ๊ด€๋ จํ•˜์—ฌ ๊ฐ ์š”์†Œ๋ณ„๋กœ ์ˆœํšŒํ•˜๋Š” ๋ฐ˜๋ณต๋ฌธ ์ž‘์—…์„ ํ•  ๋•Œ ๊ฐ€์žฅ ์ต์ˆ™ํ•œ ๋ฐฉ๋ฒ•์„ ์‚ฌ์šฉํ•˜๊ฑฐ๋‚˜ ๋•Œ๋กœ๋Š” ๊ฐ€์žฅ ๋จผ์ € ๋– ์˜ค๋ฅด๋Š” ๋ฐฉ๋ฒ•์„ ์‚ฌ์šฉํ•˜๊ธฐ๋„ ํ•ฉ๋‹ˆ๋‹ค.

๋ฐฐ์—ด์˜ ํฌ๊ธฐ๊ฐ€ ์ž‘์œผ๋ฉด ์ƒ๊ด€์ด ์—†์ง€๋งŒ ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๊ฐ€ ์ปค์ง€๋ฉด ์ž‘์€ ์ฐจ์ด๊ฐ€ ํฐ ์ฐจ์ด๋ฅผ ๋งŒ๋“ค์–ด๋‚ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋ฌธ๋“ ์—ฐ์‚ฐ ์†๋„๊ฐ€ ๊ฐ€์žฅ ๋น ๋ฅธ ๋ฐ˜๋ณต๋ฌธ์ด ๋ฌด์—‡์ผ๊นŒ๋ผ๋Š” ๊ถ๊ธˆ์ฆ์ด ์ƒ๊ฒจ ๊ฐ„๋‹จํ•˜๊ฒŒ ํ•˜๋‚˜์˜ ๋ฐฐ์—ด ๋ฐ์ดํ„ฐ๋ฅผ ๋‹ค๋ฅธ ๋ฐฐ์—ด๋กœ ์˜ฎ๊ธฐ๋Š” ์—ฐ์‚ฐ์„ ํ†ตํ•ด ์†๋„๋ฅผ ํ…Œ์ŠคํŠธํ•ด๋ณด๊ณ ์ž ํ•ฉ๋‹ˆ๋‹ค.

ํฌ๊ธฐ์— ์ƒ๊ด€์—†์ด ๋ฐ˜๋ณต๋ฌธ ๋ณ„๋กœ ๊ฐ™์€ ํšจ์œจ์„ ๋ณด์—ฌ์ฃผ๋ฆฌ๋ผ ์ƒ๊ฐํ–ˆ์ง€๋งŒ ๋ฐฐ์—ด์˜ ํฌ๊ธฐ์— ๋”ฐ๋ผ ๊ฐ๊ฐ ๋‹ค๋ฅธ ์†๋„๋ฅผ ๋ณด์—ฌ์ฃผ๋Š” ์ ์ด ํฅ๋ฏธ๋กœ์› ์Šต๋‹ˆ๋‹ค.


1. ํ…Œ์ŠคํŠธ ๋ฐฉ๋ฒ•

๋จผ์ € ์ผ์ • ํฌ๊ธฐ๋ฅผ ๊ฐ–๋Š” ๋ฐฐ์—ด array์„ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค.

console.time ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉํ•ด ์ด ๋ฐฐ์—ด์˜ ๋ฐ์ดํ„ฐ๋ฅผ ๋‹ค๋ฅธ ๋ฐฐ์—ด๋กœ ๋ณต์‚ฌํ•˜๋Š” ์ž‘์—…์„ ์ง„ํ–‰ํ•˜๊ณ  ์ด ์ž‘์—… ์‹œ๊ฐ„์„ ์ธก์ •ํ•ฉ๋‹ˆ๋‹ค.

ํ…Œ์ŠคํŠธ๋Š” map, for, while, for…in, for…of์˜ ๋‹ค์„ฏ ๊ฐ€์ง€ ๋ฐ˜๋ณต๋ฌธ์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

// ๋ฐฐ์—ด ๋ฐ์ดํ„ฐ ์ƒ์„ฑ
const array = [];
for(let i=0;i<10000;i++){
  array.push(i);
}

// ๋ฐ์ดํ„ฐ๊ฐ€ ๋ณต์‚ฌ๋  ๋ฐฐ์—ด
let arraymap = [];

console.time('map');  //ํƒ€์ด๋จธ ์‹œ์ž‘
arraymap = array.map(list=>list);
console.timeEnd('map'); //ํƒ€์ด๋จธ ์ข…๋ฃŒ

์œ„์™€ ๊ฐ™์€ ๋ฐฉ์‹์œผ๋กœ 3ํšŒ์”ฉ ํ…Œ์ŠคํŠธ๋ฅผ ์ง„ํ–‰ํ•˜๋ฉฐ ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๋ฅผ ์กฐ์ ˆํ•˜์—ฌ ๋ฐ˜๋ณต๋ฌธ ๋ณ„๋กœ ์ƒ๋Œ€์ ์ธ ์ž‘์—… ์†๋„์˜ ๋ณ€ํ™”๋ฅผ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.


2. ํ…Œ์ŠคํŠธ

๋จผ์ € ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๊ฐ€ ์•„์ฃผ ์ž‘์„ ๋•Œ๋Š” ๋ชจ๋‘ ํฐ ์ฐจ์ด๋ฅผ ๋ณด์ด์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

๋‹ค์Œ์€ ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๊ฐ€ 100์ผ ๋•Œ ๊ฒฐ๊ณผ์ž…๋‹ˆ๋‹ค.

์ž‘์—…์„ ์„ธ ๋ฒˆ ์ง„ํ–‰ํ•œ ๊ฒฐ๊ณผ map๊ณผ for…of๊ฐ€ ์—Ž์น˜๋ฝ๋’ค์น˜๋ฝํ•˜์ง€๋งŒ ํ•ญ์ƒ ๊ฐ€์žฅ ๋น ๋ฅธ ์†๋„๋ฅผ ๋ณด์—ฌ์ค๋‹ˆ๋‹ค.

for, while, for…in๋„ ์„ธ๋ฒˆ ๋ชจ๋‘ ๊ฒฐ๊ณผ๊ฐ€ ์—Ž์น˜๋ฝ๋’ค์น˜๋ฝํ•˜์ง€๋งŒ ์œ„์˜ ๋‘ ๋ฐ˜๋ณต๋ฌธ๋ณด๋‹จ ๋Š๋ฆฐ ์†๋„๋ฅผ ๋ณด์—ฌ์ค๋‹ˆ๋‹ค.

๊ทธ๋Ÿผ ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๋ฅผ 1000์œผ๋กœ ์˜ฌ๋ ค๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

ํฌ๊ธฐ๊ฐ€ 1000์ผ ๋•Œ๋Š” ๋Œ€์ฒด์ ์œผ๋กœ ๋น„์Šทํ•œ ์†๋„๋ฅผ ๋ณด์—ฌ์ค๋‹ˆ๋‹ค.

for…in๋งŒ ๋‹ค๋ฅธ ๋ฐ˜๋ณต๋ฌธ๋ณด๋‹ค ๋Š๋ฆฐ ๊ฒƒ์ด ํ™•์ธ๋ฉ๋‹ˆ๋‹ค.

์ด์ œ ํ™•์—ฐํ•˜๊ฒŒ ์œ ์˜๋ฏธํ•œ ์ฐจ์ด๋ฅผ ๋Š๋‚„ ์ˆ˜ ์žˆ๋Š” ํฌ๊ธฐ์ธ 10000์œผ๋กœ ์˜ฌ๋ ค๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

10000์—์„œ๋Š” map์ด ๊ฐ€์žฅ ์šฐ์ˆ˜ํ•œ ์†๋„๋ฅผ ๋ณด์—ฌ์ค๋‹ˆ๋‹ค.

๋ˆˆ์— ๋„๋Š” ๋ถ€๋ถ„์€ ์ž‘์€ ์‚ฌ์ด์ฆˆ์—์„œ๋Š” map๊ณผ ๋Œ€๋“ฑํ•œ ์†๋„๋ฅผ ๋ณด์ด๋˜ for…of๊ฐ€ ์—ฌ๊ธฐ์„œ๋Š” ๊ฐ€์žฅ ๋Š๋ฆฐ ์†๋„๋ฅผ ๊ธฐ๋กํ•ฉ๋‹ˆ๋‹ค.

๋˜ํ•œ for…in์€ ์˜คํžˆ๋ ค for…of๋ณด๋‹ค ๋น ๋ฅธ ์†๋„๋ฅผ ๋ณด์—ฌ์ค๋‹ˆ๋‹ค.

๊ทธ๋Ÿผ 1000000์œผ๋กœ ํ™•์ธํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

๋ฐฐ์—ด์ด ๋งค์šฐ ์ปค์ง€๋‹ˆ ์ž‘์—… ์†๋„๋Š” for๋ฌธ์ด ๊ฐ€์žฅ ์ค€์ˆ˜ํ•ฉ๋‹ˆ๋‹ค.

map, while๋„ ํฐ ์ฐจ์ด๋ฅผ ๋ณด์ด์ง€ ์•Š๊ณ  ์ค€์ˆ˜ํ•œ ์„ฑ๋Šฅ์„ ๋ณด์—ฌ์ค๋‹ˆ๋‹ค.

for…of๋Š” ํ™•์—ฐํ•˜๊ฒŒ ์กฐ๊ธˆ ๋Š๋ฆฐ ์†๋„๋ฅผ ๋ณด์—ฌ์ฃผ๊ณ  for…in์€ ์ด์ œ ์ธ์‚ฌ๋ฅผ ํ•ด์•ผํ•  ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๊ทธ๋Ÿผ ๋งˆ์ง€๋ง‰์œผ๋กœ 10000000(์ฒœ๋งŒ)์œผ๋กœ ํ…Œ์ŠคํŠธ๋ฅผ ํ•ด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

์„ธ ๋ฒˆ ํ…Œ์ŠคํŠธํ•œ ๊ฒฐ๊ณผ ๋ชจ๋‘ for ๋ฌธ์ด ๊ฐ€์žฅ ๋น ๋ฅธ ์†๋„๋ฅผ ๋ณด์—ฌ์ฃผ์—ˆ์œผ๋ฉฐ, map, while๋„ ์˜๋ฏธ์žˆ๋Š” ์†๋„๋ฅผ ๋ณด์—ฌ์ค๋‹ˆ๋‹ค.

ํ™•์‹คํžˆ for…of๋Š” ์œ„์˜ ์„ธ ๋ฐ˜๋ณต๋ฌธ๋ณด๋‹ค ๋Š๋ฆฐ ์†๋„๋ฅผ ๋ณด์—ฌ์ฃผ์—ˆ์œผ๋ฉฐ for…in์€ 10๋ฐฐ๊ฐ€ ๋„˜๋Š” ๋Š๋ฆฐ ์†๋„์˜ ์ฐจ์ด๋ฅผ ๋ณด์—ฌ์ค๋‹ˆ๋‹ค.


3. ๊ฒฐ๊ณผ ์ •๋ฆฌ

๋ฐฐ์—ด ํ…Œ์ดํ„ฐ์˜ ํฌ๊ธฐ๊ฐ€ ์ž‘์„ ๋•Œ๋Š” ์˜๋ฏธ์žˆ๋Š” ์ฐจ์ด๊ฐ€ ์—†์ง€๋งŒ ๋ฐฐ์—ด์ด ์ปค์งˆ์ˆ˜๋ก map, for, while์˜ ์†๋„๊ฐ€ ์šฐ์ˆ˜ํ•˜๊ณ  for…in, for…of๋Š” ์†๋„ ์ €ํ•˜๋ฅผ ๋ณด์ด๋Š” ๊ฒฐ๊ณผ๋ฅผ ๋‚˜ํƒ€๋ƒ…๋‹ˆ๋‹ค.

์–ด๋””๊นŒ์ง€๋‚˜ ๋‹จ์ˆœํ•œ ์ž‘์—…์ธ ๋ฐฐ์—ด ๋ฐ์ดํ„ฐ ๋ณต์‚ฌ ๊ธฐ๋Šฅ๋งŒ์„ ์‚ฌ์šฉํ•œ ํ…Œ์ŠคํŠธ์ด๋ฏ€๋กœ ์ž‘์—… ๋‚ด์šฉ์— ๋”ฐ๋ผ ๋‹ค๋ฅธ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์ผ ๊ฐ€๋Šฅ์„ฑ์ด ์žˆ์–ด ๋‹จ์ˆœ ์ฐธ๊ณ ์šฉ์œผ๋กœ ์‚ผ์œผ๋ฉด ์ข‹์„ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๋‹ค์Œ์€ ํ…Œ์ŠคํŠธ์— ์‚ฌ์šฉํ•œ ์ฝ”๋“œ ์ „์ฒด์ž…๋‹ˆ๋‹ค.

console.log('-------------start----------------')

const array = [];

for(let i=0;i<10000;i++){  //ํฌ๊ธฐ ๋ณ€๊ฒฝ
	array.push(i);
}

console.log("arraysize:"+array.length);
console.log('--------------------------------');

let arraymap = [];

console.log('arraymap start:'+arraymap.length);
console.time('map');

arraymap = array.map(list=>list);

console.log('arraymap end:'+arraymap.length);
console.timeEnd('map');
console.log('--------------------------------');


let arrayfor = [];
console.log('arrayfor start:'+arrayfor.length);
console.time('for');

for(let i=0; i<array.length;i++){
	arrayfor.push(array[i]);
};

console.log('arrayfor end:'+arrayfor.length);
console.timeEnd('for');
console.log('--------------------------------');

let arraywhile = [];
let whilenum = 0;
console.log('arraywhile start:'+arraywhile.length);
console.time('while');

while(whilenum<array.length){
	arraywhile.push(array[whilenum]);
	whilenum++;
};

console.log('arraywhile end:'+arraywhile.length);
console.timeEnd('while');
console.log('--------------------------------');

const arrayforof = [];
console.log('arrayforof start:'+arrayforof.length);
console.time('forof');

for(const num of array){
	arrayforof.push(num)
};

console.log('arrayfor end:'+arrayforof.length);
console.timeEnd('forof');
console.log('--------------------------------');

let arrayforin = [];
console.log('arrayforin start:'+arrayforin.length);
console.time('forin');

for(const num in array){
	arrayforin.push(array[num]);
};

console.log('arrayforin end:'+arrayforin.length);
console.timeEnd('forin');


console.log('---------------end-----------------');

OnKeyPress๋Š” ์™œ ESC๊ฐ€ ์ธ์‹์ด ์•ˆ๋ ๊นŒ?(React.ํ‚ค ์ด๋ฒคํŠธ ์ฒ˜๋ฆฌ)

Key ์ž…๋ ฅ์„ ์ฒ˜๋ฆฌํ•˜๋Š” ์†์„ฑ

๋ฆฌ์•กํŠธ input์—์„œ ํ‚ค ์ž…๋ ฅ ์ด๋ฒคํŠธ๋ฅผ ์ฒ˜๋ฆฌํ•  ๋•Œ onKeyPress, onKeyDown, onKeyUp ์ด๋ฒคํŠธ๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ์™€ ๊ฐ™์€ ๋ช…์นญ์˜ ์†์„ฑ๋“ค์„ ๋ฆฌ์•กํŠธ๋Š” camel case๋กœ ํ‘œ๊ธฐํ•ฉ๋‹ˆ๋‹ค.

๋‹ค์Œ๊ณผ ๊ฐ™์ด ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

const onKeyPress= e => {
    if(e.key==='Enter'){    
        findExecute();
    }   
}

........

<div onKeyPress={onKeyPress}>click</div>

์ด๋ฒคํŠธ๊ฐ€ ๋ฐœ์ƒํ•˜๋Š” ์‹œ์ ์ด ์กฐ๊ธˆ์”ฉ ๋‹ค๋ฅผ ๋ฟ ์‚ฌ์šฉ ๋ฐฉ๋ฒ•์€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๊ทธ๋ฆฌ๊ณ  ๊ฐ ์ด๋ฒคํŠธ ๋ณ„ ํŠน์ง•์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

onKeyDown ๐Ÿ‘‰ ์ด๋ฒคํŠธ๊ฐ€ ๋จผ์ € ์‹คํ–‰
onKeyUp ๐Ÿ‘‰ text๊ฐ€ ์ž…๋ ฅ๋˜๋ฉด ์‹คํ–‰
onKeyPress ๐Ÿ‘‰ text ์ž…๋ ฅ์ด ์™„๋ฃŒ๋˜๋ฉด ์‹คํ–‰ (Deprecated)

MDN์˜ ๊ณต์‹ ๋ฌธ์„œ๋ฅผ ๋ณด๋ฉด ์ด์ œ onKeyPress๋Š” ๋” ์ด์ƒ ์‚ฌ์šฉ๋˜์ง€ ์•Š๋Š”๋‹ค๊ณ  ํ•˜๋‹ˆ ๊ฑฐ์˜ ๋น„์Šทํ•˜๊ฒŒ ๋™์ž‘ํ•˜๋Š” onKeyDown์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค.

MDN – keypress event


์™œ onKeyPress์—์„œ ESC๊ฐ€ ๋™์ž‘ํ•˜์ง€ ์•Š์„๊นŒ?

onKeyPress๋Š” ๊ธฐ๋ณธ์ ์œผ๋กœ ESC๊ฐ€ ๋ˆŒ๋ ค์กŒ์„ ๋•Œ ์ด๋ฒคํŠธ๊ฐ€ ์ƒ์„ฑ๋˜์ง€ ์•Š๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.

onKeyPress๋Š” ESC, CTRL, ALT ๋“ฑ function ๊ธฐ๋Šฅ์„ ๊ฐ–๋Š” ํ‚ค๋ฅผ ์ œ์™ธํ•˜๊ณ  ์•ŒํŒŒ๋ฒณ๊ณผ ์ˆซ์ž ํ‚ค์—์„œ๋งŒ ์ด๋ฒคํŠธ๊ฐ€ ์ƒ์„ฑ๋ฉ๋‹ˆ๋‹ค.

ํ•˜์ง€๋งŒ onKeyDown, onKeyUp์€ onKeyPress์—์„œ ์ธ์‹๋˜์ง€ ๊ธฐ๋Šฅ ํ‚ค๋“ค๋„ ์ธ์‹์ด ๋ฉ๋‹ˆ๋‹ค.

๋˜ํ•œ onKeyPress๋Š” ์ด์ œ ๋” ์ด์ƒ ์ง€์›๋˜์ง€ ์•Š๋Š”๋‹ค๊ณ  ํ•˜๋‹ˆ ๊ธฐ๋ณธ์ ์œผ๋กœ๋Š” onKeyDown์„ ์‚ฌ์šฉํ•˜๊ณ  ์ƒํ™ฉ์— ๋”ฐ๋ผ onKeyUp์„ ์‚ฌ์šฉํ•˜๋ฉด ํฐ ๋ฌธ์ œ ์—†์ด ์›ํ•˜๋Š” ๋ฐฉ์‹์œผ๋กœ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๊ฐ ํ‚ค ๊ฐ’๊ณผ ์ด์Šˆ ๊ด€๋ จ ํŽ˜์ด์ง€๋ฅผ ๋งํฌ๋กœ ๋‚จ๊ธฐ๊ฒ ์Šต๋‹ˆ๋‹ค.


ํ‚ค ์ฝ”๋“œ๋ฅผ ์ง์ ‘ ์ž…๋ ฅํ•ด๋ณด๋ฉด์„œ ์•Œ ์ˆ˜ ์žˆ๋Š” ์‚ฌ์ดํŠธ -> https://keycode.info/

๊ด€๋ จ ์ด์Šˆ -> https://github.com/Leaflet/Leaflet/issues/5234

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)๋ฅผ ์ฝ˜์†”์— ์ถœ๋ ฅํ•˜๋ฉด ๋‹ค์–‘ํ•œ ํ•˜์œ„ ์†์„ฑ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ ์›ํ•˜๋Š” ์†์„ฑ์„ ์ฐพ๊ฑฐ๋‚˜ ์—๋Ÿฌ๋ฅผ ํ•ด๊ฒฐํ•  ๋•Œ ์œ ์šฉํ•˜๊ฒŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.