๋Œ€๋ถ€๋ถ„์˜ ํŠœํ† ๋ฆฌ์–ผ์—์„œ ๋†“์น˜๋Š” 12๊ฐ€์ง€ JavaScript ํŠธ๋ฆญ

๋Œ€๋ถ€๋ถ„์˜ ํŠœํ† ๋ฆฌ์–ผ์—์„œ ๋†“์น˜๋Š” 12๊ฐ€์ง€ JavaScript ํŠธ๋ฆญ

JavaScript๋ฅผ ๋ฐฐ์šฐ๊ธฐ ์‹œ์ž‘ํ–ˆ์„ ๋•Œ ์ œ๊ฐ€ ๊ฐ€์žฅ ๋จผ์ € ํ•œ ์ผ์€ ์‹œ๊ฐ„์„ ์ ˆ์•ฝํ•˜๋Š” ๋ฐ ๋„์›€์ด ๋˜๋Š” ์š”๋ น ๋ชฉ๋ก์„ ๋งŒ๋“œ๋Š” ๊ฒƒ์ด์—ˆ์Šต๋‹ˆ๋‹ค. ๋‚˜๋Š” ๋‹ค๋ฅธ ํ”„๋กœ๊ทธ๋ž˜๋จธ, ๋‹ค๋ฅธ ์‚ฌ์ดํŠธ, ๋งค๋‰ด์–ผ์—์„œ ๊ทธ๊ฒƒ๋“ค์„ ๋ฐœ๊ฒฌํ–ˆ์Šต๋‹ˆ๋‹ค.

์ด ๊ธฐ์‚ฌ์—์„œ๋Š” JavaScript ์ฝ”๋“œ๋ฅผ ๊ฐœ์„ ํ•˜๊ณ  ์†๋„๋ฅผ ๋†’์ด๋Š” 12๊ฐ€์ง€ ์ข‹์€ ๋ฐฉ๋ฒ•์„ ๋ณด์—ฌ ๋“œ๋ฆฌ๊ฒ ์Šต๋‹ˆ๋‹ค. ๋Œ€๋ถ€๋ถ„์˜ ๊ฒฝ์šฐ ๋ณดํŽธ์ ์ž…๋‹ˆ๋‹ค.

์•Œ๋ฆผ: "Habr"์˜ ๋ชจ๋“  ๋…์ž๋ฅผ ์œ„ํ•œ - "Habr" ํ”„๋กœ๋ชจ์…˜ ์ฝ”๋“œ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ Skillbox ๊ณผ์ •์— ๋“ฑ๋กํ•  ๋•Œ 10 ๋ฃจ๋ธ” ํ• ์ธ.

Skillbox๋Š” ๋‹ค์Œ์„ ๊ถŒ์žฅํ•ฉ๋‹ˆ๋‹ค. ์‹ค๊ธฐ ์ฝ”์Šค "๋ชจ๋ฐ”์ผ ๊ฐœ๋ฐœ์ž PRO".

๊ณ ์œ  ๊ฐ’ ํ•„ํ„ฐ๋ง

๋ฐฐ์—ด

Set ๊ฐ์ฒด ์œ ํ˜•์€ ..., ์Šคํ”„๋ ˆ๋“œ ์—ฐ์‚ฐ์ž์™€ ํ•จ๊ป˜ ES6์—์„œ ๋„์ž…๋˜์—ˆ์œผ๋ฉฐ, ์ด๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๊ณ ์œ ํ•œ ๊ฐ’๋งŒ ํฌํ•จํ•˜๋Š” ์ƒˆ ๋ฐฐ์—ด์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

const array = [1, 1, 2, 3, 5, 5, 1]
const uniqueArray = [...new Set(array)];
 
console.log(uniqueArray); // Result: [1, 2, 3, 5]

์ผ๋ฐ˜์ ์ธ ์ƒํ™ฉ์—์„œ๋Š” ๋™์ผํ•œ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๋ ค๋ฉด ํ›จ์”ฌ ๋” ๋งŽ์€ ์ฝ”๋“œ๊ฐ€ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค.

