5๊ฐ€์ง€ ์ผ๋ฐ˜์ ์ธ JavaScript ๋ฉด์ ‘ ๊ณผ์ œ: ๋ถ„์„ ๋ฐ ์†”๋ฃจ์…˜

5๊ฐ€์ง€ ์ผ๋ฐ˜์ ์ธ JavaScript ๋ฉด์ ‘ ๊ณผ์ œ: ๋ถ„์„ ๋ฐ ์†”๋ฃจ์…˜

๋ฒˆ์—ญ์ž: ๋‹น์‹ ์„ ์œ„ํ•œ ๊ธฐ์‚ฌ๋ฅผ ๊ฒŒ์‹œํ–ˆ์Šต๋‹ˆ๋‹ค ์ผ๋ฐ˜์ ์ธ JavaScript ์ž‘์—…์— ๋Œ€ํ•ด ์ด์•ผ๊ธฐํ•˜๋Š” Maria Antonietta Perna, ์ธํ„ฐ๋ทฐ ์ค‘์— ๊ฐœ๋ฐœ์ž ์ง€์›์ž์—๊ฒŒ ๊ฐ€์žฅ ์ž์ฃผ ์ œ๊ณต๋ฉ๋‹ˆ๋‹ค. ์ด ๊ธฐ์‚ฌ๋Š” ์šฐ์„  ์ดˆ๋ณด ํ”„๋กœ๊ทธ๋ž˜๋จธ์—๊ฒŒ ์œ ์šฉํ•  ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๊ธฐ์ˆ  ํšŒ์‚ฌ์˜ ์ธํ„ฐ๋ทฐ๋Š” ์˜ค๋žซ๋™์•ˆ ํ™”์ œ๊ฐ€ ๋˜์–ด ์™”์Šต๋‹ˆ๋‹ค. ์ด๋Š” ๋†€๋ผ์šด ์ผ์ด ์•„๋‹™๋‹ˆ๋‹ค. ์„ฑ๊ณต์ ์œผ๋กœ ์ธํ„ฐ๋ทฐ๋ฅผ ํ†ต๊ณผํ•˜๋ฉด ์ข‹์€ ์ง์—…์„ ์–ป์„ ์ˆ˜ ์žˆ๋Š” ๊ธฐํšŒ๊ฐ€ ์ œ๊ณต๋ฉ๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ๋ณต์žกํ•œ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ๊ธฐ ๋•Œ๋ฌธ์— ์ด๋Š” ๊ทธ๋ฆฌ ๊ฐ„๋‹จํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

๋˜ํ•œ ๋Œ€๋ถ€๋ถ„์˜ ๊ฒฝ์šฐ ์ด๋Ÿฌํ•œ ์ž‘์—…์˜ ๋Œ€๋ถ€๋ถ„์€ ์ง€์›์ž๊ฐ€ ์ˆ˜ํ–‰ํ•  ์ž‘์—…๊ณผ ๊ด€๋ จ์ด ์—†์ง€๋งŒ ์—ฌ์ „ํžˆ ํ•ด๊ฒฐํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๋•Œ๋กœ๋Š” Google์ด๋‚˜ ๋‹ค๋ฅธ ์†Œ์Šค์— ํ™•์ธํ•˜์ง€ ์•Š๊ณ  ๊ฒŒ์‹œํŒ์—์„œ ์ด๋ฅผ ์ˆ˜ํ–‰ํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ๋„ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ, ์ƒํ™ฉ์€ ์ ์ฐจ ๋ณ€ํ•˜๊ณ  ์žˆ์œผ๋ฉฐ ์ผ๋ถ€ ํšŒ์‚ฌ์—์„œ๋Š” ์ด๋Ÿฌํ•œ ์ธํ„ฐ๋ทฐ๋ฅผ ํฌ๊ธฐํ•˜๊ณ  ์žˆ์ง€๋งŒ ๋งŽ์€ ๊ณ ์šฉ์ฃผ๋Š” ์—ฌ์ „ํžˆ ์ด๋Ÿฌํ•œ ์ „ํ†ต์„ ๊ณ ์ˆ˜ํ•˜๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ์ด ๊ธ€์€ ๊ตฌ์ง์ž์˜ ์ž‘์—…์œผ๋กœ ์ž์ฃผ ์‚ฌ์šฉ๋˜๋Š” ์ผ๋ฐ˜์ ์ธ JavaScript ์ž‘์—…์— ๋Œ€ํ•œ ๋ถ„์„์„ ๋‹ค๋ฃน๋‹ˆ๋‹ค.

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

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

๊ฐ€์žฅ ์ค‘์š”ํ•œ ๊ฒƒ์€ ์ธํ„ฐ๋ทฐ๋ฅผ ์ฒ ์ €ํžˆ ์ค€๋น„ํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

