[TIL] JavaScript : Loop

Acidยท2021๋…„ 8์›” 11์ผ
0

๐Ÿ“’ JavaScript

๋ชฉ๋ก ๋ณด๊ธฐ
5/8
post-thumbnail

์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ์˜ ๋ฐ˜๋ณต๋ฌธ์˜ ์ข…๋ฅ˜์™€ ๊ฐ๊ฐ์˜ ์‚ฌ์šฉ๋ฒ•, ํŠน์ง• ๋“ฑ์— ๋Œ€ํ•œ ๋‚ด์šฉ์ž…๋‹ˆ๋‹ค. ๐Ÿ˜Š

๐Ÿ”ƒ ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ์˜ ๋ฐ˜๋ณต๋ฌธ

๋ฐ˜๋ณต๋ฌธ(loop)์€ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ ์ผ์ • ๊ตฌ๊ฐ„์„ ์กฐ๊ฑด์— ๋”ฐ๋ผ ์ง€์†์ ์œผ๋กœ ๋ฐ˜๋ณตํ•˜๋Š” ๊ตฌ๋ฌธ์„ ์˜๋ฏธํ•œ๋‹ค.

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

์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ์—๋Š” ๋Œ€ํ‘œ์ ์ธ ๋ฐ˜๋ณต๋ฌธ์œผ๋กœ for ๋ฌธ๊ณผ while ๋ฌธ์ด ์žˆ๊ณ , while ๋ฌธ์˜ ๊ฒฝ์šฐ ๋ณ€ํ˜•๋˜์–ด do~while ๋ฌธ์œผ๋กœ๋„ ์ž‘์„ฑ ๊ฐ€๋Šฅํ•˜๋‹ค.

์ด๋ฒˆ ํฌ์ŠคํŒ…์—์„œ๋Š” ํ•ด๋‹น ์„ธ ๊ฐ€์ง€์˜ ๋ฐ˜๋ณต๋ฌธ ํ˜•ํƒœ์™€ ๊ฐ๊ฐ์˜ ์‚ฌ์šฉ๋ฒ• ๊ทธ๋ฆฌ๊ณ  ํŠน์ง•์„ ๊ตฌ๋ถ„์ง€์–ด ์•Œ์•„๋ณผ ๊ฒƒ์ด๋‹ค.

For ๋ฌธ

for ๋ฌธ์€ ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ ๋ฐ˜๋ณต๋ฌธ ์ƒ์„ฑ ์‹œ, ์ผ๋ฐ˜์ ์œผ๋กœ ์‚ฌ์šฉํ•˜๋Š” ๋ฐ˜๋ณต๋ฌธ ํ˜•ํƒœ์ด๋‹ค.

for ๋ฌธ ๋˜ํ•œ ๋ณ€ํ˜•๋œ ํ˜•ํƒœ๊ฐ€ ๋ช‡ ๊ฐ€์ง€ ์กด์žฌํ•˜๋Š”๋ฐ, ํ•ด๋‹น ํ˜•ํƒœ๋“ค์ด ์–ธ์ œ ์‚ฌ์šฉ๋˜๋Š”์ง€ ๊ทธ๋ฆฌ๊ณ  ์–ด๋–ป๊ฒŒ ์ž‘๋™ํ•˜๋Š”์ง€์— ๋Œ€ํ•ด ํ•จ๊ป˜ ์•Œ์•„๋ณผ ๊ฒƒ์ด๋‹ค.

For ๋ฌธ์˜ ๋ฌธ๋ฒ•

๊ธฐ๋ณธ์ ์ธ for ๋ฌธ์€ for ํ‚ค์›Œ๋“œ๋ฅผ ํ†ตํ•ด ์ž‘์„ฑ ๊ฐ€๋Šฅํ•˜๊ณ  ๊ตฌ์„ฑ ์š”์†Œ๋กœ ๋ณ€์ˆ˜ ์ดˆ๊ธฐํ™”, ์กฐ๊ฑด์‹, ์ฆ๊ฐ์‹์ด ์žˆ๋‹ค.

let arr = [1, "two", true]

for (let i = 0; i < arr.length; i++) {
	console.log(arr[i]) 
} // output : 1 two true


์œ„ ์˜ˆ์‹œ๋Š” ๋ฐฐ์—ด arr ์„ ์ˆœํšŒํ•˜๋ฉฐ console ์— arr ์˜ ๊ฐ ์š”์†Œ๋“ค์„ ์ถœ๋ ฅํ•˜๋Š” ์ž‘์—…์„ ์ง„ํ–‰ํ•œ๋‹ค.