์ด ๊ธฐ์ˆ ์€ ์ •์˜๋˜์ง€ ์•Š์Œ, null, ๋ถ€์šธ, ๋ฌธ์ž์—ด ๋ฐ ์ˆซ์ž์™€ ๊ฐ™์€ ๊ธฐ๋ณธ ์œ ํ˜•์„ ํฌํ•จํ•˜๋Š” ๋ฐฐ์—ด์— ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค. ๊ฐ์ฒด, ํ•จ์ˆ˜ ๋˜๋Š” ์ถ”๊ฐ€ ๋ฐฐ์—ด์ด ํฌํ•จ๋œ ๋ฐฐ์—ด๋กœ ์ž‘์—…ํ•˜๋Š” ๊ฒฝ์šฐ ๋‹ค๋ฅธ ์ ‘๊ทผ ๋ฐฉ์‹์ด ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค.

์ฃผ๊ธฐ ๋‹จ์œ„์˜ ์บ์‹œ ๋ฐฐ์—ด ๊ธธ์ด

์‚ฌ์ดํด

for ๋ฃจํ”„๋ฅผ ๋ฐฐ์šธ ๋•Œ๋Š” ํ‘œ์ค€ ์ ˆ์ฐจ๋ฅผ ๋”ฐ๋ฆ…๋‹ˆ๋‹ค.

for (let i = 0; i < array.length; i++){
  console.log(i);
}

๊ทธ๋Ÿฌ๋‚˜ ์ด ๊ตฌ๋ฌธ์„ ์‚ฌ์šฉํ•˜๋ฉด for ๋ฃจํ”„๋Š” ๋ฐ˜๋ณตํ•  ๋•Œ๋งˆ๋‹ค ๋ฐฐ์—ด์˜ ๊ธธ์ด๋ฅผ ๋ฐ˜๋ณต์ ์œผ๋กœ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.

๋•Œ๋กœ๋Š” ์ด๊ฒƒ์ด ์œ ์šฉํ•  ์ˆ˜ ์žˆ์ง€๋งŒ ๋Œ€๋ถ€๋ถ„์˜ ๊ฒฝ์šฐ ํ•œ ๋ฒˆ์˜ ์•ก์„ธ์Šค๊ฐ€ ํ•„์š”ํ•œ ๋ฐฐ์—ด์˜ ๊ธธ์ด๋ฅผ ์บ์‹œํ•˜๋Š” ๊ฒƒ์ด ๋” ํšจ์œจ์ ์ž…๋‹ˆ๋‹ค. ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๋ณ€์ˆ˜ i๋ฅผ ์ •์˜ํ•˜๋Š” ๊ณณ์— ๊ธธ์ด ๋ณ€์ˆ˜๋ฅผ ์ •์˜ํ•˜์—ฌ ์ด๋ฅผ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

for (let i = 0, length = array.length; i < length; i++){
  console.log(i);
}

์›์น™์ ์œผ๋กœ ์œ„์™€ ๊ฑฐ์˜ ๋™์ผํ•˜์ง€๋งŒ ๋ฃจํ”„ ํฌ๊ธฐ๋ฅผ ๋Š˜๋ฆฌ๋ฉด ์‹œ๊ฐ„์ด ํฌ๊ฒŒ ์ ˆ์•ฝ๋ฉ๋‹ˆ๋‹ค.

๋‹จ๋ฝ ์ •๊ฒฉ(๋งค์นด์‹œ ์ •๊ฒฉ)

์กฐ๊ฑด๋ถ€ ์—ฐ์‚ฐ์ž

์‚ผํ•ญ ์—ฐ์‚ฐ์ž๋Š” ๊ฐ„๋‹จํ•œ(๋•Œ๋กœ๋Š” ๊ทธ๋‹ค์ง€ ๋‹จ์ˆœํ•˜์ง€ ์•Š์€) ์กฐ๊ฑด๋ฌธ์„ ์ž‘์„ฑํ•˜๋Š” ๋น ๋ฅด๊ณ  ํšจ์œจ์ ์ธ ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค.

x> 100? "100 ์ดˆ๊ณผ": "100 ๋ฏธ๋งŒ";
x> 100? (x>200? "200 ์ดˆ๊ณผ": "100-200 ์‚ฌ์ด"): "100 ๋ฏธ๋งŒ";