์˜ˆ, ์—…๋ฌด๋ฅผ ์‚ดํŽด๋ณด๊ธฐ ์ „์— ์ผ๋ฐ˜์ ์ธ ๋ฉด์ ‘ ์ค€๋น„ ํŒ์„ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

๊ฐ€์žฅ ์ค‘์š”ํ•œ ๊ฒƒ์€ ๋ฏธ๋ฆฌ ์ค€๋น„ํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์•Œ๊ณ ๋ฆฌ์ฆ˜๊ณผ ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ๋ฅผ ์–ผ๋งˆ๋‚˜ ์ž˜ ๊ธฐ์–ตํ•˜๋Š”์ง€ ํ…Œ์ŠคํŠธํ•˜๊ณ  ์ต์ˆ™ํ•˜์ง€ ์•Š์€ ์˜์—ญ์— ๋Œ€ํ•œ ์ง€์‹์„ ํ–ฅ์ƒ์‹œํ‚ค์„ธ์š”. ์ธํ„ฐ๋ทฐ ์ค€๋น„์— ๋„์›€์ด ๋˜๋Š” ์˜จ๋ผ์ธ ํ”Œ๋žซํผ์ด ๋งŽ์ด ์žˆ์Šต๋‹ˆ๋‹ค. ์šฐ๋ฆฌ๋Š” ์กฐ์–ธํ•ฉ๋‹ˆ๋‹ค ๊ธฑ์Šคํฌ๊ธฑ์Šค, ํ”„๋žจํ”„, ์ธํ„ฐ๋ทฐ.io ะธ ์ฝ”๋“œ ์‹ ํ˜ธ.

๊ฒฐ์ •์„ ํฐ ์†Œ๋ฆฌ๋กœ ๋งํ•˜๋Š” ๋ฒ•์„ ๋ฐฐ์šฐ๋Š” ๊ฒƒ์€ ๊ฐ€์น˜๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ๋‹จ์ˆœํžˆ ์น ํŒ์— ๊ธ€์„ ์“ฐ๋Š” ๊ฒƒ(๋˜๋Š” ์กฐ์šฉํžˆ ์ปดํ“จํ„ฐ์— ์ฝ”๋“œ๋ฅผ ์ž…๋ ฅํ•˜๋Š” ๊ฒƒ)์ด ์•„๋‹Œ ์ง€์›์ž์—๊ฒŒ ์ž์‹ ์ด ํ•˜๋Š” ์ผ์— ๋Œ€ํ•ด ์•Œ๋ ค์ฃผ๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค. ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ์ฝ”๋“œ์— ์‹ค์ˆ˜๊ฐ€ ์žˆ์ง€๋งŒ ์ผ๋ฐ˜์ ์œผ๋กœ ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•์ด ์ •ํ™•ํ•˜๋”๋ผ๋„ ์„ฑ๊ณต ๊ฐ€๋Šฅ์„ฑ์ด ๋†’์•„์ง‘๋‹ˆ๋‹ค.

๋ฌธ์ œ ํ•ด๊ฒฐ์„ ์‹œ์ž‘ํ•˜๊ธฐ ์ „์— ๋ฌธ์ œ๋ฅผ ์ดํ•ดํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์–ด๋–ค ๊ฒฝ์šฐ์—๋Š” ์ž‘์—…์„ ํ”ผ์ƒ์ ์œผ๋กœ ์ดํ•ดํ•œ ๋‹ค์Œ ์ž˜๋ชป๋œ ๊ธธ๋กœ ๊ฐˆ ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฉด์ ‘๊ด€์—๊ฒŒ ๋ช‡ ๊ฐ€์ง€ ๋ช…ํ™•ํ•œ ์งˆ๋ฌธ์„ ํ•˜๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค.

PC๊ฐ€ ์•„๋‹Œ ์†์œผ๋กœ ์ฝ”๋“œ ์ž‘์„ฑ ์—ฐ์Šต์„ ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ธํ„ฐ๋ทฐ ์ค‘์— ์ง€์›์ž์—๊ฒŒ ํžŒํŠธ๋‚˜ ์ž๋™ ์„œ์‹์ด ์—†๋Š” ๋งˆ์ปค์™€ ํ™”์ดํŠธ๋ณด๋“œ๊ฐ€ ์ œ๊ณต๋˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ํ•ด๊ฒฐ์ฑ…์„ ์ฐพ์„ ๋•Œ ์ฝ”๋“œ๋ฅผ ์ข…์ด๋‚˜ ๋ณด๋“œ์— ์ง์ ‘ ์ ์–ด ๋‘๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค. ๋ชจ๋“  ๊ฒƒ์„ ๋จธ๋ฆฟ์†์— ๋‹ด์•„๋‘๋ฉด ์ค‘์š”ํ•œ ๊ฒƒ์„ ์žŠ์–ด๋ฒ„๋ฆด ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

JavaScript์˜ ํ…œํ”Œ๋ฆฟ ์ž‘์—…