์˜ˆ์‹œ์—์„œ for ๋‹ค์Œ์˜ ๊ด„ํ˜ธ ์•ˆ์— ์„ธ๋ฏธ์ฝœ๋ก (;)์œผ๋กœ ๊ตฌ๋ถ„๋œ ์š”์†Œ๋“ค์ด for ๋ฌธ์˜ ๊ตฌ์„ฑ ์š”์†Œ์— ํ•ด๋‹นํ•œ๋‹ค.

์šฐ์„  let i = 0 ์„ ํ†ตํ•ด ๋ฐฐ์—ด์„ ์ˆœํšŒํ•  ์ธ๋ฑ์Šค ์š”์†Œ๊ฐ€ ๋  ๋ณ€์ˆ˜ i๋ฅผ ์„ ์–ธ๊ณผ ๋™์‹œ์— ์ดˆ๊ธฐํ™”ํ•œ๋‹ค. ์ด์–ด์„œ i ๊ฐ€ ๋ฐฐ์—ด arr ์˜ ๊ธธ์ด(arr.length) ๋ณด๋‹ค ์งง์•„์•ผ ํ•จ์„ ์กฐ๊ฑด์œผ๋กœ ์ œ์‹œํ•˜๊ณ , ๋ฐ˜๋ณต์˜ ๊ธฐ์ค€์ด ๋˜๋Š” i ๊ฐ€ ์–ด๋–ป๊ฒŒ ๋ณ€ํ™”ํ• ์ง€์— ๋Œ€ํ•œ ์ฆ๊ฐ์‹์„ ์ž‘์„ฑํ•œ๋‹ค. ์˜ˆ์‹œ์˜ ๊ฒฝ์šฐ ํ•˜๋‚˜์”ฉ ์ฆ๊ฐ€ํ•˜๋„๋ก(i++) ์ž‘์„ฑํ•˜์˜€๋‹ค.

๊ทธ๋ ‡๊ฒŒ ์ž‘์„ฑ๋œ ํ•ด๋‹น for ๋ฌธ์€ ์ด ๋ฐฐ์—ด ๊ธธ์ด์ธ 3 ๋งŒํผ console.log(arr[i]) ๊ตฌ๋ฌธ์„ ๋ฐ˜๋ณตํ•˜์—ฌ ์œ„์™€ ๊ฐ™์€ ๊ฒฐ๊ณผ๋ฅผ ์ถœ๋ ฅํ•œ ๊ฒƒ์ด๋‹ค.

๐Ÿ’ก for ๋ฌธ์˜ ๋™์ž‘ ์ˆœ์„œ

for ๋ฌธ์˜ ๋™์ž‘ ์ˆœ์„œ์— ๋Œ€ํ•œ ์ดํ•ด๋Š” for ๋ฌธ์˜ ์ž‘์„ฑ์— ์žˆ์–ด ์œ ์—ฐํ•œ ์ž‘์„ฑ์— ๋„์›€์„ ์ค€๋‹ค.

for (A; B; C) {
   D
}
// A : ๋ณ€์ˆ˜ ์ดˆ๊ธฐ ์„ ์–ธ, B : ์กฐ๊ฑด์‹, C : ์ฆ๊ฐ์‹, D : ์‹คํ–‰ ๊ตฌ๋ฌธ


์œ„ ์˜ˆ์‹œ๋Š” for ๋ฌธ ์š”์†Œ๋“ค์˜ ๊ฐ ์œ„์น˜๋ฅผ ์•ŒํŒŒ๋ฒณ์œผ๋กœ ์ •์˜ํ•œ ๊ฒƒ์ด๋‹ค.

for ๋ฌธ์˜ ๋ณ€์ˆ˜ ์ดˆ๊ธฐํ™”(A)๋Š” for ๋ฌธ ์‹œ์ž‘๊ณผ ํ•จ๊ป˜ ์ฒ˜์Œ์—๋งŒ ์‹คํ–‰๋˜๊ณ  ์ดํ›„ ๋ฐ˜๋ณต ์‹คํ–‰ํ•˜์ง€ ์•Š๋Š”๋‹ค. ์ดํ›„ ์กฐ๊ฑด์‹(B)์œผ๋กœ ๋„˜์–ด์™€ ์ œ์‹œ๋œ ์กฐ๊ฑด์˜ ๋ฐ˜ํ™˜ ๊ฐ’์ด true ์ธ์ง€๋ฅผ ๊ตฌ๋ถ„ํ•˜์—ฌ true ์ผ ๊ฒฝ์šฐ, ๊ตฌ๋ฌธ(D)์„ ์‹คํ–‰ํ•œ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ์ฆ๊ฐ์‹(C)์œผ๋กœ ๋„˜์–ด์™€ ์ฆ๊ฐ์‹์— ํ•ด๋‹นํ•˜๋Š” ๋ณ€ํ™”๋ฅผ ์ค€๋‹ค.