๊ทธ๋Ÿฌ๋‚˜ ๋•Œ๋•Œ๋กœ ์‚ผํ•ญ ์—ฐ์‚ฐ์ž์กฐ์ฐจ ํ•„์š”ํ•œ ๊ฒƒ๋ณด๋‹ค ๋” ๋ณต์žกํ•ฉ๋‹ˆ๋‹ค. ๋Œ€์‹  'and' &&์™€ 'or'๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค || ๋”์šฑ ๊ฐ„๊ฒฐํ•œ ๋ฐฉ์‹์œผ๋กœ ํŠน์ • ํ‘œํ˜„์‹์„ ํ‰๊ฐ€ํ•˜๋Š” ๋ถ€์šธ ์—ฐ์‚ฐ์ž์ž…๋‹ˆ๋‹ค. ์ข…์ข… "๋‹จ๋ฝ" ๋˜๋Š” "๋‹จ๋ฝ ์ •๊ฒฉ"์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค.

์ด๊ฑฐ ์–ด๋–ป๊ฒŒ ์ž‘๋™ ์‹œ์ผœ์š”

๋‘ ๊ฐœ ์ด์ƒ์˜ ์กฐ๊ฑด โ€‹โ€‹์ค‘ ํ•˜๋‚˜๋งŒ ๋ฐ˜ํ™˜ํ•˜๊ณ  ์‹ถ๋‹ค๊ณ  ๊ฐ€์ •ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

&&๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์ฒซ ๋ฒˆ์งธ ๊ฑฐ์ง“ ๊ฐ’์ด ๋ฐ˜ํ™˜๋ฉ๋‹ˆ๋‹ค. ๊ฐ ํ”ผ์—ฐ์‚ฐ์ž๊ฐ€ true๋กœ ํ‰๊ฐ€๋˜๋ฉด ๋งˆ์ง€๋ง‰์œผ๋กœ ํ‰๊ฐ€๋œ ํ‘œํ˜„์‹์ด ๋ฐ˜ํ™˜๋ฉ๋‹ˆ๋‹ค.

let one = 1, two = 2, three = 3;
console.log(one && two && three); // Result: 3
 
console.log(0 && null); // Result: 0

||๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ฒซ ๋ฒˆ์งธ ์ฐธ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ๊ฐ ํ”ผ์—ฐ์‚ฐ์ž๊ฐ€ false๋กœ ํ‰๊ฐ€๋˜๋ฉด ๋งˆ์ง€๋ง‰์œผ๋กœ ํ‰๊ฐ€๋œ ๊ฐ’์ด ๋ฐ˜ํ™˜๋ฉ๋‹ˆ๋‹ค.

let one = 1, two = 2, three = 3;
console.log(one || two || three); // Result: 1
 
console.log(0 || null); // Result: null

์˜ˆ๋ฅผ ๋“ค์–ด 1

๋ณ€์ˆ˜์˜ ๊ธธ์ด๋ฅผ ๋ฐ˜ํ™˜ํ•˜๊ณ  ์‹ถ์ง€๋งŒ ํ•ด๋‹น ์œ ํ˜•์„ ๋ชจ๋ฅธ๋‹ค๊ณ  ๊ฐ€์ •ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

์ด ๊ฒฝ์šฐ if/else๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ foo๊ฐ€ ์˜ฌ๋ฐ”๋ฅธ ์œ ํ˜•์ธ์ง€ ํ™•์ธํ•  ์ˆ˜ ์žˆ์ง€๋งŒ ์ด ๋ฐฉ๋ฒ•์€ ๋„ˆ๋ฌด ๊ธธ์–ด์งˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ "๋‹จ๋ฝ"์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค.

return (foo || []).length;

๋ณ€์ˆ˜ foo์˜ ๊ธธ์ด๊ฐ€ ์ ์ ˆํ•œ ๊ฒฝ์šฐ ํ•ด๋‹น ๊ธธ์ด๊ฐ€ ๋ฐ˜ํ™˜๋ฉ๋‹ˆ๋‹ค. ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด 0์„ ์–ป๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด 2

์ค‘์ฒฉ๋œ ๊ฐœ์ฒด์— ์•ก์„ธ์Šคํ•˜๋Š” ๋ฐ ๋ฌธ์ œ๊ฐ€ ์žˆ์—ˆ๋‚˜์š”? ๊ฐœ์ฒด ๋˜๋Š” ๊ฐœ์ฒด์˜ ํ•˜์œ„ ์†์„ฑ ์ค‘ ํ•˜๋‚˜๊ฐ€ ์กด์žฌํ•˜๋Š”์ง€ ์—ฌ๋ถ€๋ฅผ ์•Œ ์ˆ˜ ์—†์œผ๋ฉฐ ์ด๋กœ ์ธํ•ด ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด, this.state์˜ ๋ฐ์ดํ„ฐ ์†์„ฑ์— ์•ก์„ธ์Šคํ•˜๊ณ  ์‹ถ์—ˆ์ง€๋งŒ ํ”„๋กœ๊ทธ๋žจ์ด ๊ฐ€์ ธ์˜ค๊ธฐ ์š”์ฒญ์„ ๋ฐ˜ํ™˜ํ•  ๋•Œ๊นŒ์ง€ ๋ฐ์ดํ„ฐ๊ฐ€ ์ •์˜๋˜์ง€ ์•Š์•˜์Šต๋‹ˆ๋‹ค.