์ด๋Ÿฌํ•œ ์ž‘์—… ์ค‘ ์ผ๋ถ€๋Š” ์ด๋ฏธ ์ต์ˆ™ํ•  ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๋น„์Šทํ•œ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•ด์•ผ ํ•˜๋Š” ์ธํ„ฐ๋ทฐ๋ฅผ ํ–ˆ๊ฑฐ๋‚˜ JavaScript๋ฅผ ๋ฐฐ์šฐ๋ฉด์„œ ์—ฐ์Šตํ•ด ๋ณธ ์ ์ด ์žˆ์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ž, ์ด์ œ ๋‹ค์‹œ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๊ณ  ๊ณผ์ •์— ๋Œ€ํ•œ ์ž์„ธํ•œ ์„ค๋ช…์„ ๋“ค์„ ์ฐจ๋ก€์ž…๋‹ˆ๋‹ค.

ํšŒ๋ฌธ

ํšŒ๋ฌธ์€ ์ผ๋ฐ˜์ ์ธ ๋ฐฉํ–ฅ๊ณผ ๋ฐ˜๋Œ€ ๋ฐฉํ–ฅ ๋ชจ๋‘์—์„œ ์ •ํ™•ํžˆ ๋™์ผํ•˜๊ฒŒ ์ฝํžˆ๋Š” ๋‹จ์–ด, ๋ฌธ์žฅ ๋˜๋Š” ๋ฌธ์ž ์‹œํ€€์Šค์ž…๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, โ€œAnnaโ€๋Š” ํšŒ๋ฌธ์ด์ง€๋งŒ โ€œtableโ€๊ณผ โ€œJohnโ€์€ ๊ทธ๋ ‡์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

์Šคํ…Œ์ด์ง•

๋ฌธ์ž์—ด์ด ์ฃผ์–ด์ง€๋ฉด; ๋ฌธ์ž์—ด์ด ํšŒ๋ฌธ์ด๋ฉด true๋ฅผ ๋ฐ˜ํ™˜ํ•˜๊ณ  ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด false๋ฅผ ๋ฐ˜ํ™˜ํ•  ์ˆ˜ ์žˆ๋Š” ํ•จ์ˆ˜๋ฅผ ์ž‘์„ฑํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด ๊ฒฝ์šฐ ๊ณต๋ฐฑ๊ณผ ๊ตฌ๋‘์ ์„ ๊ณ ๋ คํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

palindrome('racecar') === ์ฐธ
ํšŒ๋ฌธ('ํ…Œ์ด๋ธ”') === ๊ฑฐ์ง“

์ž‘์—…์„ ๋ถ„์„ํ•ด ๋ด…์‹œ๋‹ค

์—ฌ๊ธฐ์„œ ์ฃผ์š” ์•„์ด๋””์–ด๋Š” ๋ฌธ์ž์—ด์„ ๋’ค์ง‘๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. "์—ญ๋ฐฉํ–ฅ" ๋ฌธ์ž์—ด์ด ์›๋ž˜ ๋ฌธ์ž์—ด๊ณผ ์™„์ „ํžˆ ๋™์ผํ•˜๋ฉด ํšŒ๋ฌธ์„ ๋ฐ›์€ ๊ฒƒ์ด๋ฏ€๋กœ ํ•จ์ˆ˜๋Š” true๋ฅผ ๋ฐ˜ํ™˜ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋ ‡์ง€ ์•Š๋‹ค๋ฉด ๊ฑฐ์ง“์ž…๋‹ˆ๋‹ค.

๊ฒฐ์ •

๋‹ค์Œ์€ ํšŒ๋ฌธ์„ ํ•ด๊ฒฐํ•˜๋Š” ์ฝ”๋“œ์ž…๋‹ˆ๋‹ค.

const palindrome = str => {
  // turn the string to lowercase
  str = str.toLowerCase()
  // reverse input string and return the result of the
  // comparisong
  return str === str.split('').reverse().join('')
}

์ฒซ ๋ฒˆ์งธ ๋‹จ๊ณ„๋Š” ์ž…๋ ฅ ๋ฌธ์ž์—ด์˜ ๋ฌธ์ž๋ฅผ ์†Œ๋ฌธ์ž๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ด๋Š” ํ”„๋กœ๊ทธ๋žจ์ด ๋Œ€์†Œ๋ฌธ์ž๋‚˜ ๋‹ค๋ฅธ ์–ด๋–ค ๊ฒƒ๋„ ๋น„๊ตํ•˜์ง€ ์•Š๊ณ  ๋ฌธ์ž ์ž์ฒด๋ฅผ ๋น„๊ตํ•œ๋‹ค๋Š” ๊ฒƒ์„ ๋ณด์žฅํ•ฉ๋‹ˆ๋‹ค.