์ดํ›„์—” ๋‹ค์‹œ ์กฐ๊ฑด์‹์œผ๋กœ ๋„˜์–ด์™€ ์กฐ๊ฑด์„ ํ™•์ธํ•˜๊ณ , ๊ตฌ๋ฌธ์„ ์‹คํ–‰ํ•œ ๋’ค, ๋‹ค์‹œ ์ฆ๊ฐ์‹์„ ์‹คํ–‰ํ•˜๋Š” ๊ฒƒ์„ ๋ฐ˜๋ณตํ•œ๋‹ค. ํ•ด๋‹น ์ˆœ์„œ๋ฅผ ์ž‘์„ฑํ•˜๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

: A โ†’ B โ†’ D โ†’ ( C โ†’ B โ†’ D โ†’ ) (์ดํ›„ ๊ด„ํ˜ธ ์•ˆ ๋ฐ˜๋ณต)

for ๋ฌธ์ด ํ•ด๋‹น ์ˆœ์„œ๋กœ ์ž‘๋™ํ•˜๊ธฐ ๋•Œ๋ฌธ์—, ์ด๋ฅผ ๊ณ ๋ คํ•˜์—ฌ for (let i = 0; i < arr.length; i++) ์™€ ๊ฐ™์€ ๋ณดํŽธ์ ์ธ ํ˜•ํƒœ๊ฐ€ ์•„๋‹ˆ๋ผ ์œ ๋™์ ์œผ๋กœ ์กฐ๊ฑด์‹๊ณผ ์ฆ๊ฐ์‹์„ ์ž‘์„ฑํ•˜์—ฌ for ๋ฌธ์„ ๋”์šฑ ํšจ๊ณผ์ ์œผ๋กœ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.


์ด์–ด์„œ for ๋ฌธ ๊ตฌ์„ฑ ์š”์†Œ์˜ ๊ธฐ๋Šฅ์— ๋Œ€ํ•ด ์ž์„ธํžˆ ์•Œ์•„๋ณด์ž.

๊ตฌ์„ฑ ์š”์†Œ ์ค‘ ๋ณ€์ˆ˜ ์ดˆ๊ธฐํ™”(์œ„ ์˜ˆ์‹œ A) ๋ถ€๋ถ„์˜ ๊ฒฝ์šฐ, ๋ฐฐ์—ด์˜ ์ธ๋ฑ์Šค ๋ณ€์ˆ˜์˜ ์ดˆ๊ธฐํ™” ์™ธ์—๋„ ํ•ด๋‹น ๋ฐ˜๋ณต๋ฌธ์—์„œ ์‚ฌ์šฉ๋  ๋ณ€์ˆ˜์˜ ์ดˆ๊ธฐํ™”์— ์‚ฌ์šฉ๋œ๋‹ค.

let arr = [1, 2, 3, 4, 5]

for (let i = 0, len = arr.length; i < len; i++) {
  console.log(arr[i])
}


ํ•ด๋‹น ์˜ˆ์‹œ์˜ ๊ฒฝ์šฐ, ์กฐ๊ฑด์‹์—์„œ ํ˜ธ์ถœ๋˜๋Š” ๋ฐฐ์—ด์˜ ์†์„ฑ์ธ ๊ธธ์ด(length)์— ๋Œ€ํ•ด ํŠน์ • ๋ณ€์ˆ˜(len)๋กœ ๋ฏธ๋ฆฌ ํ• ๋‹นํ•˜์—ฌ ์กฐ๊ฑด์‹์ด ์ˆœํ™˜ํ•  ๋•Œ๋งˆ๋‹ค ๋ฐฐ์—ด ๊ธธ์ด๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ๊ณผ์ •์„ ์ƒ๋žตํ•˜๋„๋ก ํ•  ์ˆ˜ ์žˆ๋‹ค. ์ด๋•Œ, ๊ฐ ๋ณ€์ˆ˜์˜ ์ดˆ๊ธฐํ™”๋Š” ์ฝค๋งˆ(,)๋ฅผ ํ†ตํ•ด ๊ตฌ๋ถ„ํ•œ๋‹ค.

