์๋ฐ์คํฌ๋ฆฝํธ์ ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฅ์ ๊ฐ๊ฐ์ ์ฌ์ฉ๋ฒ, ํน์ง ๋ฑ์ ๋ํ ๋ด์ฉ์ ๋๋ค. ๐
๋ฐ๋ณต๋ฌธ(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
์ ์ฌ์ฉ์ ์ง์ํ๋ค.๐ ์ถ์ฒ
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)