๋‘ ๋ฒˆ์งธ ๋‹จ๊ณ„๋Š” ๋ผ์ธ์„ ๋’ค์ง‘๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ด๋Š” ์–ด๋ ต์ง€ ์•Š์Šต๋‹ˆ๋‹ค. .split() ๋ฉ”์„œ๋“œ(๋ฌธ์ž์—ด ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ)๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋ฐฐ์—ด๋กœ ๋ณ€ํ™˜ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋Ÿฐ ๋‹ค์Œ .reverse()(๋ฐฐ์—ด ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ)๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋ฐฐ์—ด์„ ๋’ค์ง‘์Šต๋‹ˆ๋‹ค. ๋งˆ์ง€๋ง‰ ๋‹จ๊ณ„๋Š” .join()(๋ฐฐ์—ด ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ)์„ ์‚ฌ์šฉํ•˜์—ฌ ์—ญ๋ฐฉํ–ฅ ๋ฐฐ์—ด์„ ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

์ด์ œ ํ•ด์•ผ ํ•  ์ผ์€ "์—ญ๋ฐฉํ–ฅ" ๋ฌธ์ž์—ด์„ ์›๋ž˜ ๋ฌธ์ž์—ด๊ณผ ๋น„๊ตํ•˜์—ฌ ๊ฒฐ๊ณผ๊ฐ€ true ๋˜๋Š” false๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

ํ”ผ์ฆˆ๋ฒ„์ฆˆ

์ธํ„ฐ๋ทฐ์—์„œ ๊ฐ€์žฅ ์ธ๊ธฐ ์žˆ๋Š” ์ž‘์—… ์ค‘ ํ•˜๋‚˜์ž…๋‹ˆ๋‹ค.

์Šคํ…Œ์ด์ง•

1๋ถ€ํ„ฐ n๊นŒ์ง€์˜ ์ˆซ์ž๋ฅผ ์ฝ˜์†”์— ์ธ์‡„ํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ ์ž‘์„ฑํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„œ n์€ ๋‹ค์Œ ์กฐ๊ฑด์— ๋”ฐ๋ผ ํ•จ์ˆ˜๊ฐ€ ๋งค๊ฐœ ๋ณ€์ˆ˜๋กœ ์‚ฌ์šฉํ•˜๋Š” ์ •์ˆ˜์ž…๋‹ˆ๋‹ค.

  • 3์˜ ๋ฐฐ์ˆ˜ ๋Œ€์‹  fizz๋ฅผ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค.
  • 5์˜ ๋ฐฐ์ˆ˜์ธ ์ˆซ์ž ๋Œ€์‹  ๋ฒ„์ฆˆ๋ฅผ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค.
  • 3๊ณผ 5์˜ ๋ฐฐ์ˆ˜์ธ ์ˆซ์ž ๋Œ€์‹  fizzbuzz๊ฐ€ ์ถœ๋ ฅ๋ฉ๋‹ˆ๋‹ค.

์˜ˆ

ํ”ผ์ฆˆ๋ฒ„์ฆˆ(5)

๊ฒฐ๊ณผ

// 1
// 2
// ํƒ„์‚ฐ
// 4
//๋ฒ„์ € ์†Œ๋ฆฌ

์ž‘์—…์„ ๋ถ„์„ํ•ด ๋ด…์‹œ๋‹ค

์—ฌ๊ธฐ์„œ ๊ฐ€์žฅ ์ค‘์š”ํ•œ ๊ฒƒ์€ JavaScript๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋ฐฐ์ˆ˜๋ฅผ ์ฐพ๋Š” ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค. ๋ชจ๋“ˆ๋Ÿฌ์Šค ์—ฐ์‚ฐ์ž ๋˜๋Š” ๋‚˜๋จธ์ง€ - %๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋ฅผ ํ†ตํ•ด ๋‘ ์ˆซ์ž๋ฅผ ๋‚˜๋ˆŒ ๋•Œ ๋‚˜๋จธ์ง€๋ฅผ ํ‘œ์‹œํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋‚˜๋จธ์ง€๊ฐ€ 0์ด๋ฉด ์ฒซ ๋ฒˆ์งธ ์ˆซ์ž๊ฐ€ ๋‘ ๋ฒˆ์งธ ์ˆซ์ž์˜ ๋ฐฐ์ˆ˜๋ผ๋Š” ์˜๋ฏธ์ž…๋‹ˆ๋‹ค.

12% 5 // 2 -> 12๋Š” 5์˜ ๋ฐฐ์ˆ˜๊ฐ€ ์•„๋‹™๋‹ˆ๋‹ค.
12% 3 // 0 -> 12๋Š” 3์˜ ๋ฐฐ์ˆ˜์ž…๋‹ˆ๋‹ค.