๋‘ ๋ฒˆ์งธ๋กœ, ์กฐ๊ฑด์‹(์œ„ ์˜ˆ์‹œ B)์˜ ๊ฒฝ์šฐ ์ฃผ๋กœ ์ดˆ๊ธฐ ๋ณ€์ˆ˜์˜ ์ƒํƒœ ํ‰๊ฐ€์— ์‚ฌ์šฉ๋˜์ง€๋งŒ, ์™ธ๋ถ€ ์ „์—ญ ๋ณ€์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๋“ฑ์˜ ๋ฐฉ์‹์œผ๋กœ๋„ ์กฐ๊ฑด์„ ์ž์œ ๋กญ๊ฒŒ ์„ค์ •ํ•  ์ˆ˜ ์žˆ๋‹ค.

๋˜ํ•œ, ์กฐ๊ฑด์‹์˜ ๊ฒฝ์šฐ์—๋Š” ์ƒ๋žตํ•  ์ˆ˜๋„ ์žˆ์œผ๋ฉฐ, ํ•ด๋‹น ๊ฒฝ์šฐ์—๋Š” break ๋ฅผ ๋ฐ˜๋ณต๋ฌธ ๋‚ด๋ถ€์— ์‚ฝ์ž…ํ•ด์•ผ ํ•œ๋‹ค.

๐Ÿ’ก break ๋ฌธ๊ณผ continue ๋ฌธ

๋ฐ˜๋ณต๋ฌธ์—์„œ ๋ฐ˜๋ณต์„ ์ œ์–ดํ•  ์ˆ˜ ์žˆ๋Š” ๊ตฌ๋ฌธ์ด๋‹ค.

break ๋ฌธ์€ ๋ฐ˜๋ณต๋ฌธ์„ ๋” ์ด์ƒ ๋ฐ˜๋ณตํ•˜์ง€ ์•Š๊ณ , ๋ฐ”๋กœ ํ•ด๋‹น ๋ฐ˜๋ณต๋ฌธ์„ ๋๋‚ด๋ผ๋Š” ์˜๋ฏธ๋ฅผ ๊ฐ–๋Š”๋‹ค.

break ๋ฌธ์˜ ๊ฒฝ์šฐ, ์กฐ๊ฑด๋ฌธ(if ๋“ฑ)์„ ํ™œ์šฉํ•˜์—ฌ ํŠน์ • ์กฐ๊ฑด์— ํ•ด๋‹นํ•˜๋Š” ๊ฒฝ์šฐ ์กฐ๊ฑด๋ฌธ์„ ๋๋‚ด๋Š” ๊ธฐ๋Šฅ์„ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ๋‹ค.

let sum = 0;
for (let number=1;; number++) // ์กฐ๊ฑด์‹ ์ƒ๋žต ๊ฐ€๋Šฅ
{
    if ( number == 5) // 5์ผ ๊ฒฝ์šฐ break ์‹คํ–‰
    {
        break;
    }
      sum = sum+number;
      console.log(sum) // ํ•ฉ์ด 10์ด ๋˜๊ณ  ๋ฐ˜๋ณต๋ฌธ ์ข…๋ฃŒ
}


continue ๋ฌธ์€ break ๋ฌธ๊ณผ ๋‹ฌ๋ฆฌ ๋ฐ˜๋ณต๋ฌธ์„ ๋๋‚ด์ง€ ์•Š์ง€๋งŒ, continue ๋ฌธ์„ ๊ธฐ์ค€์œผ๋กœ ์•„๋ž˜์— ์žˆ๋Š” ๊ตฌ๋ฌธ์„ ๋„˜๊ธฐ๊ณ  ๋ฐ˜๋ณต๋ฌธ์„ ์ง„ํ–‰ํ•œ๋‹ค.

ํ•ด๋‹น ๊ฒฝ์šฐ์—๋„ ์กฐ๊ฑด๋ฌธ(if ๋“ฑ)์„ ํ™œ์šฉํ•˜์—ฌ ํŠน์ • ์กฐ๊ฑด์— ํ•ด๋‹นํ•˜๋Š” ๊ฒฝ์šฐ๋งŒ ๋„˜์–ด๊ฐ€๊ณ  ๋ฐ˜๋ณต๋ฌธ์„ ์ง„ํ–‰ํ•˜๋Š” ๊ธฐ๋Šฅ์„ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ๋‹ค.

