JavaScript์์ for ๋ฃจํ๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ด๊ณ ๋ง์ด ์ฌ์ฉ๋๋ ๋ฐ๋ณต๋ฌธ ์ค ํ๋์ ๋๋ค. ๋ฐ๋ณต๋ฌธ์ ์ฝ๋๋ฅผ ์ฌ๋ฌ ๋ฒ ์คํํ ์ ์๋ ๋ฐฉ๋ฒ์ ์ ๊ณตํ์ฌ, ๋์ผํ ์์ ์ ์ฌ๋ฌ ๋ฒ ์ํํ ๋ ๋งค์ฐ ์ ์ฉํฉ๋๋ค. ์ด๋ฒ ๊ธ์์๋ JavaScript์ for ๋ฃจํ์ ๊ธฐ๋ณธ ๊ตฌ์กฐ์ ๋ค์ํ ํ์ฉ ์์ ๋ฅผ ํตํด ์ด๋ป๊ฒ ์ฌ์ฉ๋๋์ง ์์๋ณด๊ฒ ์ต๋๋ค.
JavaScript์ for ๋ฃจํ๋?
for
๋ฃจํ๋ ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ ๋๊น์ง ์ฝ๋๋ฅผ ๋ฐ๋ณต ์คํํ๋ ๊ตฌ์กฐ์
๋๋ค. ๋ฃจํ๋ฅผ ์ ์ดํ๊ธฐ ์ํ ์ด๊ธฐ๊ฐ, ์กฐ๊ฑด์, ์ฆ๊ฐ์์ ์ค์ ํ์ฌ ์ํ๋ ํ์๋งํผ ๋ฐ๋ณต์ ์ํํ ์ ์์ต๋๋ค.
for ๋ฃจํ ๊ธฐ๋ณธ ๊ตฌ์กฐ
for (์ด๊ธฐ๊ฐ; ์กฐ๊ฑด์; ์ฆ๊ฐ์) {
// ๋ฐ๋ณต ์คํํ ์ฝ๋
}
for ๋ฃจํ๋ ์ธ ๊ฐ์ง ์ฃผ์ ์์๋ก ๊ตฌ์ฑ๋ฉ๋๋ค:
- ์ด๊ธฐ๊ฐ: ๋ฃจํ๊ฐ ์์๋ ๋ ํ ๋ฒ๋ง ์คํ๋๋ ์ด๊ธฐ ์ค์ ์ ๋๋ค. ์ฃผ๋ก ๋ฐ๋ณต ํ์๋ฅผ ์ ์ดํ๋ ๋ณ์ ์ด๊ธฐํ๊ฐ ์ด๊ณณ์์ ์ด๋ฃจ์ด์ง๋๋ค.
- ์กฐ๊ฑด์: ๊ฐ ๋ฐ๋ณต์ด ์์๋๊ธฐ ์ ์ ํ๊ฐ๋๋ฉฐ, ์กฐ๊ฑด์์ด
true
์ผ ๊ฒฝ์ฐ์๋ง ๋ฃจํ๊ฐ ์คํ๋ฉ๋๋ค.false
์ผ ๊ฒฝ์ฐ ๋ฐ๋ณต์ด ์ข ๋ฃ๋ฉ๋๋ค. - ์ฆ๊ฐ์: ๋ฃจํ๊ฐ ํ ๋ฒ ์คํ๋ ๋๋ง๋ค ์คํ๋๋ฉฐ, ์ฃผ๋ก ๋ณ์๋ฅผ ์ฆ๊ฐ์ํค๊ฑฐ๋ ๊ฐ์์ํต๋๋ค.
for ๋ฃจํ ์์
// 1๋ถํฐ 5๊น์ง ์ถ๋ ฅํ๋ for ๋ฃจํ
for (let i = 1; i <= 5; i++) {
console.log(i);
}
์ ์ฝ๋์์๋ i
๋ณ์๊ฐ 1๋ถํฐ ์์ํ์ฌ 5๊น์ง ์ฆ๊ฐํ๋ฉด์ ๊ฐ ๊ฐ์ ์ถ๋ ฅํฉ๋๋ค. i++
๋ ๋ฐ๋ณต์ด ์คํ๋ ๋๋ง๋ค i
๊ฐ์ 1์ฉ ์ฆ๊ฐ์ํต๋๋ค. ์กฐ๊ฑด์ i <= 5
๊ฐ false
๊ฐ ๋๋ ์๊ฐ, ๋ฃจํ๋ ์ข
๋ฃ๋ฉ๋๋ค.
for ๋ฃจํ์ ๋ค์ํ ํ์ฉ
for ๋ฃจํ๋ ๋จ์ํ ์ซ์ ๋ฐ๋ณต ์ธ์๋ ๋ฐฐ์ด์ด๋ ๊ฐ์ฒด์ ๊ฐ์ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋ฉ๋๋ค. ํนํ, ๋ฐ์ดํฐ๋ฅผ ์ํํ๊ฑฐ๋ ๋์ ๊ฐ์ ๊ณ์ฐํ๋ ๋ฑ์ ์์ ์์ ์์ฃผ ์ฌ์ฉ๋ฉ๋๋ค.
1. ๋ฐฐ์ด ์ํ
๋ฐฐ์ด์ ๊ฐ ์์๋ฅผ ์ํํ๋ฉด์ ์์ ์ ์ํํ ๋, for ๋ฃจํ๋ ๋งค์ฐ ์ ์ฉํฉ๋๋ค. ๋ค์ ์์๋ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ถ๋ ฅํ๋ ๋ฐฉ๋ฒ์ ๋๋ค.
// ๋ฐฐ์ด ์์ ์ถ๋ ฅ ์์
const fruits = ['์ฌ๊ณผ', '๋ฐ๋๋', '๋ธ๊ธฐ', '์ค๋ ์ง'];
for (let i = 0; i < fruits.length; i++) {
console.log(fruits[i]);
}
์ด ์ฝ๋์์๋ ๋ฐฐ์ด์ ๊ธธ์ด๋งํผ ๋ฃจํ๊ฐ ๋ฐ๋ณต๋๋ฉฐ, ๋ฐฐ์ด์ ๊ฐ ์์๋ฅผ ์ถ๋ ฅํฉ๋๋ค. fruits.length
๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ๊ตฌํ๊ณ , ๊ฐ ์์์ ์ ๊ทผํ๊ธฐ ์ํด ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํฉ๋๋ค.
2. ๋์ ๊ฐ ๊ณ์ฐ
for ๋ฃจํ๋ฅผ ์ฌ์ฉํด ๋ฐฐ์ด์ ์ซ์ ์์๋ฅผ ๋ชจ๋ ๋ํ๋ ๋์ ๊ณ์ฐ์ ํ ์ ์์ต๋๋ค.
// ๋ฐฐ์ด ์์ ํฉ๊ณ ๊ณ์ฐ
const numbers = [10, 20, 30, 40];
let sum = 0;
for (let i = 0; i < numbers.length; i++) {
sum += numbers[i];
}
console.log('ํฉ๊ณ:', sum);
์ ์์์์๋ ๋ฐฐ์ด numbers
์ ๋ชจ๋ ์์๋ฅผ ์ํํ๋ฉด์ sum
์ ๋์ ํ์ฌ ํฉ๊ณ๋ฅผ ๊ณ์ฐํฉ๋๋ค. ์ต์ข
์ ์ผ๋ก ๋ฐฐ์ด์ ๋ชจ๋ ์ซ์๊ฐ ๋ํด์ ธ ์ถ๋ ฅ๋ฉ๋๋ค.
3. ์ง์์ ํ์ ๊ตฌ๋ถ
for ๋ฃจํ๋ฅผ ์ฌ์ฉํ์ฌ ์ฃผ์ด์ง ๋ฒ์ ๋ด์ ์ง์์ ํ์๋ฅผ ๊ตฌ๋ถํ ์ ์์ต๋๋ค. ์๋ ์์๋ 1๋ถํฐ 10๊น์ง์ ์ซ์ ์ค ์ง์์ ํ์๋ฅผ ์ถ๋ ฅํ๋ ์ฝ๋์ ๋๋ค.
// ์ง์์ ํ์ ๊ตฌ๋ถ
for (let i = 1; i <= 10; i++) {
if (i % 2 === 0) {
console.log(i + '๋ ์ง์์
๋๋ค.');
} else {
console.log(i + '๋ ํ์์
๋๋ค.');
}
}
์ด ์ฝ๋๋ i % 2 === 0
์ ํตํด i
๊ฐ ์ง์์ธ์ง ํ์ธํ๊ณ , ํด๋นํ๋ ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํฉ๋๋ค. ์ง์๊ฐ ์๋ ๊ฒฝ์ฐ์๋ ํ์๋ก ํ๋จํ์ฌ ๋ค๋ฅธ ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
for ๋ฃจํ์ ๋ค๋ฅธ ๋ฐ๋ณต๋ฌธ ๋น๊ต
JavaScript์๋ for
๋ฃจํ ์ธ์๋ ๋ฐ๋ณต๋ฌธ์ด ์ฌ๋ฌ ๊ฐ์ง ์์ต๋๋ค. while
๋ฃจํ, for...of
๋ฃจํ, for...in
๋ฃจํ ๋ฑ์ด ์๋๋ฐ, ๊ฐ๊ฐ์ ํน์ง๊ณผ ์ฌ์ฉ ๋ฐฉ๋ฒ์ด ๋ค๋ฆ
๋๋ค.
1. while ๋ฃจํ
while
๋ฃจํ๋ ์ฃผ์ด์ง ์กฐ๊ฑด์ด ์ฐธ์ผ ๋๋ง ๊ณ์ํด์ ๋ฐ๋ณตํฉ๋๋ค. ์กฐ๊ฑด์ด false
๊ฐ ๋๋ฉด ๋ฐ๋ณต์ด ์ข
๋ฃ๋ฉ๋๋ค. for
๋ฃจํ์ ๋ฌ๋ฆฌ, ์ด๊ธฐ๊ฐ๊ณผ ์ฆ๊ฐ์์ด ๋ณ๋๋ก ์กด์ฌํ์ง ์์ต๋๋ค.
// while ๋ฃจํ ์์
let i = 1;
while (i <= 5) {
console.log(i);
i++;
}
์ ์์์์๋ i
๊ฐ 1๋ถํฐ ์์ํ์ฌ ์กฐ๊ฑด์ด ์ฐธ์ผ ๋์ 5๊น์ง ์ถ๋ ฅํฉ๋๋ค. i++
๋ ๋ฃจํ๊ฐ ๋๋ ๋๋ง๋ค ๊ฐ์ ์ฆ๊ฐ์ํต๋๋ค.
2. for...of ๋ฃจํ
for...of
๋ฃจํ๋ ๋ฐฐ์ด์ด๋ ๋ฌธ์์ด๊ณผ ๊ฐ์ ์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด๋ฅผ ์ํํ ๋ ์ฌ์ฉ๋ฉ๋๋ค. ๋ฐฐ์ด ์์์ ์ง์ ์ ๊ทผํ ์ ์์ด, ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ ํ์๊ฐ ์์ต๋๋ค.
// for...of ์์
const fruits = ['์ฌ๊ณผ', '๋ฐ๋๋', '๋ธ๊ธฐ'];
for (const fruit of fruits) {
console.log(fruit);
}
์ด ์ฝ๋๋ for...of
๋ฅผ ์ฌ์ฉํด ๋ฐฐ์ด fruits
์ ๊ฐ ์์๋ฅผ ์ํํ๋ฉด์ ์ถ๋ ฅํฉ๋๋ค. ๋ฐฐ์ด์ ๊ฐ ์์์ ์ง์ ์ ๊ทผํ ์ ์์ด ๊ฐ๊ฒฐํ๊ฒ ์์ฑํ ์ ์์ต๋๋ค.
3. for...in ๋ฃจํ
for...in
๋ฃจํ๋ ๊ฐ์ฒด์ ์์ฑ์ ์ํํ ๋ ์ฃผ๋ก ์ฌ์ฉ๋ฉ๋๋ค. ๊ฐ์ฒด์ ํค ๊ฐ์ ์ ๊ทผํ ์ ์์ผ๋ฉฐ, ๋ฐฐ์ด์ ์ธ๋ฑ์ค์๋ ์ฌ์ฉํ ์ ์์ต๋๋ค.
// for...in ์์
const person = { name: 'John', age: 30, city: 'New York' };
for (const key in person) {
console.log(key + ': ' + person[key]);
}
์ด ์์์์๋ ๊ฐ์ฒด person
์ ๊ฐ ์์ฑ ํค์ ๊ฐ์ ์ถ๋ ฅํฉ๋๋ค. for...in
์ ๊ฐ์ฒด์ ๋ชจ๋ ์์ฑ์ ์ํํ ์ ์์ด ์ ์ฉํฉ๋๋ค.
for ๋ฃจํ์ ํ์ฅ
for
๋ฃจํ๋ ๋งค์ฐ ๊ฐ๋ ฅํ๊ณ ์ ์ฐํ ๋ฐ๋ณต๋ฌธ์
๋๋ค. ๊ฐ๋จํ ์ซ์ ๋ฐ๋ณต๋ถํฐ ๋ณต์กํ ๋ฐ์ดํฐ ๊ตฌ์กฐ ์ฒ๋ฆฌ๊น์ง ๋ค์ํ ์์
์ ์ํํ ์ ์์ต๋๋ค. ๋ํ, break
์ continue
๊ฐ์ ์ ์ด๋ฌธ๊ณผ ๊ฒฐํฉํ์ฌ ๋ฐ๋ณต ํ๋ฆ์ ์ ์ดํ ์ ์์ต๋๋ค.
1. break ๋ฌธ
break
๋ฌธ์ ์ฌ์ฉํ๋ฉด ๋ฐ๋ณต๋ฌธ์ ์กฐ๊ธฐ ์ข
๋ฃํ ์ ์์ต๋๋ค.
// ํน์ ์กฐ๊ฑด์์ ๋ฐ๋ณต ์ข
๋ฃ
for (let i = 1; i <= 10; i++) {
if (i === 5) {
break; // i๊ฐ 5์ผ ๋ ๋ฃจํ ์ข
๋ฃ
}
console.log(i);
}
์ ์ฝ๋์์๋ i
๊ฐ 5์ผ ๋ break
๋ฌธ์ ๋ง๋ ๋ฐ๋ณต์ด ์ข
๋ฃ๋ฉ๋๋ค.
2. continue ๋ฌธ
continue
๋ฌธ์ ์ฌ์ฉํ๋ฉด ํด๋น ๋ฐ๋ณต์ ๊ฑด๋๋ฐ๊ณ ๋ค์ ๋ฐ๋ณต์ผ๋ก ๋์ด๊ฐ ์ ์์ต๋๋ค.
// ํน์ ์กฐ๊ฑด์์ ๋ฐ๋ณต ๊ฑด๋๋ฐ๊ธฐ
for (let i = 1; i <= 10; i++) {
if (i === 5) {
continue; // i๊ฐ 5์ผ ๋๋ง ๊ฑด๋๋ฐ๊ธฐ
}
console.log(i);
}
์ ์ฝ๋์์๋ i
๊ฐ 5์ผ ๋ ์ถ๋ ฅ๋์ง ์๊ณ , ๋๋จธ์ง ๊ฐ๋ค์ ๋ชจ๋ ์ถ๋ ฅ๋ฉ๋๋ค.
๊ฒฐ๋ก
JavaScript์ for ๋ฃจํ๋ ๋ฐ๋ณต ์์
์ ์ฒ๋ฆฌํ๋ ๊ธฐ๋ณธ์ ์ธ ๋๊ตฌ๋ก, ๋งค์ฐ ๋ค์ํ ์ฉ๋๋ก ์ฌ์ฉ๋ ์ ์์ต๋๋ค. ๋ฐฐ์ด ์ํ, ๊ฐ ๋์ , ์กฐ๊ฑด ์ฒ๋ฆฌ ๋ฑ ๋ค์ํ ์ํฉ์์ ํ์ฉํ ์ ์์ผ๋ฉฐ, break
์ continue
๊ฐ์ ์ ์ด๋ฌธ๊ณผ ํจ๊ป ์ฌ์ฉํ๋ฉด ๋์ฑ ์ ์ฉํ๊ฒ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด๋ฒ ๊ธ์์๋ for ๋ฃจํ์ ๊ธฐ๋ณธ์ ์ธ ๊ตฌ์กฐ์ ์ฌ๋ฌ ๊ฐ์ง ํ์ฉ ๋ฐฉ๋ฒ์ ์์๋ณด์์ต๋๋ค. ์ด๋ฅผ ๋ฐํ์ผ๋ก ํจ์จ์ ์ธ ๋ฐ๋ณต๋ฌธ์ ์์ฑํด๋ณด์ธ์!
๋๊ธ ์ฐ๊ธฐ