๋”ฐ๋ผ์„œ 12๋ฅผ 5๋กœ ๋‚˜๋ˆ„๋ฉด 2๊ฐ€ ๋˜๊ณ  ๋‚˜๋จธ์ง€๋Š” 2๊ฐ€ ๋ฉ๋‹ˆ๋‹ค. 12๋ฅผ 3์œผ๋กœ ๋‚˜๋ˆ„๋ฉด 4๊ฐ€ ๋˜๊ณ  ๋‚˜๋จธ์ง€๋Š” 0์ด ๋ฉ๋‹ˆ๋‹ค. ์ฒซ ๋ฒˆ์งธ ๊ฒฝ์šฐ 12๋Š” 5์˜ ๋ฐฐ์ˆ˜๊ฐ€ ์•„๋‹ˆ๊ณ  ๋‘ ๋ฒˆ์งธ ๊ฒฝ์šฐ , 12๋Š” 3์˜ ๋ฐฐ์ˆ˜์ž…๋‹ˆ๋‹ค.

๊ฒฐ์ •

์ตœ์ ์˜ ์†”๋ฃจ์…˜์€ ๋‹ค์Œ ์ฝ”๋“œ์ž…๋‹ˆ๋‹ค.

const fizzBuzz = num => {
  for(let i = 1; i <= num; i++) {
    // check if the number is a multiple of 3 and 5
    if(i % 3 === 0 && i % 5 === 0) {
      console.log('fizzbuzz')
    } // check if the number is a multiple of 3
      else if(i % 3 === 0) {
      console.log('fizz')
    } // check if the number is a multiple of 5
      else if(i % 5 === 0) {
      console.log('buzz')
    } else {
      console.log(i)
    }
  }
}

์ด ํ•จ์ˆ˜๋Š” ์กฐ๊ฑด๋ฌธ์„ ์‚ฌ์šฉํ•˜์—ฌ ํ•„์š”ํ•œ ๊ฒ€์‚ฌ๋ฅผ ์ˆ˜ํ–‰ํ•˜๊ณ  ์‚ฌ์šฉ์ž๊ฐ€ ์š”๊ตฌํ•˜๋Š” ๊ฒฐ๊ณผ๋ฅผ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค. ๋ฌธ์ œ์—์„œ๋Š” if...else ๋ฌธ์˜ ์ˆœ์„œ์— ์ฃผ์˜ํ•  ํ•„์š”๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ์ฆ‰, ์ด์ค‘ ์กฐ๊ฑด(&&)์œผ๋กœ ์‹œ์ž‘ํ•˜๊ณ  ์—ฌ๋Ÿฌ ์ˆซ์ž๋ฅผ ์ฐพ์„ ์ˆ˜ ์—†๋Š” ๊ฒฝ์šฐ๋กœ ๋๋‚ฉ๋‹ˆ๋‹ค. ๊ฒฐ๊ณผ์ ์œผ๋กœ ์šฐ๋ฆฌ๋Š” ๋ชจ๋“  ์˜ต์…˜์„ ๋‹ค๋ฃน๋‹ˆ๋‹ค.

์ฒ ์ž ๋ฐ”๊พธ๊ธฐ

์ด๋Š” ๋‹ค๋ฅธ ๋‹จ์–ด์˜ ๋ชจ๋“  ๋ฌธ์ž๋ฅผ ๊ฐ™์€ ์ˆซ์ž๋กœ ํฌํ•จํ•˜์ง€๋งŒ ์ˆœ์„œ๊ฐ€ ๋‹ค๋ฅธ ๋‹จ์–ด์˜ ์ด๋ฆ„์ž…๋‹ˆ๋‹ค.

์Šคํ…Œ์ด์ง•

๋‘ ๋ฌธ์ž์—ด์ด ์ฒ ์ž ๋ฐ”๊พธ๊ธฐ์ธ์ง€, ๋Œ€์†Œ๋ฌธ์ž๋Š” ์ค‘์š”ํ•˜์ง€ ์•Š์€์ง€ ํ™•์ธํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ ์ž‘์„ฑํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๋ฌธ์ž๋งŒ ๊ณ„์‚ฐ๋ฉ๋‹ˆ๋‹ค. ๊ณต๋ฐฑ์ด๋‚˜ ๊ตฌ๋‘์ ์€ ๊ณ ๋ ค๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

anagram('finder', 'Friend') โ€”> ์ฐธ
anagram('hello', 'bye') โ€”> ๊ฑฐ์ง“

์ž‘์—…์„ ๋ถ„์„ํ•ด ๋ด…์‹œ๋‹ค

์—ฌ๊ธฐ์„œ ์ค‘์š”ํ•œ ์ ์€ ๋‘ ์ž…๋ ฅ์ค„์˜ ๊ฐ ๋ฌธ์ž์™€ ๊ฐ ์ค„์˜ ์ˆซ์ž๋ฅผ ํ™•์ธํ•ด์•ผ ํ•œ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