let sum = 0;
for (let number=1; number<=10; number++)
{
    if ( number == 5) // 5์ผ ๊ฒฝ์šฐ continue ์‹คํ–‰
    {
        continue;
    }
      sum = sum+number;
      console.log(sum) // ํ•ฉ์ด 15๊ฐ€ ๋˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ์‚ฌ๋ผ์ง
}


break ๋ฌธ๊ณผ continue ๋ฌธ์€ for ๋ฌธ ๋ง๊ณ ๋„ ๋‹ค๋ฅธ ๋ฐ˜๋ณต๋ฌธ(while, do~while ๋ฌธ)์—์„œ๋„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.

๐Ÿ”– ์ถœ์ฒ˜

break & continue : ์—ฐ๊ธˆ์ˆ ์‚ฌ๋‹˜ ๋ธ”๋กœ๊ทธ : ๋ฐ˜๋ณต_break/continue๋ฌธ


๋งˆ์ง€๋ง‰์œผ๋กœ, ์ฆ๊ฐ์‹(์œ„ ์˜ˆ์‹œ C)์˜ ๊ฒฝ์šฐ์—๋Š” ์ฃผ๋กœ ์ดˆ๊ธฐ ๋ณ€์ˆ˜์˜ ์ฆ๊ฐ์— ์‚ฌ์šฉ๋œ๋‹ค. ์ฆ๊ฐ์‹ ๋˜ํ•œ ์„ ํƒ ์‚ฌํ•ญ์ด๋ฉฐ ์ƒ๋žต ๊ฐ€๋Šฅํ•˜๊ณ , ์ดˆ๊ธฐ ๋ณ€์ˆ˜ ์™ธ์—๋„ ๋‹ค๋ฅธ ์š”์†Œ์˜ ์ฆ๊ฐ์—๋„ ์‚ฌ์šฉ ๊ฐ€๋Šฅํ•˜๋‹ค.

๐Ÿ”– ์ถœ์ฒ˜

for ๋ฌธ์˜ ๊ตฌ์กฐ : jun.hansung : JavaScript For ๋ฃจํ”„(Loop)


์•ž์—์„œ ์•Œ์•„๋ณธ ๊ธฐ๋ณธ์ ์ธ for ๋ฌธ ์ด์™ธ์—๋„ ๋‹ค์–‘ํ•œ ํ˜•ํƒœ๊ฐ€ ์žˆ๋Š”๋ฐ, for...in ๋ฌธ๊ณผ for...of ๋ฌธ ๋“ฑ์ด ์ด์— ํ•ด๋‹นํ•œ๋‹ค.

for...in ๋ฌธ์€ ์—ด๊ฑฐ ๊ฐ€๋Šฅํ•œ ์†์„ฑ(enumerable)์ด ์žˆ๋Š” ๊ฐ์ฒด๋“ค์— ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๊ณ , ๊ฐ์ฒด์˜ ๊ฒฝ์šฐ ๊ฐ์ฒด ๋‚ด ํ”„๋กœํผํ‹ฐ๋“ค์„ ์ˆœํ™˜ํ•˜๋ฉด์„œ key ๊ฐ’์— ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ๋‹ค.

let obj = {
    a: 1,
    b: 2,
    c: 3
};
for (let i in obj) { // i = key ๊ฐ’
    console.log(i + ': ' +obj[i]);
};
// output : a: 1, b: 2, c: 3


for...of ๋ฌธ์€ ๋ฐ˜๋ณต์ž(iterator)๊ฐ€ ์žˆ๋Š” ์š”์†Œ๋“ค์€ ๋ชจ๋‘ ์ˆœํ™˜ํ•  ์ˆ˜ ์žˆ์œผ๋ฉฐ, String ๊ณผ ๊ฐ™์€ ๋ฌธ์ž์—ด๋„ ๊ฐ ๋ฌธ์ž๋ฅผ ์ˆœํ™˜ํ•  ์ˆ˜ ์žˆ๋‹ค.

let arr = ["a", "b", "c"];
for (let i of arr) {
    console.log(i);
};
// a, b, c
let fruit = 'orange';
for (let i of fruit) { // i = 'orange'์˜ ๊ฐ ๋ฌธ์ž ๋‹จ์œ„
    console.log(i);
};
// o, r, a, n, g, e

๐Ÿ”– ์ถœ์ฒ˜

for...in, for...of : Swimjiy devlog : [JavaScript] forEach, for...in, for...of ์ •๋ฆฌ


๐Ÿ’ก for...in ์‚ฌ์šฉ ์‹œ ์ฃผ์˜์‚ฌํ•ญ

