๐ค Flow constrol (์ ์ดํ๋ฆ, ํ๋ฆ์ ์ด) ๋?
- ๋ช ๋ นํ ํ๋ก๊ทธ๋จ์ ๊ฐ๋ณ ๋ช ๋ น๋ฌธ, ๋ช ๋ น ๋๋ ํจ์ ํธ์ถ์ด ์คํ๋๊ฑฐ๋ ํ๊ฐ๋๋ ์์
- 5๊ฐ์ง ์ ์ดํ๋ฆ์ ์ข
๋ฅ
goto : ๋ค๋ฅธ ๊ตฌ๋ฌธ์์ ์์-> ๊ฐ๋ฐ ์ค๋ฅ ๋ฐ์ํ ์ ์์.- choice : ์ผ๋ถ ์กฐ๊ฑด์ด ์ถฉ์กฑ๋๋ ๊ฒฝ์ฐ์๋ง ์ผ๋ จ์ ๋ช ๋ น๋ฌธ ์คํ -> If-else / switch
- loop : ์ด๋ค ์กฐ๊ฑด์ด ์ถฉ์กฑ๋ ๋๊น์ง ์ผ๋ จ์ ๋ช ๋ น๋ฌธ์ 0ํ ์ด์ ์คํ -> Collection loop / General lop
- continue : ํ์ฌ ์คํ ๊ตฌ๋ฌธ์์ ๋จ์ด์ง ํ ๊ตฌ๋ฌธ์ ์งํฉ์ ์คํ -> Loop continuation
- break : ํ๋ก๊ทธ๋จ ์คํ์ ์ค๋จ => Loop earyl exit, ํจ์ ์คํ ์ ์ง ]
ํํ์๊ณผ ๋ฌธ์ ๊ฐ๋
- ํํ์
- ์ด๋ค ๊ฐ์ผ๋ก ์ดํ๋๋ ์์์ ์ ํจํ ์ฝ๋ ๋จ์
- ํํ์์ด ํ๊ฐ๋๋ฉด, ์๋ก์ด ๊ฐ์ ์์ฑํ๊ฑฐ๋ ๊ธฐ์กด ๊ฐ์ ์ฐธ์กฐ
- ๊ฐ์ผ๋ก ํ๊ฐ๋ ์ ์๋ ๋ฌธ์ ๋ชจ๋ ํํ์
- ๋ฆฌํฐ๋ด ํํ์, ํจ์ ํํ์, ...
const ๋ณ์๋ช
= 'apple';
const ํจ์ = (์ธ์) => {
if(์ธ์ === 'apple'){
return '๐';
} else {
return 'โ';
}
};
ํจ์('apple')
- ๋ฌธ statement
- ํ๋ก๊ทธ๋จ์ ๊ตฌ์ฑํ๋ ๊ธฐ๋ณธ ๋จ์, ์ต์ ์คํ ๋จ์
- == ๋ช ๋ น๋ฌธ
- ์ ์ธ๋ฌธ, ํ ๋น๋ฌธ, ์ ์ด๋ฌธ, ๋ฐ๋ณต๋ฌธ, ๋ธ๋ญ๋ฌธ ...
let ๋ณ์๋ช
; //๋ณ์ ์ ์ธ๋ฌธ
๋ณ์๋ช
= 'apple'; //ํ ๋น๋ฌธ
function ํจ์() {} //ํจ์ ์ ์ธ๋ฌธ
if(true) { //์กฐ๊ฑด๋ฌธ
console.log('true');
}
while(false){ //๋ฐ๋ณต๋ฌธ
console.log('while');
}
- ๋ธ๋ญ๋ฌธ block statement
- ๋ช ๋ น๋ฌธ๋ค์ ๊ทธ๋ฃน์ผ๋ก ๋ฌถ์ ์ ์๋ ๋ธ๋ญ๋ฌธ
- ํ์์ ์ค๊ดํธ๋ก ๋ฌถ์ด์ ํํ
{
123;
const foo = 'apple';
function ํจ์() {
return 1;
}
}
- choice
- If..else
- ๋ ผ๋ฆฌ์กฐ๊ฑด์ ์ฐธ/๊ฑฐ์ง์ ๋ฐ๋ผ ๋ช ๋ น๋ฌธ์ ์คํํด์ผ ํ ๊ฒฝ์ฐ ์ฌ์ฉ
- if๋ฌธ์ ๋ ผ๋ฆฌ์กฐ๊ฑด์๋ true, false๋ก ํ๊ฐํ ์ ์๋ ํํ์ ๋์ ๊ฐ๋ฅ
- ๋ ผ๋ฆฌ์กฐ๊ฑด ์ฐธ์ธ ๊ฒฝ์ฐ, if๋ธ๋ญ๋ฌธ ์คํ / ๋ ผ๋ฆฌ์กฐ๊ฑด์ด ๊ฑฐ์ง์ธ ๊ฒฝ์ฐ, else๋ธ๋ก๋ฌธ ์คํ
- ํด๋น๊ฐ์ false๋ก ํ๊ฐ : false, undefined, null, 0, Nan, ""(empty string)
- ์ค์ ๋ก์ง์ ๊ตฌํํ ๋ ์ค์ฒฉ if๋ฌธ์ ์ฌ์ฉํ ์๋ ์์
- ๋งํด ํ์ธ๋ฌ์ ๋ฆฌํฉํ ๋ง ์๋ฃ
- nested conditional ์ง์
- Guard Clauses ํํ๋ก ๊ตฌํ โ๏ธ
- If..else
//nested conditional (์ง์)
const ์กฐ๊ฑด๋ฌธ = (์ธ์) => ์ธ์ === 1;
const ์กฐ๊ฑด๋ฌธ2 = (์ธ์) => ์ธ์ === 2;
const ํจ์ = (์ธ์) => {
if (์กฐ๊ฑด๋ฌธ(์ธ์)) {
return 1;
} else if (์กฐ๊ฑด๋ฌธ2(์ธ์)) {
return 2;
} else return 3;
};
ํจ์(2);
//Guard Clauses (๊ถ์ฅ)
const ์กฐ๊ฑด๋ฌธ = (์ธ์) => ์ธ์ === 1;
const ์กฐ๊ฑด๋ฌธ2 = (์ธ์) => ์ธ์ === 2;
const ํจ์ = (์ธ์) => {
if (์กฐ๊ฑด๋ฌธ(์ธ์)) return 1;
if (์กฐ๊ฑด๋ฌธ2(์ธ์)) return 2;
return 3;
};
ํจ์(2);
- switch
- switch์ ํํ์์ ์์ฑ, ๋ผ๋ฒจ์ด ํฌํจ๋ case์ ์ ์์ฑ
- default๋ ๋ผ๋ฒจ์์ด ์์ฑ
const foo = (parameter) => {
switch(parameter){
case 1:
return 1;
case 2:
case 3:
case 4:
return 4;
default:
return 0;
}
}
foo(3) __ 23
- Loop(interations)
- Loop early exit : break
- Loop continuation : continue
- Conditional loop
- ๋๋ถ๋ถ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์๋ ์ผ๋ถ ์กฐ๊ฑด์ด ๋ณ๊ฒฝ๋ ๋๊น์ง ๋ฃจํ๋ฅผ ๋ฐ๋ณตํ๋ ๊ตฌ์กฐ๊ฐ ์๋ค.
- ์ข
๋ฃ๋ ์ ์๋ ์กฐ๊ฑด์ด ์๋ ๊ฒฝ์ฐ, ๋ฌดํ ๋ฃจํ์ ๋น ์ง ์ ์๋ค.
- ์์ํ ๋ ์กฐ๊ฑด์ ํ๊ฐ (๋ณธ๋ฌธ ์๋ต ๊ฐ๋ฅ)
- while
- ์์ํ ๋ ์กฐ๊ฑด์ ํ๊ฐ (๋ณธ๋ฌธ ์๋ต ๊ฐ๋ฅ)
let count = 0;
while(count <3){
count++;
console.log(count);
}
console.log('end');
>> 1 2 3 'end'
let count = 3;
while(count <3) {
count++;
console.log(count);
}
console.log('end');
>> 'end'
- ๋ง์ง๋ง์ ์กฐ๊ฑด์ ํ๊ฐ (๋ณธ๋ฌธ ํ ๋ฒ ์ด์ ์คํ)
-
- do...while
let count = 0;
do {
count++;
console.log(count);
} while(count<3);
console.log('end');
>> 1 2 3 'end'
let count = 3;
do {
count++;
console.log(count);
}while(count <3);
console.log('end');
>> 'end'
- General loop
- for
- ํน์ ๋ถ๋ถ์ ์ฝ๋๊ฐ ๋ฐ๋ณต์ ์ผ๋ก ์ํ๋ ์ ์๋๋ก ํ๋ค
- ์ธ์ด๋ณ๋ก ์ง์ํ๋ ํ์์ด ์๋ค.
- [์ด๊ธฐํ-์กฐ๊ฑด์-์ฆ๊ฐ๋ฌธ]์ ํ์ (for(let ๋ฃจํ๋ณ์ = 0; ๋ฃจํ๋ณ์ <3; ๋ฃจํ๋ณ์++))
- C์ธ์ด ์ ๋, while๋ฌธ๊ณผ ๋ค๋ฅด๊ฒ ํด๋น ๋ฃจํ์ ๊ด๋ จ๋ loop ๋ณ์ ์กด์ฌ
- loop๋ณ์์ ๋น๊ต ๋ฐ ์ฆ๊ฐ์ ์ํ ๋ณ๋ ๋ถ๋ฒ ๋ช ์ ํ์
- ==loop๋ณ์๋ฅผ ํ์ฉํด ๋ช ์์ ์ผ๋ก ์นด์ดํธ๋ฅผ ๊ด๋ฆฌ ํ์
- ์ด๊ธฐ๋ฌธ: loop ๋ด์์ ์ฌ์ฉํ loop๋ณ์๋ฅผ ์ด๊ธฐํ
- ์กฐ๊ฑด๋ฌธ: loop ๋ด ์ฝ๋ ์ , ์กฐ๊ฑด์ ํ๊ฐํ์ฌ loop๋ฅผ ์ง์ํ ์ง ํ๋จ
- ์ฆ๊ฐ๋ฌธ: loop ๋ด ์ฝ๋ ํ, ์คํ๋๋ ๋ฌธ์ฅ(๋ฃจํ๋ณ์ ์ฆ๊ฐ ์ฉ๋)
- C์ธ์ด ์ ๋, while๋ฌธ๊ณผ ๋ค๋ฅด๊ฒ ํด๋น ๋ฃจํ์ ๊ด๋ จ๋ loop ๋ณ์ ์กด์ฌ
- ์งํฉ loopํ์ (Foreach loop)
- [์ด๊ธฐํ-์กฐ๊ฑด์-์ฆ๊ฐ๋ฌธ]์ ํ์ (for(let ๋ฃจํ๋ณ์ = 0; ๋ฃจํ๋ณ์ <3; ๋ฃจํ๋ณ์++))
- for
- Collection loop
- ์ปฌ๋ ์ ์์ ํญ๋ชฉ๋ค์ ํก๋จํ๋ ์ ์ดํ๋ฆ๋ฌธ
- For๋ฌธ๊ณผ ๋ค๋ฅด๊ฒ, ๋ช ์์ ์ผ๋ก ์นด์ดํฐ(๋ฃจํ๋ณ์)๋ฅผ ๊ด๋ฆฌํ์ง ์๋๋ค.
- ์ ์ฌ์ ์ธ ์ํ ํ์ ์ค๋ฅ๋ฅผ ์๋ฐฉ (off-by-one error)
- ์ฝ๋๋ฅผ ๋ ๋จ์ํ๊ฒ ์ฝํ ์ ์๊ฒ ํด์ค๋ค.
- ์๋ฐ์คํฌ๋ฆฝํธ collection loop
- for...in
- ๊ฐ์ฒด์ ์ด๊ฑฐ์์ฑ(enumerable)์ ํตํด ์ง์ ๋ ๋ณ์๋ฅผ ๋ฐ๋ณตํ๋ค.
- for([๋ณ์] in [object]) { ... } //๋ณ์๋ ๊ฐ์ฒด์ key๊ฐ์ ๋ฐํ
- for...of
- ๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด(iterator)๋ฅผ ํตํด ๋ฐ๋ณตํ๋ ๋ฃจํ๋ฅผ ๋ง๋ ๋ค.
- for([๋ณ์] of [object]) { ... } //๋ณ์๋ ๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด์ ๊ฐ์ ๋ฐํ(Array, Set, String, ...)
- for...in
const foo = 'apple';
for(const i of foo){
console.log(i);
}
>> 'a' 'p' 'p' 'l' 'e'
const foo = new Set();
foo.add('apple');
foo.add('banana');
for(const i of foo){
console.log(i);
}
>> 'apple' 'banana'
const foo = {
apple: '๐',
banana: '๐',
};
for(let key in foo){
console.log(key);
}
>> console.log(key);
- Subroutine exit : return
- break๋ฌธ
- ์ ์ดํ๋ฆ์ ์ข ๋ฅ ์ค ํ๋ก๊ทธ๋จ ์คํ ์ค๋จ ์ข ๋ฅ
- ๋ฐ๋ณต๋ฌธ, switch๋ฌธ์ ์ข ๋ฃ์ํฌ ๋ ์ฌ์ฉ
- ๊ฐ์ฅ ๊ฐ๊น์ด while, do-while, for, switch๋ฌธ ์ข ๋ฃํ๊ณ ๋ค์ ๋ช ๋ น์ด๋ก ๋์ด๊ฐ
- continue๋ฌธ
- ์ ์ดํ๋ฆ์ ์ข ๋ฅ ์ค ํ์ฌ ์คํ ๊ตฌ๋ฌธ์์ ๋จ์ด์ง ํ ๊ตฌ๋ฌธ์ ์งํฉ์ ์คํ ์ข ๋ฅ์ ์ํ๋ค.
- while, do...while, for๋ฌธ์ ๋ค์ ์์ํ๊ธฐ ์ํด ์ฌ์ฉ
- ๊ฐ์ฅ ์์ชฝ์ while, do-while, for๋ฌธ์ ๋๋ฌ์ผ ๋ฐ๋ณต์ ์ข ๋ฃ, ๋ค์ loop ์คํ
- ์ ์ฒด ๋ฃจํ ์คํ์ ์ข
๋ฃํ์ง ์๋๋ค.
- while: ์กฐ๊ฑด๋ฌธ์ผ๋ก ์ด๋
- for: ์ฆ๊ฐ๋ฌธ์ผ๋ก ์ด๋
- break๋ฌธ
- Non-local control flow
- try...catch
- throw
- generator
- async
์์ธ์ํฉ Exception
- - ๋ฐํ์ ๋ ๋ฐ์ํ ์ ์๋ ์๋์น ์์ ์ํฉ์ ๋ปํ๋ค.
- - ํ๋ฆ ์ ์ด ์ ๋ฐ์ํ ์ ์๋ ์์ธ ์ํฉ์ด๋ฏ๋ก, ์ด๋ฅผ ์ดํดํ์ฌ ์ฝ๋ ๋ ๋ฒจ์์ ๋์ํด์ผ ํ๋ค.
- handling: ๋์ํ๋ค์ ์๋ฏธ
- control: ์์ํ๊ณ ์ง์ ์กฐ์ํ๋ค๋ ์๋ฏธ
- ์์ธ ์ํฉ์ ํธ๋ค๋งํ์ง ์๋๋ค๋ฉด, ๊ธฐ๋ฅ์ด ๋์ํ์ง ์๊ฑฐ๋ ์ดํ๋ฆฌ์ผ์ด์ ์ด shut down๋ ์ ์๋ค.
- ์์ธ์ ์์ธ
- ์ธ์ด ๋ ๋ฒจ~ ์ธ๋ถ์์ธ์ ์ํ ์์ธ ์ํฉ๊น์ง ๋ค์ํ๋ค.
- ์ฝ๋ ๋ ๋ฒจ์์์ ๋ฌธ์ / ํ๋์จ์ด, ๋๋ฐ์ด์ค์ ๋ฌธ์ / ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์์ / ์ฌ์ฉ์์ ์ ๋ ฅ ์ค์ ...
- ์ธ์ด ๋ ๋ฒจ~ ์ธ๋ถ์์ธ์ ์ํ ์์ธ ์ํฉ๊น์ง ๋ค์ํ๋ค.
- ์์ธ์ ์ข
๋ฅ
- ECMAScript Error: ์๋ฐ์คํฌ๋ฆฝํธ ์ธ์ด์์ ๋ฐ์ํ๋ Error Type
- RangeError ๊ฐ์ด ์งํฉ์ ์๊ฑฐ๋, ํ์ฉ๋ฒ์๊ฐ ์๋ ๋
- ReferenceError ์กด์ฌํ์ง ์๋ ๋ณ์ ์ฐธ์กฐ ์
- SyntaxError ๋ฌธ๋ฒ์ ์งํค์ง ์์์ ๋
- TypeError ๊ฐ์ด ๊ธฐ๋ํ ์๋ฃํ์ด ์๋์ฌ์ ์ฐ์ฐ์ด ๋ถ๊ฐ๋ฅํ ๋
- DOMException: Web API ๋ ๋ฒจ์์ ๋ฐ์ํ๋ Error Type
- NetworkError ๋คํธ์ํฌ ์๋ฌ ๋ฐ์ ์
- AbortError ์์ ์ด ์ค๋จ๋์์ ๋
- TimeoutError ์์ ์๊ฐ์ด ์ด๊ณผ๋์์ ๋
- ๊ทธ ์ธ ์์ธ
- ๊ฐ๋ฐ์๋ ์์์น ๋ชปํ ์์ธ ์ํฉ
- ๊ฐ๋ฐ์๊ฐ ์ง์ ์์ธ ์ํฉ์ ์์ํ์ฌ ํธ๋ค๋ง ํ ์ ์๋ค.
- ์๋ฐ์คํฌ๋ฆฝํธ์ Error๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ์ฌ ์ง์ ์๋ฌ๋ฅผ ์ ์๋ด๋ฆฌ๊ณ ํธ๋ค๋ง ํ ์ ์๋ค.
- throw๋ฌธ
- ์์ธ๋ฅผ ๋ฐ์์ํฌ ๋ ์ฌ์ฉ, catch๋ธ๋ญ์์ ์๋ฌ ๊ฐ์ฒด ํธ๋ค๋ง
- ์์ธ๊ฐ ๋ฐ์ํ๋ฉด
- 1. ํ์ฌ ํจ์์ ์คํ์ด ์ค์ง
- 2. ์๋ฌ๊ฐ์ฒด์ ํจ๊ป ์๋ฌ๊ฐ throw
- 3. ์ ์ดํ๋ฆ์
- ํธ์ถ์ ์ฌ์ด์ catch๋ธ๋ก์ด ์์ผ๋ฉด, catch๋ธ๋ก์ผ๋ก ์ ๋ฌ
- ํธ์ถ์ ์ฌ์ด์ catch๋ธ๋ก์ด ์์ผ๋ฉด, ํ๋ก๊ทธ๋จ ์ข ๋ฃ
- ์์ธ๋ฅผ ๋ฐ์์ํค๊ธฐ ์ํ์ฌ throw๋ฌธ ์ฌ์ฉ -> throw ํํ์
- throw๋ฌธ ์ดํ์ ๋ช ๋ น๋ฌธ์ ์คํ๋์ง ์๋๋ค.
- ECMAScript Error: ์๋ฐ์คํฌ๋ฆฝํธ ์ธ์ด์์ ๋ฐ์ํ๋ Error Type
const foo = () => {
console.log(1);
thorw '์ฌ๊ธฐ';
console.log(2);
}
foo();
>> Error: ์ฌ๊ธฐ
>> 1
- Error ๊ฐ์ฒด
- ์ฌ์ฉ์๊ฐ ์ง์ Error ๊ฐ์ฒด๋ฅผ ์ ์ํ์ฌ ์ฌ์ฉํ ์ ์๋ค.
- new Error("์๋ฌ ๋ฉ์ธ์ง")
- Error.message
- Error.name
- ECMAScript ํ์ค ๋ด์ฅ ์ค๋ฅ ์ ํ์ด ์๋ค.
- ์ฌ์ฉ์๊ฐ ์ง์ Error ๊ฐ์ฒด๋ฅผ ์ ์ํ์ฌ ์ฌ์ฉํ ์ ์๋ค.
const foo = () => {
console.log(1);
const customError = new Error();
customError.name = "ErrorName";
customError.message = '์๋ฌ๋ฐ์';
throw customError;
console.log(2);
}
foo();
>> 1
>> ErrorName: ์๋ฌ๋ฐ์
์๋ฌ catch
- ์๋ฌ๊ฐ ๋ฐ์ํ๋ฉด
- ํ์ฌ ํจ์์ ์คํ์ด ์ค์ง
- ์๋ฌ๊ฐ์ฒด์ ํจ๊ป ์๋ฌ๊ฐ throw
- ์ ์ดํ๋ฆ์
- ํธ์ถ์ ์ฌ์ด์ catch๋ธ๋ก์ด ์์ผ๋ฉด, catch๋ธ๋ก์ผ๋ก ์ ๋ฌ
- ํธ์ถ์ ์ฌ์ด์ catch๋ธ๋ก์ด ์์ผ๋ฉด, ํ๋ก๊ทธ๋จ ์ข ๋ฃ
- ์๋ฌ๋ฅผ catchํ์ฌ ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋์ง ์๋๋ก ํด์ผํ๋ค.
- ์์ธ ์ฒ๋ฆฌ๋ฅผ ๋ด๋นํ๋ ํธ๋ค๋ฌ๋ฅผ ์ฐพ๊ธฐ ์ํด, ์์๋๋ก ์ฝ ์คํ(call stack)์ ๊ฑฐ์ฌ๋ฌ ์ฌ๋ผ๊ฐ ์ฌ๋ฐ๋ฅธ ํธ๋ค๋ฌ๋ฅผ ์ฐพ์๋ด์ด ๊ทธ ๊ณณ์์ ์ฒ๋ฆฌ๋๋๋ก ํ๋ค.
์ฝ์คํ call stack
- ์คํ ์๋ฃ๊ตฌ์กฐ
- ์ถ์ ๊ตฌ๊ฐ ํ๋์ธ ๋ฐ์ดํฐ ๊ตฌ์กฐ(First In Last Out)
- Call stack
- ์๋ฐ์คํฌ๋ฆฝํธ ์ฝ๋๊ฐ ์คํ๋๋ฉฐ ์์ฑ๋๋ ์คํ์ปจํ ์คํธ๋ฅผ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ
- ํจ์๋ฅผ ํธ์ถํ ๋๋ง๋ค ์คํ์ด ์์ด๊ณ , ํจ์์ ์คํ์ด ์ข ๋ฃ๋๋ฉด, ์ฝ์คํ์์ ์คํ์ ์ ๊ฑฐํ๋ ์๋ฆฌ
- ์๋ฌ throw๋๋ฉด
- ์ฝ์คํ์ ํ์ธํ์ฌ, ํธ๋ค๋งํ๊ณ ์๋ catch๋ฌธ์ด ์๋ ์คํ์์ ์ฒ๋ฆฌ
try...catch๋ฌธ
- try...catch๋ฌธ์ ๋ธ๋ก๋ฌธ ๋ด์์ ์์ธ๊ฐ ๋ฐ์ํ ๊ฒฝ์ฐ, ์์ธ ์ฒ๋ฆฌ๋ฅผ ๋งก์ ํ๋ ์ด์์ ๋ฐ์ ๋ช
๋ น๋ฌธ์ ์ง์
- try ๋ธ๋ก์ ๋ช ๋ น๋ฌธ ์ค ํ๋๊ฐ ์คํจํ๋ฉด, catch๋ก ์ ์ด๊ถ์ด ๋์ด๊ฐ๋ค.
- try ๋ธ๋ก์ ๋ช ๋ น๋ฌธ ์ค ํ๋๊ฐ ์ฑ๊ณตํ๋ฉด, catch๋ก ์ ์ด๊ถ์ด ๋์ด๊ฐ์ง ์๋๋ค.
- catch๋ธ๋ญ์์ ์ธ์๋ก throw๋ catchId๋ฅผ ์ฐธ์กฐํ ์ ์๋ค.
- try{...} catch(catchID){...}
const foo = (value) => {
if(value < 3) throw value;
else console.log(value);
};
const bar = (value) => {
try {
foo(value); // ์ค๋ฅ throw๋ผ์ catch๋ฌธ์ผ๋ก ๋์ด๊ฐ
} catch(catchID){
console.log('catch', catchID);
//>> 'catch' 2
}
};
bar(2);
์ฝ์คํ ์ค ํ๋์์ catch๋ฌธ์์ ์์ธ๊ฐ ์ฒ๋ฆฌ๋๋ค๋ฉด, ๋ ์์์ ์ฝ ์คํ์์๋ ๋์ด์ ์์ธ๊ฐ ํ๊ณ ์ฌ๋ผ์ค์ง ์๋๋ค.
function functionC() {
throw new Error("ํญํ ๋ฐ์ฌ!"); // ์ฌ๊ธฐ์ ์์ธ ๋ฐ์
}
function functionB() {
try {
functionC();
} catch (e) {
console.log("B์์ ์์ต ์๋ฃ: " + e.message); // ์ฌ๊ธฐ์ ์์ธ๋ฅผ ์ก์!
}
}
function functionA() {
functionB();
console.log("A๋ ์๋ฌด ์ผ ์์๋ค๋ ๋ฏ์ด ์คํ๋ฉ๋๋ค."); // ์คํ๋จ!
}
functionA();
>> B์์ ์์ต ์๋ฃ: ํญํ ๋ฐ์ฌ!
>> A๋ ์๋ฌด ์ผ ์์๋ค๋ ๋ฏ์ด ์คํ๋ฉ๋๋ค.
finally๋ธ๋ก
- finally๋ธ๋ก์ try๋ธ๋ก์์ ์์ธ ์ํฉ์ด ๋ฐ์ํ์ง ์๋๋ผ๋, ์คํํ๋ค.
- ์์ธ์ํฉ์ด ๋ฐ์๋๋ฉด: try -> catch -> finally
- ์์ธ์ํฉ์ด ๋ฐ์๋์ง ์์ผ๋ฉด: try -> finally
์ฌ๋ก
์ธ๋ถ์ ์์กด๋์ด์ ๊ตฌํ๋ ๋ก์ง์์ ์ฌ์ฉ(์๊ธฐ์น ๋ชปํ ์ํฉ ๋์)
- network ์๋ฌ ๋ฐ์ ์
- ์๋ฌ๋ฅผ ๊ฐ์งํด์ผ ํ๋ ๋น์ง๋์ค ๋ก์ง
- ๋น์ง๋์ค ๋ฐ์ดํฐ๊ฐ ์ ์ํ์ง ์๋ ๊ฒฝ์ฐ
- ์ ์ ๊ฐ ์๋ชป๋ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅํ ๊ฒฝ์ฐ
'FE > Javascript' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [JavaScript] ์๋ฐ์คํฌ๋ฆฝํธ์ ๋ฐ์ดํฐ์ฒ๋ฆฌ : ํจ์ (0) | 2026.03.17 |
|---|---|
| [JavaScript] ์๋ฐ์คํฌ๋ฆฝํธ์ ์๋ฃํ, ๋์ ํ์ ์ธ์ด (0) | 2026.03.17 |
| [JavaScript] ๋ณ์ ์์ฑ ๋ฐฉ๋ฒ(var vs const, let), ํธ์ด์คํ , ๋ณ์ ๋ค์ด๋ฐ ์ปจ๋ฒค์ (0) | 2026.03.13 |
| [JavaScript] javaScript์ ๊ธฐ๋ณธ ํน์ง (0) | 2026.03.09 |
| [JavaScript] ์ ๋๋ฉ์ด์ , form, ์กฐ๊ฑด๋ฌธ (0) | 2025.06.30 |