์‚ฌ์šฉ ์œ„์น˜์— ๋”ฐ๋ผ this.state.data๋ฅผ ํ˜ธ์ถœํ•˜๋ฉด ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์ด ์‹œ์ž‘๋˜์ง€ ์•Š์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๊ธฐ ์œ„ํ•ด ์ด๋ฅผ ์กฐ๊ฑด์‹์œผ๋กœ ๋ž˜ํ•‘ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

if (this.state.data) {
  return this.state.data;
} else {
  return 'Fetching Data';
}

๋” ๋‚˜์€ ์˜ต์…˜์€ "or" ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

return (this.state.data || 'Fetching Data');

&&๋ฅผ ์‚ฌ์šฉํ•˜๋„๋ก ์œ„์˜ ์ฝ”๋“œ๋ฅผ ๋ณ€๊ฒฝํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. '๋ฐ์ดํ„ฐ ๊ฐ€์ ธ์˜ค๊ธฐ' && this.state.data ์—ฐ์‚ฐ์ž๋Š” ์ •์˜๋˜์ง€ ์•Š์•˜๋Š”์ง€ ์—ฌ๋ถ€์— ๊ด€๊ณ„์—†์ด this.state.data๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

์˜ต์…˜ ์ฒด์ธ

ํŠธ๋ฆฌ ๊ตฌ์กฐ ๊นŠ์€ ๊ณณ์—์„œ ์†์„ฑ์„ ๋ฐ˜ํ™˜ํ•˜๋ ค๊ณ  ํ•  ๋•Œ ์„ ํƒ์  ์—ฐ๊ฒฐ์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿผ ๋ฌผ์Œํ‘œ ๊ธฐํ˜ธ๋Š”์š”? null์ด ์•„๋‹Œ ๊ฒฝ์šฐ์—๋งŒ ์†์„ฑ์„ ๊ฒ€์ƒ‰ํ•˜๋Š” ๋ฐ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด ์œ„์˜ ์˜ˆ์ œ๋ฅผ ๋ฆฌํŒฉํ„ฐ๋งํ•˜์—ฌ this.state.data?..()๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ฆ‰, ๊ฐ’์ด null์ด ์•„๋‹Œ ๊ฒฝ์šฐ์—๋งŒ ๋ฐ์ดํ„ฐ๊ฐ€ ๋ฐ˜ํ™˜๋ฉ๋‹ˆ๋‹ค.

๋˜๋Š” ์ƒํƒœ๊ฐ€ ์ •์˜๋˜์—ˆ๋Š”์ง€ ์—ฌ๋ถ€๊ฐ€ ์ค‘์š”ํ•œ ๊ฒฝ์šฐ this.state?.data๋ฅผ ๋ฐ˜ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋ถ€์šธ๋กœ ๋ณ€ํ™˜

์œ ํ˜• ๋ณ€ํ™˜

์ผ๋ฐ˜์ ์ธ ๋ถ€์šธ ํ•จ์ˆ˜์ธ true ๋ฐ false ์™ธ์—๋„ JavaScript๋Š” ๋‹ค๋ฅธ ๋ชจ๋“  ๊ฐ’๋„ true ๋˜๋Š” falsy๋กœ ์ฒ˜๋ฆฌํ•ฉ๋‹ˆ๋‹ค.

๋ณ„๋„๋กœ ๋ช…์‹œํ•˜์ง€ ์•Š๋Š” ํ•œ JavaScript์˜ ๋ชจ๋“  ๊ฐ’์€ 0, "", null, ์ •์˜๋˜์ง€ ์•Š์Œ, NaN ๋ฐ ๋ฌผ๋ก  false๋ฅผ ์ œ์™ธํ•˜๊ณ  ์ง„์‹ค์ž…๋‹ˆ๋‹ค. ํ›„์ž๋Š” ๊ฑฐ์ง“์ด๋‹ค.

