- Published on
๐ JS(3)-๋๋ฆผ์ฝ๋ฉ ๊ฐ์ ์ ๋ฆฌ
- ๊ธ์ด์ด
๐ ๋ชฉ์ฐจ
โจ ์๋ฐ์คํฌ๋ฆฝํธ ๊ธฐ์ด ๊ฐ์ (ES5+): ๊ฐ์ด ๋ ธํธ๋ฅผ ์์ฑํ๋ฉฐ ๋ฐฐ์์ ๐
๐๐ป
- ์๋ฐ์คํฌ๋ฆฝํธ์ ์ญ์ฌ์ ๋ชฉ์ ๋ฐ ๋ํฅ
- ์๋ฐ์คํฌ๋ฆฝํธ ๋์์๋ฆฌ
๋ฐ์ดํฐํ์ (3๊ฐ)
์น ํ๋ก๊ทธ๋๋ฐ์์ ์ ์ผ ์ค์ํ ๊ฒ : ์ ๋ ฅ.์ฐ์ฐ.์ถ๋ ฅ(์ ์ก)
๋ณ์(Variable), rw(read/write):๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ ํ์๋ ์ฝ๊ณ ์ฐ๊ธฐ๊ฐ ๊ฐ๋ฅ
๋ณ๊ฒฝ๋ ์ ์๋ ๊ฐ.
์ฝ๋๋ธ๋ญ |
---|
์ฝ๋ ๋ฐ์์๋ ์ฝ๋๋ธ๋ญ ์์ ์๋ ์ฝ๋์ ์ ๊ทผํ ์ ์๋ค. |
let (added in ES6) |
---|
ํ๊ฐ์ง ๋ฐ์ค๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๋ฅผ ๋ง๋๋ ๊ฒ. ์ฌ๊ธฐ์ ๋ค๋ฅธ ๊ฐ์ ๋ฃ์ด ๊ต์ฒดํ ์ ์๋ค. |
let name = 'apopo'
console.log(name)
name = 'hello'
console.log(name)
var(don't ever use this!) |
---|
ES6์ด์ ์ ์ฐ๋ ๋ณ์ ์ ์ธ ๋ช ๋ น์ด |
๊ฐ์ ํ ๋นํ๊ธฐ๋ ์ ์ ์ถ๋ ฅํ ์ ์์ผ๋ฏ๋ก (undefined) ์ด์ ๋ ์ฐ์ง ์๋๋ค.
์ด๋์ ์ ์ธํ๋์ง ์๊ด์์ด ๊ฐ์ ๋์ด์ฌ๋ ค์ฃผ๋ ๊ฑธ hoisting์ด๋ผ๊ณ ํ๋๋ฐ
var์ hoisting์ ์ฌ์ฉํด์ ๋ณ์ ์ ์ธ์ ๊ฐ์ฅ ์๋ก ๋์ด์ฌ๋ฆฐ๋ค.
๋ํ var์ ์ฝ๋๋ธ๋ญ๋ ๋ฌด์ํ๋ ์ ์ญ ๋ณ์๋ก ์ ์ธ๋๋ค.
๊ณ ์ ๊ฐ (Constants) r(read):๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ๋ ํ์๋ ์ฝ๊ธฐ๋ง ๊ฐ๋ฅ
๋๋๋ก์ด๋ฉด const๋ฅผ ์ฐ๊ณ ์ ์ธ ํ ๋์ค์ ๊ฐ์ ๋ณ๊ฒฝํด์ผ ํ ๋๋ง let์ ์ฐ์.
const (added in ES6) |
---|
ํ๋ฒ ๊ฐ์ ํ ๋นํ๋ฉด ๋์ด์ ๊ฐ์ ๊ต์ฒดํ ์ ์๊ฒ ๋ง๋๋ ๋ช ๋ น์ด. ๊ฐ์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๊ฐ ์ ๊ฒจ์์ |
immutable datatype์ด๋ค. ์ด๋ ๊ฒ ๋ชป๋ฐ๊พธ๊ฒ ํ๋ ์ด์ ๋ 3๊ฐ์ง๊ฐ ์๋ค.
- security
- thread safety
- reduce human mistakes
๋ค์ํ ๋ฐ์ดํฐ ํ์ ๋ค (Variable types)
- primitive, Single item (๋์ด์ ์๊ฒ ๋๋ ์ ์๋ ํ๊ฐ์ง์ ๋ฐ์ดํฐํ์
):
number, string, boolean, null, undefined, symbol - object, box container : ์ฑ๊ธ ํ์ ๋ค์ ๋ฌถ์ด์ ํ๋์ ๊ทธ๋ฃน์ผ๋ก ๊ด๋ฆฌ
- function, first-class function(๋ณ์์ ํ ๋น ๊ฐ๋ฅ, ์ธ์๋ก ์ฌ์ฉ ๊ฐ๋ฅ, ๋ฐํ๊ฐ์ผ๋ก ์ฌ์ฉ ๊ฐ๋ฅ)
๋ก์ฐ ๋ ๋ฒจ ์ธ์ด(c,java)์ ๋ค์ํ ๋ฐ์ดํฐ ํ์ ๋ค๋ ๊ณต๋ถํ๋ฉด ๋ฐ์ดํฐ ์ฌ์ด์ฆ๋ฅผ ๋์ฑ ์ธ์ธํ๊ฒ ์ ํ ์ ์๋ค. Js์์๋ number๋ง ์ฐ๋ฉด ์ด๋ค ํฌ๊ธฐ์ ์๋ ์ธ ์ ์๋ค! ์์ฃผ ๊ฐ๋จ!
ํน๋ณํ ์ํฉ์์์ number ๊ฐ๋ค
const infinity = 1 / 0 //Infinity๋ก ์ถ๋ ฅ๋จ
const negativeInfinity = -1 / 0 //negativeInfinity์ผ๋ก ์ถ๋ ฅ๋จ
const nAn = 'not a number' / 2 //NaN์ผ๋ก ์ถ๋ ฅ๋จ
const bigInt = 12345678975654897486465135487694861531553n //bigint๋ผ๊ณ ์ถ๋ ฅ๋จ
string
const char = 'c' //ํ๊ฐ์ง์ ๊ธ์๋ ์ฌ๋ฌ๊ฐ์ ๊ธ์๋ ๋ค string์ผ๋ก ํ ๋น
const brendan = 'brendan'
const greeting = 'hello' + brendan
console.log(`value: ${greeting}, type: ${typeof greeting}`)
const helloBob = `hi ${brendan}!` //template literals (string) :
``(๋ฐฑํฑ)๊ธฐํธ๋ฅผ ์ด์ฉํด ์ํ๋ string์ ${}์์ ์ ์ผ๋ฉด ๊ทธ string์ ๊ฐ์ด ์ถ๋ ฅ๋จ
console.log(`value: ${helloBob}, type: ${typeof helloBob}`)
boolean
- false: 0, null, undefined, NaN, ''
- true: any other value
const canRead = true
const test = 3 < 1 //false
console.log(`value" ${canRead}, type: ${typeof canRead}`)
console.log(`value: ${test}, type: ${typeof test}`)
null
null์ด๋ผ๊ณ ํ ๋นํ๋ฉด ์์ ๋น ๊ฐ์ ์ง์ ํด์ค๊ฒ
let nothing = null
console.log(`value: ${nothing}, type: ${typeof nothing}`)
undefined
์๋ฌด ๊ฐ์ด ์ง์ ๋์ด ์์ง ์์ ์ํ
let x
console.log(`value: ${x}, type: ${typeof x}`)
symbol
create unique identifiers for objects
์ฐ์ ์์๋ฅผ ์ฃผ๊ณ ์ถ์ ๋,๊ณ ์ ํ ์๋ณ์๋ฅผ ์ฃผ๊ณ ์ถ์ ๋ ์
๋์ผํ ๋ด์ฉ์ ๊ฐ์ง๊ณ ์ฌ๋ณผ์ ๋ค๋ฅด๊ฒ ๋ง๋ค๋ฉด ์๋ก ๋ค๋ฅธ ์ฌ๋ณผ๋ก ๊ฐ์ฃผํจ.
const symbol1 = Symbol('id')
const symbol2 = Symbol('id')
console.log(symbol1 === symbol2) //false
๋ง์ฝ ๊ฐ์ ๊ฐ์ ๊ฐ์ง๊ณ ๋ค๋ฅธ ์ฌ๋ณผ์ ๋ง๋ค์์ ๋ ๋์ผํ ์ฌ๋ณผ๋ก
๊ฐ์ฃผํ๊ณ ์ถ์ผ๋ฉด Symbol.for();
์ ์ฌ์ฉํ๋ค.
const gsymbol1 = Symbol.for('id')
const gsymbol2 = Symbol.for('id')
console.log(gsymbol1 === gsymbol2) //true
object
const apopo = { name: 'apopo', age: 20 }
//ํ๋ฒ ํ ๋น๋ object๋ ๋ค๋ฅธ object๋ก ํ ๋น์ด ๋ถ๊ฐํ์ง๋ง
//object์์์๋ ๋ค๋ฅธ ๊ฐ๋ค์ ํ ๋นํ ์ ์๋ค.
//apopo.name,apopo.age๋ฑ์ผ๋ก ๊บผ๋ผ ์ ์๋ค.
๋ค์ด๋๋ฏน ํ์ดํ(dynamically typed language)
๋ณ์๋ฅผ ์ ์ธํ ๋ ๋ฐ์ดํฐ ํ์
์ ์ ์ธํ์ง ์๊ณ
ํ๋ก๊ทธ๋๋ฐ์ด ๋์ํ ๋ ํ ๋น๋ ๊ฐ์ ๋ฐ๋ผ ํ์
์ด ๋ณ๊ฒฝ๋ ์ ์๋ค.(์๋ํ๋ณํ)
์ด ์ ์ด ๋จ์ ์ผ๋ก ์์ฉํ ๋๊ฐ ์์ด TypeScript๊ฐ ๋์ค๊ฒ ๋์๋ค.
let text = 'hello'
console.log(`value: ${text}, type: ${typeof text}`) //hello, string
text = 1
console.log(`value: ${text}, type: ${typeof text}`) //1, number
text = '7' + 5
console.log(`value: ${text}, type: ${typeof text}`) //75, string
text = '8' / '2'
console.log(`value: ${text}, type: ${typeof text}`) //2, number
Note!
Immutable data types: premitive types, frozen objects (i.e. object.freeze()) Mutable data
types: all objects by default are mutable in JS favor immutable data type always for a few reasons:
- security
- thread safety
- reduce human mistakes