โ ๋ณ์, ํธ์ด์คํ , ํด๋ก์
1. ๋ณ์
- ์๋ฐ์คํฌ๋ฆฝํธ๋ ๋์ ์ธ์ด์ด๊ธฐ ๋๋ฌธ์, ๋ณ์ ํ์ ์ ๋ฏธ๋ฆฌ ์ ์ธํ ํ์ ์์
- ํ์ ์ ํ๋ก๊ทธ๋จ์ด ์ฒ๋ฆฌ๋๋ ๊ณผ์ ์์ ์๋์ผ๋ก ํ์ ํจ ( typeof(๋ณ์)๋ฅผ ํตํด ํ์ธ )
[ var vs let vs const ]
- var : ES6 ์ด์ ์๋ฐ์คํฌ๋ฆฝํธ์์ ์ฌ์ฉ
(์ด์ ๋ let, const ์ฌ์ฉ์ ๊ถ์ฅํจ)
์ด์ ๋?
var์ ๋ณ์ ํธ์ด์คํ
๊ณผ function-level-scope๋ก ์๊ธฐ๋ ๋ฌธ์ ๋๋ฌธ!
2. ๋ณ์ ํธ์ด์คํ
๋ณ์ ํธ์ด์คํ
(hoisting)์ด๋?
๋ณ์์ ์ ์ธ๊ณผ ์ด๊ธฐํ๊ฐ ๋์์ ์ด๋ฃจ์ด์ ธ ์์ง ๊ฐ์ด ์์์๋ ์ค๋ฅ๊ฐ ๋์ง ์๋ ํ์
(๋ณ์ ์ ์ธ ์ด์ ์ ์ฐธ์กฐ ๊ฐ๋ฅ)
* Hoisting : ๋์ด์ฌ๋ฆฌ๋ค.
1) var์ ๊ฒฝ์ฐ
// sample 01
console.log(puppy);
var puppy = 'cute';
console.log(puppy);
// ์ถ๋ ฅ๊ฒฐ๊ณผ
/*
undefined
cute
*/
โก ์์ง puppy๋ผ๋ ๋ณ์๋ฅผ ์ ์ธํ์ง ์์ ์ํ์์ ํธ์ถํ์์๋,
์ค๋ฅ๊ฐ ๋์ง ์๊ณ undefined๋ผ๋ ๊ฐ์ ๋ฐํํจ.
๐ฅ ์ฌ๊ธฐ์ ์ฃผ์!
null vs undefined
1. null : ๋ณ์์ ๊ฐ์ null๋ก ์ง์ ํ ๊ฒ!
โก ์ฆ, ๋ณ์๋ null ์ด๋ผ๋ ๊ฐ์ ๊ฐ๊ณ ์์
2. undefined : ๋ณ์๊ฐ ๊ฐ์ ๊ฐ๊ณ ์๋ ๊ฒ์ ์๋์ง๋ง, ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ฐจ์งํ๊ณ ์๋ ๊ฒ!
โก ๋ด๊ฐ ์์ง ํ ๋นํ์ง ์์ ๋ณ์๊ฐ ์ ๋ง๋๋ก ์ฐธ์กฐํ ์ ์๊ฒ ๋จ
2) let, const์ ๊ฒฝ์ฐ (ES6 ์ดํ var๋ณด๋ค ์ด๊ฒ์ ์ฌ์ฉํ๊ธฐ๋ฅผ ๊ถ์ฅ)
// sample-02-1
let dog;
dog = 'happy';
console.log(dog);
let dog = 'happy'; // ์ค๋ฅ ๋ฐ์
// smaple 02-2
const puppy = 'cute';
const puppy = 'so cute'; // ์ค๋ฅ ๋ฐ์
โก let ๊ณผ const ์ค๋ณต์ ์ธ์ด ๋ถ๊ฐ๋ฅํ์ฌ, ๋ณ์ ํธ์ด์คํ ๋ฌธ์ ํด๊ฒฐ ๊ฐ๋ฅ
(์ฆ, ๋ด๊ฐ ๊ฐ์ ์ค ๋ณ์๋ง์ด ์ ์ญํ ์ ํ ์ ์๊ฒ ๋๋ฏ๋ก ๋ณ์ ํธ์ด์คํ ๋ฌธ์ ๋ก ์ค์ํ ์ผ์ ๊ฐ์์ํด)
3. ์ค์ฝํ (scope)
์ค์ฝํ๋?
๋ณ์์ ์ ๊ทผํ ์ ์๋ ๋ฒ์
1) var์ ๊ฒฝ์ฐ
ํจ์ ๋ ๋ฒจ ์ค์ฝํ (function-level-scope)
: ํจ์์ ๋ธ๋ก ๋ฒ์ ๋ด์์ ์ ์ธํ ๋ณ์๋ ํจ์ ๋ด์์๋ง ์ธ์ (ํจ์ ์ธ๋ถ์์ ์ ์ธํ ๋ณ์๋ ๋ชจ๋ ์ ์ญ๋ณ์)
// sample 03
var puppy = 'cute';
console.log(puppy);
{
var puppy = 'so cute';
}
console.log(puppy);
// ์ถ๋ ฅ๊ฒฐ๊ณผ
/*
cute
so cute
*/
โก var๋ function-level-scope๋ฅผ ๋ฐ๋ฅด๊ธฐ ๋๋ฌธ์, ์ ์ญ๋ณ์์ ์ํ์ง ์๋ ๊ฐ์ ๋ฎ์ ์ ์๋ ๋ฌธ์ ์ ์ด ์์
2) let ๊ณผ const์ ๊ฒฝ์ฐ
๋ธ๋ก ๋ ๋ฒจ ์ค์ฝํ (block-level-scope)
: ๋ชจ๋ ์ฝ๋ ๋ธ๋ก(ํจ์, if ๋ฌธ, for ๋ฌธ, while ๋ฌธ, try/catch ๋ฌธ ๋ฑ) ๋ด์์ ์ ์ธ๋ ๋ณ์๋ ์ฝ๋ ๋ธ๋ก ๋ด์์๋ง ์ ํจํ๋ฉฐ,
์ฝ๋ ๋ธ๋ก ์ธ๋ถ์์๋ ์ฐธ์กฐํ ์ ์๋ค. (์ฝ๋ ๋ธ๋ก ๋ด๋ถ์์ ์ ์ธํ ๋ณ์๋ ์ง์ญ ๋ณ์)
// sample04
let puppy = 'cute';
{
let puppy = 'so cute';
}
console.log(puppy); // cute
โก 1๋ฐ ์ดํ์ง๊ณผ 3๋ฐ ์ดํ์ง์ด ๋ค๋ฅธ ์ฌ๋์ธ ๊ฒ์ฒ๋ผ,
๋ ๊ฐ์ puppy๋ ์ด๋ฆ๋ง ๊ฐ์ ๋ฟ ๋ค๋ฅธ ๋ณ์์.
4. let vs const
// sample05-1
const puppy = 'cute';
puppy = 'so cute!!';
console.log(puppy);
// TypeError: Assignment to constant variable.
// sample 05-2
let dog;
console.log(dog); // undefined
dog = 'so lovely';
console.log(dog); // so lovely
- let์ ๊ฐ์ ์ฌํ ๋นํ ์ ์์
- const๋ ์ฌํ ๋น ๋ถ๊ฐ๋ฅ (๊ฐ์ ๋ณ๊ฒฝ์ด ๋ถ๊ฐ๋ฅํจ)
5. ํด๋ก์ (closure)
ํด๋ก์ ๋?
๋ด๋ถ ํจ์๊ฐ ์ธ๋ถ ํจ์์ ์ค์ฝํ์ ์ ๊ทผํ ์ ์๋ ๊ฒ
// sample 06
function outer(){
var a = 'A';
var b = 'B';
function inner(){
var a = 'AA';
console.log(a); // AA
console.log(b); // B
}
console.log(a); // A
return inner;
}
var outerFunc = outer();
outerFunc();
// ์ถ๋ ฅ๊ฒฐ๊ณผ
/*
A
AA
B
*/
์๋ฐ์คํฌ๋ฆฝํธ์ ์ค์ฝํ๋ ํจ์ ๋จ์๋ก ์์ฑ๋จ.
โก inner() ํจ์์ ์ค์ฝํ๊ฐ outer()ํจ์์ ์ค์ฝํ๋ฅผ ์ฐธ์กฐํจ.
โก outer()์ ์คํ์ด ๋๋๊ณ ์๋ฉธ๋ ์ดํ์๋ inner()ํจ์๊ฐ outer()ํจ์์ ์ค์ฝํ์ ์ ๊ทผ ( = ํด๋ก์ )
์ ์์ ์ ๊ฒฝ์ฐ,
1) outer() ๊ฐ ์คํ๋๋ฉด์ var a์ธ 'A'๋ฅผ ์ถ๋ ฅ
2) var outerFunc์ inner()๋ฅผ ๋ฐํ
3) outerFunc()๋ฅผ ์คํํ๋ฉด inner()๊ฐ ์คํ๋๋ ๊ฒ๊ณผ ๊ฐ์
โก outerFunc()๊ฐ ์คํ๋๋ฉด์ inner()์ ์ง์ญ๋ณ์ a์ outer()์ ์ง์ญ๋ณ์ b๊ฐ ์ถ๋ ฅ๋์ด 'AA', 'B'๊ฐ ์ถ๋ ฅ๋จ.
๐ก ์ ๋ฆฌ ๐ก
๋๋ถ๋ถ์ ๋ฌธ์ ๋ ์ ์ญ ๋ณ์๋ก ์ธํด ๋ฐ์
์ ์ญ ๋ณ์๋ ๊ฐ๋จํ ์ ํ๋ฆฌ์ผ์ด์ ์ ๊ฒฝ์ฐ ์ฌ์ฉ์ด ํธ๋ฆฌํ๋ค๋ ์ฅ์ ์ด ์์ง๋ง,
์ค์ฝํ๊ฐ ๋์ด์ ์ฌ์ฉ์ฒ๋ฅผ ํ์ ํ๊ธฐ ํ๋ค๋ฉฐ,
๋น์์ ํจ์์ ์ํด ์๋์น ์๊ฒ ๋ณ๊ฒฝ๋ ์๋ ์์ด ๋ณต์ก์ฑ์ ์ฆ๊ฐ์ํด.
๋ฐ๋ผ์ ๋ณ์์ ์ค์ฝํ๋ ์ข์์๋ก ์ข๊ธฐ ๋๋ฌธ์
ES6๋ var์ ๋จ์ ๋ณด์์ ์ํด let๊ณผ const ํค์๋๋ฅผ ๋์ ํจ.