for...in ์€ ๋ฐฐ์—ด์˜ ์ˆœํšŒ์— ์‚ฌ์šฉํ•˜์ง€ ์•Š๋„๋ก ํ•œ๋‹ค.

๊ทธ ์ด์œ ๋Š” ๋ณดํ†ต ๊ฐ์ฒด ํ”„๋กœํผํ‹ฐ๋ฅผ ์ˆœํšŒํ•˜๋Š”๋ฐ ์‚ฌ์šฉํ•˜๋Š” for...in ์€ ๋ฐฐ์—ด ์š”์†Œ๋ฅผ ์ˆœํšŒํ•  ๊ฒฝ์šฐ ๋ชจ๋“  ํ”„๋กœํผํ‹ฐ๋ฅผ ์ˆœํšŒํ•˜๊ธฐ์— ์ผ๋ฐ˜์ ์ธ for ๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ ๋ณด๋‹ค ๋Š๋ฆฐ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์—ฌ์ค€๋‹ค.

๋˜ํ•œ, ๋ธŒ๋ผ์šฐ์ €๋งˆ๋‹ค ์ˆœํšŒ ์ˆœ์„œ๊ฐ€ ๋‹ค๋ฅด๊ธฐ ๋•Œ๋ฌธ์—, ๋งค๋ฒˆ index ์ˆœ์„œ๋Œ€๋กœ ์ˆ˜ํ–‰๋˜์ง€ ์•Š์„ ์ˆ˜ ์žˆ๋‹ค๋Š” ๋ฌธ์ œ์ ์ด ์กด์žฌํ•œ๋‹ค.

์œ„์™€ ๊ฐ™์€ ์ด์œ ๋กœ ๋ฐฐ์—ด์˜ ์ˆœํšŒ์—์„œ๋Š” for...in ์˜ ์‚ฌ์šฉ์„ ์ง€์–‘ํ•œ๋‹ค.

๐Ÿ”– ์ถœ์ฒ˜

for...in ์ฃผ์˜์‚ฌํ•ญ : TOASTUI : ์•ˆํ‹ฐ ํŒจํ„ด


๐Ÿ’ก ๋ฐ˜๋ณต๋ฌธ๊ณผ ๋ฐฐ์—ด(Array)

๋ฐ˜๋ณต๋ฌธ๊ณผ ๋ฐฐ์—ด์€ ์ž์ฃผ ํ•จ๊ป˜ ์‚ฌ์šฉ๋˜๋Š”๋ฐ, ๊ทธ ์ด์œ ๋ฅผ ์ดํ•ดํ•˜๊ธฐ ์œ„ํ•ด ์ž๋ฃŒ ๊ตฌ์กฐ์™€ ํƒ์ƒ‰ ์•Œ๊ณ ๋ฆฌ์ฆ˜์— ๋Œ€ํ•ด ๊ฐ„๋‹จํžˆ ์•Œ์•„๋ณด์ž.

๋ฐฐ์—ด์˜ ์ž๋ฃŒ ๊ตฌ์กฐ์— ๋Œ€ํ•œ ๋‚ด์šฉ์€ ๋ฐฐ์—ด ๊ด€๋ จ ํฌ์ŠคํŒ…์— ์ž‘์„ฑ ํ–ˆ์œผ๋‹ˆ, ๊ฐ€์„œ ํ™•์ธํ•˜๊ณ  ์˜ค์ž!

๊ทธ๋ ‡๋‹ค๋ฉด ํƒ์ƒ‰ ์•Œ๊ณ ๋ฆฌ์ฆ˜๊ณผ ๋ฐ˜๋ณต๋ฌธ์„ ์—ฐ๊ด€์ง€์–ด์„œ ๊ฐœ๋…์„ ์ดํ•ดํ•ด๋ณด์ž. ํƒ์ƒ‰ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด๋ž€ ์ˆ˜๋งŽ์€ ๋ฐ์ดํ„ฐ ์ค‘ ์›ํ•˜๋Š” ๋ฐ์ดํ„ฐ๋ฅผ ์ฐพ๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์œผ๋กœ ์„ ํ˜•, ์ด์ง„, ํ•ด์‹œ ํƒ์ƒ‰๋ฒ• ๋“ฑ์ด ์ด์— ํ•ด๋‹นํ•œ๋‹ค. ๊ทธ ์ค‘ ์ง€๊ธˆ ์•Œ์•„๋ณผ ์„ ํ˜• ํƒ์ƒ‰๋ฒ•์€ ๋ฐ์ดํ„ฐ๋ฅผ ์ˆœ์„œ๋Œ€๋กœ ํ•˜๋‚˜์”ฉ ๊ฒ€์ƒ‰ํ•˜๋Š” ๋ฐฉ์‹์ด๋‹ค.

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