ํŒŒ์ธ๋” โ€”> f: ์นœ๊ตฌ 1๋ช… โ€”> f: 1
๋‚˜: 1 ๋ฅด: 1
n: 1 ๋‚˜: 1
d: 1 ์ „์ž: 1
์ „์ž: 1 n: 1
r: 1 d: 1

์ฒ ์ž ๋ฐ”๊พธ๊ธฐ ๋ฐ์ดํ„ฐ๋ฅผ ์ €์žฅํ•˜๋ ค๋ฉด JavaScript ๊ฐœ์ฒด ๋ฆฌํ„ฐ๋Ÿด๊ณผ ๊ฐ™์€ ๊ตฌ์กฐ๋ฅผ ์„ ํƒํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด ๊ฒฝ์šฐ ํ•ต์‹ฌ์€ ๋ฌธ์ž์˜ ๋ฌธ์ž์ด๊ณ  ๊ฐ’์€ ํ˜„์žฌ ์ค„์—์„œ ๋ฐ˜๋ณต๋˜๋Š” ํšŸ์ˆ˜์ž…๋‹ˆ๋‹ค.

๋‹ค๋ฅธ ์กฐ๊ฑด์ด ์žˆ์Šต๋‹ˆ๋‹ค:

  • ๋น„๊ตํ•  ๋•Œ ๋ฌธ์ž์˜ ๋Œ€/์†Œ๋ฌธ์ž๊ฐ€ ๊ณ ๋ ค๋˜์ง€ ์•Š๋Š”์ง€ ํ™•์ธํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๊ฐ„๋‹จํžˆ ๋‘ ๋ฌธ์ž์—ด์„ ๋ชจ๋‘ ์†Œ๋ฌธ์ž ๋˜๋Š” ๋Œ€๋ฌธ์ž๋กœ ๋ณ€ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
  • ๋น„๊ต์—์„œ ๋ฌธ์ž๊ฐ€ ์•„๋‹Œ ๋ชจ๋“  ํ•ญ๋ชฉ์„ ์ œ์™ธํ•ฉ๋‹ˆ๋‹ค. ํ•จ๊ป˜ ์ž‘์—…ํ•˜๋Š” ๊ฒƒ์ด ๊ฐ€์žฅ ์ข‹์Šต๋‹ˆ๋‹ค. ์ •๊ทœ ํ‘œํ˜„์‹.

๊ฒฐ์ •

// helper function that builds the
// object to store the data
const buildCharObject = str => {
  const charObj = {}
  for(let char of str.replace(/[^w]/g).toLowerCase()) {
    // if the object has already a key value pair
    // equal to the value being looped over,
    // increase the value by 1, otherwise add
    // the letter being looped over as key and 1 as its value
    charObj[char] = charObj[char] + 1 || 1
  }
  return charObj
}
 
// main function
const anagram = (strA, strB) => {
  // build the object that holds strA data
  const aCharObject = buildCharObject(strA)
  // build the object that holds strB data
  const bCharObject = buildCharObject(strB)
 
  // compare number of keys in the two objects
  // (anagrams must have the same number of letters)
  if(Object.keys(aCharObject).length !== Object.keys(bCharObject).length) {
    return false
  }
  // if both objects have the same number of keys
  // we can be sure that at least both strings
  // have the same number of characters
  // now we can compare the two objects to see if both
  // have the same letters in the same amount
  for(let char in aCharObject) {
    if(aCharObject[char] !== bCharObject[char]) {
      return false
    }
  }
  // if both the above checks succeed,
  // you have an anagram: return true
  return true
}

์‚ฌ์šฉ์— ์ฃผ์˜ Object.keys () ์œ„์˜ ์กฐ๊ฐ์—์„œ. ์ด ๋ฉ”์†Œ๋“œ๋Š” ๊ฐ์ฒด์— ๋‚˜ํƒ€๋‚˜๋Š” ๊ฒƒ๊ณผ ๋™์ผํ•œ ์ˆœ์„œ๋กœ ์ด๋ฆ„์ด๋‚˜ ํ‚ค๋ฅผ ํฌํ•จํ•˜๋Š” ๋ฐฐ์—ด์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์ด ๊ฒฝ์šฐ ๋ฐฐ์—ด์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

['f', 'i', 'n', 'd', 'e', โ€‹โ€‹โ€‹โ€‹'r']

์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ๋Œ€๋Ÿ‰ ๋ฃจํ”„๋ฅผ ์ˆ˜ํ–‰ํ•˜์ง€ ์•Š๊ณ ๋„ ๊ฐ์ฒด์˜ ์†์„ฑ์„ ์–ป์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฌธ์ œ๊ฐ€ ์žˆ๋Š” ๊ฒฝ์šฐ .length ์†์„ฑ๊ณผ ํ•จ๊ป˜ ์ด ๋ฐฉ๋ฒ•์„ ์‚ฌ์šฉํ•˜์—ฌ ๋‘ ๋ฌธ์ž์—ด์˜ ๋ฌธ์ž ์ˆ˜๊ฐ€ ๋™์ผํ•œ์ง€ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋Š” ์ฒ ์ž ๋ฐ”๊พธ๊ธฐ์˜ ์ค‘์š”ํ•œ ๊ธฐ๋Šฅ์ž…๋‹ˆ๋‹ค.