์œ ํ˜•์„ ๋ถ€์šธ๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋‘˜ ์‚ฌ์ด๋ฅผ ์‰ฝ๊ฒŒ ์ „ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

const isTrue  = !0;
const isFalse = !1;
const alsoFalse = !!0;
 
console.log(true); // Result: true
console.log(typeof true); // Result: "boolean"

๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜

์œ ํ˜• ๋ณ€ํ™˜

์ •์ˆ˜์—์„œ ๋ฌธ์ž์—ด๋กœ์˜ ๋น ๋ฅธ ๋ณ€ํ™˜์€ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

const val = 1 + "";
 
console.log(val); // Result: "1"
console.log(typeof val); // Result: "string"

์ •์ˆ˜๋กœ ๋ณ€ํ™˜

์œ ํ˜• ๋ณ€ํ™˜

์ด์™€ ๊ฐ™์ด ์—ญ๋ณ€ํ™˜์„ ์ˆ˜ํ–‰ํ•ฉ๋‹ˆ๋‹ค.

let int = "15";
int = +int;
 
console.log(int); // Result: 15
console.log(typeof int); Result: "number"

์ด ๋ฐฉ๋ฒ•์€ ์•„๋ž˜์™€ ๊ฐ™์ด ๋ถ€์šธ ๋ฐ์ดํ„ฐ ์œ ํ˜•์„ ์ผ๋ฐ˜ ์ˆซ์ž ๊ฐ’์œผ๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ๋ฐ์—๋„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

console.log(+true);  // Return: 1
console.log(+false); // Return: 0

+๊ฐ€ ๋”ํ•˜๊ธฐ ์—ฐ์‚ฐ์ž๊ฐ€ ์•„๋‹Œ ์—ฐ๊ฒฐ ์—ฐ์‚ฐ์ž๋กœ ํ•ด์„๋˜๋Š” ์ƒํ™ฉ์ด ์žˆ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋ฅผ ๋ฐฉ์ง€ํ•˜๋ ค๋ฉด ๋ฌผ๊ฒฐํ‘œ๋ฅผ ์‚ฌ์šฉํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค: ~~. ์ด ์—ฐ์‚ฐ์ž๋Š” -n-1๊ณผ ๋™์ผํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด ~15๋Š” -16๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๋‘ ๊ฐœ์˜ ๋ฌผ๊ฒฐํ‘œ๋ฅผ ์—ฐ์†ํ•ด์„œ ์‚ฌ์šฉํ•˜๋ฉด - (- - n - 1) - 1 = n + 1 - 1 = n์ด๊ธฐ ๋•Œ๋ฌธ์— ์—ฐ์‚ฐ์ด ๋ฌดํšจํ™”๋ฉ๋‹ˆ๋‹ค. ์ฆ‰, ~-16์€ 15์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

const int = ~~"15"
console.log(int); // Result: 15
console.log(typeof int); Result: "number"

<Quick Powers

์šด์˜

ES7๋ถ€ํ„ฐ ์ง€์ˆ˜ ์—ฐ์‚ฐ์ž **๋ฅผ ๊ฑฐ๋“ญ์ œ๊ณฑ์˜ ์•ฝ์–ด๋กœ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋Š” Math.pow(2, 3)์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ๋ณด๋‹ค ํ›จ์”ฌ ๋น ๋ฆ…๋‹ˆ๋‹ค. ๊ฐ„๋‹จํ•ด ๋ณด์ด์ง€๋งŒ ์ด ์ ์€ ์–ด๋””์—์„œ๋‚˜ ์–ธ๊ธ‰๋˜์ง€ ์•Š๊ธฐ ๋•Œ๋ฌธ์— ๊ธฐ์ˆ  ๋ชฉ๋ก์— ํฌํ•จ๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค.

console.log(2 ** 3); // Result: 8

์ง€์ˆ˜ ๊ณ„์‚ฐ์— ์ผ๋ฐ˜์ ์œผ๋กœ ์‚ฌ์šฉ๋˜๋Š” ^ ๊ธฐํ˜ธ์™€ ํ˜ผ๋™ํ•ด์„œ๋Š” ์•ˆ ๋ฉ๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ JavaScript์—์„œ๋Š” ์ด๊ฒƒ์ด XOR ์—ฐ์‚ฐ์ž์ž…๋‹ˆ๋‹ค.