๊ทธ๋ ‡๊ธฐ ๋•Œ๋ฌธ์— ๋ฐฐ์—ด์˜ ๋งค ์š”์†Œ๋ฅผ ์ˆœํ™˜ํ•˜๋ฉด์„œ ๋ฐ์ดํ„ฐ๋ฅผ ํƒ์ƒ‰ํ•˜๋Š” ๋ฐ˜๋ณต๋ฌธ์ด ๋ฐฐ์—ด๊ณผ ์ž์ฃผ ์‚ฌ์šฉ๋œ๋‹ค๊ณ  ์ƒ๊ฐํ•  ์ˆ˜ ์žˆ์„ ๊ฒƒ์ด๋‹ค.


While ๋ฌธ๊ณผ do~while ๋ฌธ

while ๋ฌธ์€ for ๋ฌธ๊ณผ ์œ ์‚ฌํ•˜์ง€๋งŒ, ๋ฌธ๋ฒ•์ด๋‚˜ ๊ตฌ์กฐ์— ์žˆ์–ด์„œ ์ฐจ์ด๋ฅผ ๋ณด์ธ๋‹ค.

while ๋ฌธ์˜ ์ •ํ•ด์ง„ ๊ตฌ์กฐ๋Š” ์กฐ๊ฑด์„ ์ œ์‹œํ•˜๋Š” ๋ถ€๋ถ„๋งŒ ์กด์žฌํ•˜๊ณ , ๋‚˜๋จธ์ง€ ๋ถ€๋ถ„์€ ์œ ๋™์ ์œผ๋กœ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ๋‹ค.

๊ทธ๋ฆฌ๊ณ  do~while ๋ฌธ์˜ ๊ฒฝ์šฐ while ๋ฌธ๊ณผ ์œ ์‚ฌํ•˜์ง€๋งŒ, ์‹คํ–‰ ๊ตฌ์กฐ์— ์žˆ์–ด ์ฐจ์ด๋ฅผ ๋ณด์—ฌ์ค€๋‹ค.

์šฐ์„  while ๋ฌธ์„ ๋จผ์ € ์•Œ์•„๋ณด์ž.

whlie ๋ฌธ

while ๋ฌธ์€ ์กฐ๊ฑด๋ฌธ์ด ์ฐธ์ผ ๋•Œ ์‹คํ–‰๋˜๋Š” ๋ฐ˜๋ณต๋ฌธ์ด๊ณ . ๋ฌธ์žฅ์ด ์‹คํ–‰๋˜๊ธฐ ์ „ ์ฐธ๊ณผ ๊ฑฐ์ง“์„ ํŒ๋‹จํ•œ๋‹ค.

while ๋ฌธ์˜ ๋ฌธ๋ฒ•์€ ๊ฐ„๋žตํ•˜๊ฒŒ while (condition) {statement} ์œผ๋กœ ๊ตฌ์„ฑ๋˜๊ณ , condition ๋ถ€๋ถ„์ด true ์ด๋ฉด statement ๋ถ€๋ถ„์„ ๋ฐ˜๋ณต์ ์œผ๋กœ ์‹คํ–‰ํ•œ๋‹ค.

let i = 0 // ๋ณ€์ˆ˜ ์„ ์–ธ

while (i < 10) { // ์กฐ๊ฑด์‹
  console.log(i)
  i++ // ๋ณ€์ˆ˜ ์ฆ๊ฐ
}


์˜ˆ์‹œ๋ฅผ ๋ณด๋ฉด while ์˜ ๊ฒฝ์šฐ์—๋Š” for ๋ฌธ๊ณผ ๋‹ฌ๋ฆฌ ๋ณ€์ˆ˜ ์ดˆ๊ธฐํ™”๋‚˜ ์ฆ๊ฐ์‹์„ ์ž‘์„ฑํ•˜๋Š” ๊ตฌ๊ฐ„์ด ๊ณ ์ •์ ์ด์ง€ ์•Š๋‹ค. ๊ทธ๋ ‡๊ธฐ ๋•Œ๋ฌธ์—, ์ž์นซํ•˜๋ฉด ๋ฌดํ•œ ๋ฃจํ”„์˜ ๊ตฌ๊ฐ„์— ๋น ์งˆ ์ˆ˜ ์žˆ๋‹ค.