๋ชจ์Œ ๊ฒ€์ƒ‰

์ธํ„ฐ๋ทฐ์—์„œ ์ž์ฃผ ๋“ฑ์žฅํ•˜๋Š” ๋งค์šฐ ๊ฐ„๋‹จํ•œ ์ž‘์—…์ž…๋‹ˆ๋‹ค.

์Šคํ…Œ์ด์ง•

๋ฌธ์ž์—ด์„ ์ธ์ˆ˜๋กœ ์‚ฌ์šฉํ•˜๊ณ  ๋ฌธ์ž์—ด์— ํฌํ•จ๋œ ๋ชจ์Œ ์ˆ˜๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ ์ž‘์„ฑํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.
๋ชจ์Œ์€ "a", "e", "i", "o", "u"์ž…๋‹ˆ๋‹ค.

์˜ˆ :

findVowels('hello') // โ€”> 2
findVowels('์ด์œ ') // โ€”> 0

๊ฒฐ์ •

๊ฐ€์žฅ ๊ฐ„๋‹จํ•œ ์˜ต์…˜์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

const findVowels = str => {
  let count = 0
  const vowels = ['a', 'e', 'i', 'o', 'u']
  for(let char of str.toLowerCase()) {
    if(vowels.includes(char)) {
      count++
    }
  }
  return count
}

.includes() ๋ฉ”์†Œ๋“œ ์‚ฌ์šฉ์— ์ฃผ์˜ํ•˜๋Š” ๊ฒƒ์ด ์ค‘์š”ํ•ฉ๋‹ˆ๋‹ค. ๋ฌธ์ž์—ด๊ณผ ๋ฐฐ์—ด ๋ชจ๋‘์— ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฐฐ์—ด์— ํŠน์ • ๊ฐ’์ด ํฌํ•จ๋˜์–ด ์žˆ๋Š”์ง€ ํ™•์ธํ•˜๋Š” ๋ฐ ์‚ฌ์šฉํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด ๋ฉ”์„œ๋“œ๋Š” ๋ฐฐ์—ด์— ์ง€์ •๋œ ๊ฐ’์ด ํฌํ•จ๋˜์–ด ์žˆ์œผ๋ฉด true๋ฅผ ๋ฐ˜ํ™˜ํ•˜๊ณ , ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด false๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

๋ฌธ์ œ์— ๋Œ€ํ•œ ๋” ์งง์€ ํ•ด๊ฒฐ์ฑ…์ด ์žˆ์Šต๋‹ˆ๋‹ค.

const findVowels = str => {
  const matched = str.match(/[aeiou]/gi)
  return matched ? matches.length : 0
}

์ด๋Š” ํšจ์œจ์ ์ธ ๊ฒ€์ƒ‰์„ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ๋Š” .match() ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ๋ฉ”์„œ๋“œ ์ธ์ˆ˜์ธ ์ •๊ทœ์‹์ด ์ง€์ •๋œ ๋ฌธ์ž์—ด ๋‚ด์—์„œ ๋ฐœ๊ฒฌ๋˜๋ฉด ๋ฐ˜ํ™˜ ๊ฐ’์€ ์ผ์น˜ํ•˜๋Š” ๋ฌธ์ž์˜ ๋ฐฐ์—ด์ž…๋‹ˆ๋‹ค. ์ผ์น˜ํ•˜๋Š” ํ•ญ๋ชฉ์ด ์—†์œผ๋ฉด .match()๋Š” null์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

ํ”ผ๋ณด๋‚˜์น˜

๋‹ค์–‘ํ•œ ์ˆ˜์ค€์˜ ์ธํ„ฐ๋ทฐ์—์„œ ์ฐพ์„ ์ˆ˜ ์žˆ๋Š” ๊ณ ์ „์ ์ธ ์ž‘์—…์ž…๋‹ˆ๋‹ค. ํ”ผ๋ณด๋‚˜์น˜ ์ˆ˜์—ด์€ ๊ฐ ํ›„์† ์ˆซ์ž๊ฐ€ ์ด์ „ ๋‘ ์ˆซ์ž์˜ ํ•ฉ์ธ ์ผ๋ จ์˜ ์ˆซ์ž๋ผ๋Š” ์ ์„ ๊ธฐ์–ตํ•  ๊ฐ€์น˜๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ์ฒ˜์Œ 0๊ฐœ์˜ ์ˆซ์ž๋Š” 1, 1, 2, 3, 5, 8, 13, 21, 34, XNUMX์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

์Šคํ…Œ์ด์ง•