ES7 ์ด์ „์—๋Š” ** ๋‹จ์ถ•ํ‚ค๋Š” ๋น„ํŠธ ์™ผ์ชฝ ์ด๋™ ์—ฐ์‚ฐ์ž <<๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ 2์ง„์ˆ˜์˜ ๊ฑฐ๋“ญ์ œ๊ณฑ์—๋งŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค.

Math.pow(2, n);
2 << (n - 1);
2**n;

์˜ˆ๋ฅผ ๋“ค์–ด 2 << 3 = 16์€ 2 ** 4 = 16๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

์ •์ˆ˜๋กœ ๋ถ€๋™

์ž‘์—…/์œ ํ˜• ๋ณ€ํ™˜

๋ถ€๋™์†Œ์ˆ˜์ ์„ ์ •์ˆ˜๋กœ ๋ณ€ํ™˜ํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ Math.floor(), Math.ceil() ๋˜๋Š” Math.round()๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ๋” ๋น ๋ฅธ ๋ฐฉ๋ฒ•์ด ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋ฅผ ์œ„ํ•ด |, ์ฆ‰ OR ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

console.log(23.9 | 0);  // Result: 23
console.log(-23.9 | 0); // Result: -23

ํ–‰๋™ | ๋‹ค๋ฃจ๋Š” ๋Œ€์ƒ์ด ์–‘์ˆ˜์ธ์ง€ ์Œ์ˆ˜์ธ์ง€์— ๋”ฐ๋ผ ํฌ๊ฒŒ ๋‹ฌ๋ผ์ง€๋ฏ€๋กœ ์ด ๋ฐฉ๋ฒ•์€ ์ˆ˜ํ–‰ ์ค‘์ธ ์ž‘์—…์— ์ž์‹ ๊ฐ์ด ์žˆ๋Š” ๊ฒฝ์šฐ์—๋งŒ ์ ํ•ฉํ•ฉ๋‹ˆ๋‹ค.

์—” | 0์€ ์†Œ์ˆ˜ ๊ตฌ๋ถ„ ๊ธฐํ˜ธ ๋’ค์˜ ๋ชจ๋“  ๋‚ด์šฉ์„ ์ œ๊ฑฐํ•˜๊ณ  ๋ถ€๋™ ์†Œ์ˆ˜์ ์„ ์ •์ˆ˜๋กœ ์ž๋ฆ…๋‹ˆ๋‹ค.

~~๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋™์ผํ•œ ๋ฐ˜์˜ฌ๋ฆผ ํšจ๊ณผ๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ฐ•์ œ๋กœ ์ •์ˆ˜๋กœ ๋ณ€ํ™˜ํ•œ ํ›„์—๋„ ๊ฐ’์€ ๋ณ€๊ฒฝ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

ํ›„ํ–‰ ์ˆซ์ž ์ œ๊ฑฐ

OR ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์ˆซ์ž์—์„œ ์ž„์˜์˜ ์ž๋ฆฟ์ˆ˜๋ฅผ ์ œ๊ฑฐํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ฆ‰, ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์œ ํ˜•์„ ๋ณ€ํ™˜ํ•  ํ•„์š”๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค.

let str = "1553";
Number(str.substring(0, str.length - 1));

๋Œ€์‹  ๊ฐ„๋‹จํžˆ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ž‘์„ฑํ•ฉ๋‹ˆ๋‹ค.

console.log(1553 / 10   | 0)  // Result: 155
console.log(1553 / 100  | 0)  // Result: 15
console.log(1553 / 1000 | 0)  // Result: 1

์ž๋™ ์—ฐ๊ฒฐ

ํด๋ž˜์Šค

ES6 ํ™”์‚ดํ‘œ ํ‘œ๊ธฐ๋ฒ•์€ ํด๋ž˜์Šค ๋ฉ”์„œ๋“œ์—์„œ ์‚ฌ์šฉ๋  ์ˆ˜ ์žˆ์œผ๋ฉฐ ๋ฐ”์ธ๋”ฉ์ด ์•”์‹œ๋ฉ๋‹ˆ๋‹ค. ์ด๋Š” this.myMethod = this.myMethod.bind(this)์™€ ๊ฐ™์€ ๋ฐ˜๋ณต์ ์ธ ํ‘œํ˜„์‹์— ์ž‘๋ณ„ ์ธ์‚ฌ๋ฅผ ํ•  ์ˆ˜ ์žˆ์Œ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค!