๋งŒ์•ฝ, ์ •ํ•ด์ง„ ๋ฐ˜๋ณต ํšŸ์ˆ˜๊ฐ€ ์žˆ๋‹ค๋ฉด while ๋ณด๋‹ค๋Š” for ๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ํšจ์œจ์ ์ผ ์ˆ˜ ์žˆ๋‹ค.

๋ฐ˜๋Œ€๋กœ ์ •ํ•ด์ง„ ์กฐ๊ฑด์„ ๋งŒ์กฑํ•  ๋•Œ๊นŒ์ง€ ์‹คํ–‰ํ•ด์•ผ ํ•˜๋Š” ๊ตฌ๋ฌธ์ด๋ผ๋ฉด for ๋ฌธ ๋ณด๋‹ค while ๋ฌธ์ด ํšจ์œจ์ ์ผ ์ˆ˜ ์žˆ๋‹ค.

์•ž์—์„œ๋„ ์–ธ๊ธ‰ํ–ˆ์ง€๋งŒ, while ๋ฌธ์˜ ๊ฒฝ์šฐ์—๋„ break ์™€ continue ๋ฌธ์„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.

while ๋ฌธ์˜ ์‹คํ–‰ ์ˆœ์„œ๋ฅผ ์•Œ์•„๋ณด๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

while (A) { // A : condition
	B // B : Statement
}


while ๋ฌธ์€ ๋‹จ์ˆœํ•˜๊ฒŒ ์กฐ๊ฑด(A) ๋ถ€๋ถ„์ด ํ†ต๊ณผ๋˜๋ฉด, ์ง€๋ฌธ(B)์„ ์‹คํ–‰ํ•˜๊ณ  ๋‹ค์‹œ ์กฐ๊ฑด์œผ๋กœ ์ˆœํ™˜ํ•˜๋Š” ๊ตฌ์กฐ๋ฅผ ๊ฐ–๋Š”๋‹ค.

do~while ๋ฌธ

do~while ๋ฌธ์€ while ๋ฌธ๊ณผ ์กฐ๊ฑด์˜ ์œ„์น˜๊ฐ€ ๋‹ค๋ฅด๋‹ค.

๊ทธ๋ ‡๊ธฐ ๋•Œ๋ฌธ์— do~while ๋ฌธ์€ ์กฐ๊ฑด ์—ฌ๋ถ€์™€ ์ƒ๊ด€ ์—†์ด ๋ฌด์กฐ๊ฑด ํ•œ ๋ฒˆ ์‹คํ–‰ํ•˜๊ณ  ๋ฐ˜๋ณต๋ฌธ์„ ์ง„ํ–‰ํ•œ๋‹ค.

do~while ๋ฌธ์˜ ๋ฌธ๋ฒ•์€ ๊ฐ„๋‹จํ•˜๊ฒŒ do { statement } while (condition) ์ด๊ณ  ๋‹ค์Œ๊ณผ ๊ฐ™์€ ์˜ˆ์‹œ๋กœ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ๋‹ค.

let i = 0;

do {
  console.log(i);
  i++;
} while (i < 10)


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

do {
	B
} while (A)


์œ„์™€ ๊ฐ™์ด ์‹คํ–‰ ๊ตฌ๋ฌธ(B)์„ ์กฐ๊ฑด์— ์ƒ๊ด€ ์—†์ด ์‹คํ–‰ํ•˜๊ณ  ์กฐ๊ฑด(A)์— ๊ฑธ๋ฆฌ๋ฏ€๋กœ while ๋ฌธ๊ณผ ๋‹ค๋ฅด๊ฒŒ ์กฐ๊ฑด์— ์ผ์น˜ํ•˜์ง€ ์•Š์•„๋„ ๋ฌด์กฐ๊ฑด์ ์œผ๋กœ ํ•œ ๋ฒˆ์€ ์‹คํ–‰ํ•˜๋Š” ๊ฒƒ์ด๋‹ค.

๐Ÿ”– ์ „์ฒด์ ์ธ ์ฐธ๊ณ 

๋ฐ˜๋ณต๋ฌธ : ZeroCho๋‹˜ ๊ฐœ์ธ ๋ธ”๋กœ๊ทธ : ๋ฐ˜๋ณต๋ฌธ(loop - while, for, do)

profile
์ด์œ ์— ์ง‘์ฐฉํ•˜๋Š” ํ”„๋ก ํŠธ์—”๋“œ ๊ฐœ๋ฐœ์ž ์ง€๋ง์ƒ์ž…๋‹ˆ๋‹ค ๐Ÿง

0๊ฐœ์˜ ๋Œ“๊ธ€