ํŠน์ • ์‹œํ€€์Šค์˜ n๋ฒˆ์งธ ๋ ˆ์ฝ”๋“œ๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ ์ž‘์„ฑํ•ด์•ผ ํ•˜๋ฉฐ, n์€ ํ•จ์ˆ˜์— ์ธ์ˆ˜๋กœ ์ „๋‹ฌ๋˜๋Š” ์ˆซ์ž์ž…๋‹ˆ๋‹ค.

ํ”ผ๋ณด๋‚˜์น˜(3) // โ€”> 2

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

๊ฒฐ์ •

const fibonacci = num => {
  // store the Fibonacci sequence you're going
  // to generate inside an array and
  // initialize the array with the first two
  // numbers of the sequence
  const result = [0, 1]
 
  for(let i = 2; i <= num; i++) {
    // push the sum of the two numbers
    // preceding the position of i in the result array
    // at the end of the result array
    const prevNum1 = result[i - 1]
    const prevNum2 = result[i - 2]
    result.push(prevNum1 + prevNum2)
  }
  // return the last value in the result array
  return result[num]
}

๊ฒฐ๊ณผ ๋ฐฐ์—ด์—์„œ๋Š” ์‹œํ€€์Šค์˜ ๊ฐ ํ•ญ๋ชฉ์ด ์ด์ „ ๋‘ ์ˆซ์ž์˜ ํ•ฉ์ด๊ธฐ ๋•Œ๋ฌธ์— ์ฒ˜์Œ ๋‘ ์ˆซ์ž๊ฐ€ ์‹œ๋ฆฌ์ฆˆ์— ํฌํ•จ๋ฉ๋‹ˆ๋‹ค. ๋งจ ์ฒ˜์Œ์—๋Š” ๋‹ค์Œ ์ˆซ์ž๋ฅผ ์–ป๊ธฐ ์œ„ํ•ด ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๋‘ ๊ฐœ์˜ ์ˆซ์ž๊ฐ€ ์—†์œผ๋ฏ€๋กœ ๋ฃจํ”„๊ฐ€ ์ž๋™์œผ๋กœ ์ˆซ์ž๋ฅผ ์ƒ์„ฑํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ์šฐ๋ฆฌ๊ฐ€ ์•Œ๊ณ  ์žˆ๋“ฏ์ด ์ฒ˜์Œ ๋‘ ์ˆซ์ž๋Š” ํ•ญ์ƒ 0๊ณผ 1์ž…๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ๊ฒฐ๊ณผ ๋ฐฐ์—ด์„ ์ˆ˜๋™์œผ๋กœ ์ดˆ๊ธฐํ™”ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์žฌ๊ท€์˜ ๊ฒฝ์šฐ ๋ชจ๋“  ๊ฒƒ์ด ๋” ๊ฐ„๋‹จํ•˜๋ฉด์„œ๋„ ๋™์‹œ์— ๋” ๋ณต์žกํ•ด์ง‘๋‹ˆ๋‹ค.

const fibonacci = num => {
  // if num is either 0 or 1 return num
  if(num < 2) {
    return num
  }
  // recursion here
  return fibonacci(num - 1) + fibonacci(num - 2)
}

์šฐ๋ฆฌ๋Š” fibonacci()๋ฅผ ๊ณ„์† ํ˜ธ์ถœํ•˜์—ฌ ์ ์  ๋” ์ž‘์€ ์ˆซ์ž๋ฅผ ์ธ์ˆ˜๋กœ ์ „๋‹ฌํ•ฉ๋‹ˆ๋‹ค. ์ „๋‹ฌ๋œ ์ธ์ˆ˜๊ฐ€ 0 ๋˜๋Š” 1์ด๋ฉด ์ค‘์ง€๋ฉ๋‹ˆ๋‹ค.

์ถœ๋ ฅ

ํ”„๋ก ํŠธ์—”๋“œ ๋˜๋Š” JavaScript ๊ฐœ๋ฐœ์ž ์ง์—…์— ๋Œ€ํ•œ ์ธํ„ฐ๋ทฐ๋ฅผ ํ–ˆ๋‹ค๋ฉด(ํŠนํžˆ ์ฃผ๋‹ˆ์–ด ๋ ˆ๋ฒจ์ธ ๊ฒฝ์šฐ) ์ด๋ฏธ ์ด๋Ÿฌํ•œ ์ž‘์—…์„ ์ ‘ํ–ˆ์„ ๊ฐ€๋Šฅ์„ฑ์ด ๋†’์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ์•„์ง ๋ฐœ๊ฒฌํ•˜์ง€ ๋ชปํ–ˆ๋‹ค๋ฉด ํ–ฅํ›„ ์ ์–ด๋„ ์ผ๋ฐ˜์ ์ธ ๊ฐœ๋ฐœ์—๋Š” ์œ ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

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

์ถœ์ฒ˜ : habr.com

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