import React, { Component } from React;
 
export default class App extends Compononent {
  constructor(props) {
  super(props);
  this.state = {};
  }
 
myMethod = () => {
    // This method is bound implicitly!
  }
 
render() {
    return (
      <>
        <div>
          {this.myMethod()}
        </div>
      </>
    )
  }
};

๋ฐฐ์—ด ํŠธ๋ฆฌ๋ฐ

๋ฐฐ์—ด

๋ฐฐ์—ด์—์„œ ๊ฐ’์„ ์ œ๊ฑฐํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ splice()๋ณด๋‹ค ๋น ๋ฅธ ๋ฐฉ๋ฒ•์ด ์žˆ์Šต๋‹ˆ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด, ์›๋ณธ ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๋ฅผ ์•Œ๊ณ  ์žˆ๋Š” ๊ฒฝ์šฐ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๊ธธ์ด ์†์„ฑ์„ ์žฌ์ •์˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

let array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
array.length = 4;
 
console.log(array); // Result: [0, 1, 2, 3]

๊ทธ๋Ÿฌ๋‚˜ ๋˜ ๋‹ค๋ฅธ ๋ฐฉ๋ฒ•, ๋” ๋น ๋ฅธ ๋ฐฉ๋ฒ•์ด ์žˆ์Šต๋‹ˆ๋‹ค. ์†๋„๊ฐ€ ์ค‘์š”ํ•œ ๊ฒฝ์šฐ ๋‹ค์Œ์„ ์„ ํƒํ•ด ๋ณด์„ธ์š”.

let array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
array = array.slice(0, 4);
 
console.log(array); // Result: [0, 1, 2, 3]

๋ฐฐ์—ด์˜ ๋งˆ์ง€๋ง‰ ๊ฐ’ ์ธ์‡„

๋ฐฐ์—ด
์ด ๊ธฐ์ˆ ์„ ์‚ฌ์šฉํ•˜๋ ค๋ฉด Slice() ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

let array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 
console.log(array.slice(-1)); // Result: [9]
console.log(array.slice(-2)); // Result: [8, 9]
console.log(array.slice(-3)); // Result: [7, 8, 9]

JSON ์ฝ”๋“œ ํ˜•์‹ ์ง€์ •

JSON

์ด๋ฏธ JSON.stringify๋ฅผ ์‚ฌ์šฉํ–ˆ์„ ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค. JSON ํ˜•์‹์„ ์ง€์ •ํ•˜๋Š” ๋ฐ ๋„์›€์ด ๋œ๋‹ค๋Š” ๊ฒƒ์„ ์•Œ๊ณ  ๊ณ„์…จ๋‚˜์š”?

stringify() ๋ฉ”์„œ๋“œ๋Š” ๋‘ ๊ฐ€์ง€ ์„ ํƒ์  ๋งค๊ฐœ ๋ณ€์ˆ˜, ์ฆ‰ ํ‘œ์‹œ๋˜๋Š” JSON์„ ํ•„ํ„ฐ๋งํ•˜๋Š” ๋ฐ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๋Œ€์ฒด ํ•จ์ˆ˜์™€ ๊ณต๋ฐฑ ๊ฐ’์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

console.log(JSON.stringify({ alpha: 'A', beta: 'B' }, null, 't'));
 
// Result:
// '{
//     "alpha": A,
//     "beta": B
// }'

๊ทธ๊ฒŒ ๋‹ค์ž…๋‹ˆ๋‹ค. ์ด ๋ชจ๋“  ๊ธฐ์ˆ ์ด ์œ ์šฉํ–ˆ๊ธฐ๋ฅผ ๋ฐ”๋ž๋‹ˆ๋‹ค. ์–ด๋–ค ๋น„๊ฒฐ์„ ์•Œ๊ณ  ์žˆ๋‚˜์š”? ๋Œ“๊ธ€์— ์ ์–ด์ฃผ์„ธ์š”.

Skillbox๋Š” ๋‹ค์Œ์„ ๊ถŒ์žฅํ•ฉ๋‹ˆ๋‹ค.

์ถœ์ฒ˜ : habr.com

์ฝ”๋ฉ˜ํŠธ๋ฅผ ์ถ”๊ฐ€