ES6(ECMAScript 6)๋ 2015๋ ์ ๋์ ๋ ์๋ฐ์คํฌ๋ฆฝํธ์ 6๋ฒ์งธ ํ์ค์์ด๋ค. ํ๋์ ์ธ ์ฝ๋๋ฅผ ์ฌ์ฉํ๋ฉด, ์ฝ๋๊ฐ ๊ฐ๊ฒฐํด์ง๊ณ ์์ฐ์ฑ์ด ํฅ์๋๋ค. ์ด๊ฒ์ด ES6๋ฅผ ์ฌ์ฉํด์ผ ํ๋ ์ด์ ๋ค.
- var
์ ์ฌ์ ์์ ์ฌ์ ์ธ ๋ชจ๋ ๊ฐ๋ฅํ๋ค.
- let
์ ๊ฐ๋ณ๋ณ์๋ก ์ฌ์ ์๊ฐ ๊ฐ๋ฅํ์ง๋ง ์ฌ์ ์ธ์ ๋ถ๊ฐ๋ฅํ๋ค.
- const
๋ ๋ถ๋ณ๋ณ์๋ก ์ฌ์ ์ธ๊ณผ ์ฌ์ ์ ๋ชจ๋ ๋ถ๊ฐ๋ฅํ๋ค.
* ์ฌ์ ์ธ: ๋๊ฐ์ ์ด๋ฆ์ ๋ณ์๋ฅผ ๋ค์ ๋ง๋๋ ๊ฒ
* ์ฌ์ ์: ๊ฐ์ด ์ง์ ๋ ๋ณ์์ ๊ฐ์ ๋ฐ๊พธ๋ ค๋ ๊ฒ
* ์ค์ฝํ(scope)
: ์๋ณ์(ex. ๋ณ์๋ช
, ํจ์๋ช
, ํด๋์ค๋ช
๋ฑ)์ ์ ํจ๋ฒ์
//๋ณ์ ์ ์ธ
var x = 2;
// ์ฌ์ ์
x = 4;
// ์ฌ์ ์ธ
var x = 4;
var
์ ๋ฌธ์ ์ ํ ํ๋ฆฟ ๋ฆฌํฐ๋ด์ ES6๋ถํฐ ์๋ก ๋์ ๋ ๋ฌธ์์ด ํ๊ธฐ๋ฒ์ผ๋ก, ๋ฌธ์์ด ์์ฑ์ ๋ฐ์ดํ ๋์ , ๋ฐฑํฑ(`)์ ์ฌ์ฉํ๋ค. ๋ฐ์ดํ์ ๋ฌ๋ฆฌ ๋ฐฑํฑ ์์์๋ ์ค๋ฐ๊ฟ์ด ๋ฐ์๋๋ค. ๋ํ, ๋ฌธ์์ด ์ฌ์ด์ ๋ณ์๋ ์ฐ์ฐ์ ๋ฃ์ ๋๋ ${} ์ฌ์ด์ ํํ์์ ์ฝ์ ํ๋ค.
var jsp = "์๋ฐ์คํฌ๋ฆฝํธ";
// ๊ธฐ์กด ์ฝ๋
console.log("์ด๊ฑด " + jsp + "์
๋๋ค.");
// ํ
ํ๋ฆฟ ๋ฆฌํฐ๋ด ๋ฐฉ์
console.log(`์ด๊ฑด ${jsp}์
๋๋ค.`);
// ์ถ๋ ฅ ๊ฒฐ๊ณผ -> ์ด๊ฑด ์๋ฐ์คํฌ๋ฆฝํธ์
๋๋ค.
ํ์ดํ ํจ์๋ ํจ์ ํํ์์ ๋ณด๋ค ๋จ์ํ๊ณ ๊ฐ๊ฒฐํ ์์ฑํ๋ ๋ฌธ๋ฒ์ด๋ค.
// ๊ธฐ๋ณธ ํจ์ ํ์
let sum = function(a, b) {
return a + b;
};
// ํ์ดํ ํจ์ ํ์
let sum = (a, b) => a + b;
๋ชจ๋์ ๋ด๋ณด๋ด๋ ๋ฐฉ๋ฒ์ผ๋ก๋ named export์ default export๊ฐ ์๋ค.
// named export ๊ธฐ๋ณธ ํ์
export { ๋ชจ๋๋ช
1, ๋ชจ๋๋ช
2 };
import { ๋ชจ๋๋ช
1, ๋ชจ๋๋ช
2 } from 'js ํ์ผ ๊ฒฝ๋ก';
// default export ๊ธฐ๋ณธ ํ์
export default ๋ชจ๋๋ช
;
import ๋ชจ๋๋ช
from 'js ํ์ผ ๊ฒฝ๋ก';
- named export
๋ ํ ํ์ผ์์ ์ฌ๋ฌ ๊ฐ๋ฅผ exportํ ๋ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค. exportํ ์ด๋ฆ๊ณผ ๋์ผํ ์ด๋ฆ์ผ๋ก importํด์ผ ํ๋ฉฐ, ์ค๊ดํธ์ ๋ฌถ์ด์ import ํด์ผ ํ๋ค.
๋ค๋ฅธ ์ด๋ฆ์ผ๋ก import ํ๋ ค๋ฉด as
๋ฅผ ์ฌ์ฉํ๊ณ , ํ ํ์ผ์ ์๋ ํด๋์ค๋ ๋ณ์๋ค์ ํ ๋ฒ์ import ํ๋ ค๋ฉด * as
๋ฅผ ์ฌ์ฉํ๋ค.
// named export๋ ์ค๊ดํธ ํฌํจ import
import { named1, named2 } from './example.js';
// named export์์ as๋ฅผ ์ฌ์ฉํ์ฌ ๋ค๋ฅธ ์ด๋ฆ์ผ๋ก import
import { named1 as myExport, named2 } from './example.js';
// ํ ํ์ผ์ ์๋ ๋ชจ๋ ํด๋์ค๋ ๋ณ์๋ฅผ * as๋ฅผ ์ฌ์ฉํ์ฌ ํ ๋ฒ์ import
import * as Hello from './example.js';
- default export
๋ ํ๋์ ํ์ผ์์ ๋จ ํ๋์ ๋ณ์ ๋๋ ํด๋์ค ๋ฑ๋ฑ๋ง export ํ ์ ์๋ค. ๋ํ import ํ ๋ ์๋ฌด ์ด๋ฆ์ผ๋ก๋ ์์ ๋กญ๊ฒ import ๊ฐ๋ฅํ๋ฉฐ, ์ค๊ดํธ์ ๋ฌถ์ง ์์๋ ๋๋ค.
// default export ๋ ์ค๊ดํธ ์์ด import
import default1 from './example.js';
Class๋ ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ธฐ ์ํ ํ ํ๋ฆฟ์ผ๋ก, ํ๊ณผ ๊ฐ์ ์ญํ ์ ํ๋ค.
โข ํด๋์ค๋ฅผ ์ ์ธํ๋ ค๋ฉด class
ํค์๋์ ํจ๊ป ํด๋์ค์ ์ด๋ฆ์ ์์ฑํ๋ค.
โข ํด๋์ค๋ ํจ์๋ก ํธ์ถ๋ ์ ์๋ค.
โข ํด๋์ค ์ ์ธ์ let๊ณผ const์ฒ๋ผ ๋ธ๋ก ์ค์ฝํ์ ์ ์ธ๋๋ฉฐ, ํธ์ด์คํ
(hoisting)์ด ์ผ์ด๋์ง ์๋๋ค. ํด๋์ค๋ ๋ฐ๋์ ์ ์ํ ๋ค์ ์ฌ์ฉํ๋ค.
โข ํด๋์ค์ ๋ฉ์๋ ์์์ super
ํค์๋๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
โข static
ํค์๋๋ฅผ ๋ฉ์๋ ์ด๋ฆ ์์ ๋ถ์ฌ์ฃผ๋ฉด ํด๋น ๋ฉ์๋๋ ์ ์ ๋ฉ์๋๊ฐ ๋ฉ๋๋ค.
โข Getter
ํน์ Setter
๋ฅผ ์ ์ํ๊ณ ์ถ์ ๋๋ ๋ฉ์๋ ์ด๋ฆ ์์ get
๋๋ se
t์ ๋ถ์ฌ์ฃผ๋ฉด ๋๋ค.
โข extends
ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ํด๋์ค์์ ๋ค๋ฅธ ํด๋์ค๋ก ์์ํ๋ฉด์ ํด๋์ค์ ๊ธฐ๋ฅ์ ํ์ฅํด ๋๊ฐ์ ์๋ค.
โข ํด๋์ค์์ ์ผ๋ฐ์ ์ธ ๋ฐฉ์์ผ๋ก ํ๋กํผํฐ๋ฅผ ์ ์ธํ๊ณ ํ ๋นํ๋ฉด Public Property(๊ณต๊ฐ ํ๋กํผํฐ)
์ด๋ค. โ ์ธ๋ถ์์ ํ๋กํผํฐ์ ์ ๊ทผํ์ฌ ๊ฐ์ ์ฌ์ฉํ๊ฑฐ๋ ์์ ์ด ๊ฐ๋ฅ
โข ํด๋์ค์์ ํ๋กํผํฐ ์์ #
ํค์๋๋ฅผ ์์ฑํ์ฌ ์ ์ธํ๋ฉด Private Property (๋น๊ณต๊ฐ ํ๋กํผํฐ)
๊ฐ ๋๋ค. โ ์ค์ง ํด๋์ค ์์์๋ง ์ฌ์ฉ, ๋ณ๊ฒฝ์ด ๊ฐ๋ฅ. ์ธ๋ถ ์ ๊ทผ ๋ถ๊ฐ
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
nextYearAge() { // ๋ฉ์๋ ์์ฑ
return Number(this.age) + 1;
}
}
// ํด๋์ค ์์
class introducePerson extends Person {
constructor(name, age, city, futureHope) {
// super ํค์๋๋ฅผ ์ด์ฉํด์ ์์ class์์ ๋ถ๋ชจ ๋ฉ์๋๋ฅผ ํธ์ถ
super(name, age, city);
this.futureHope = futureHope
}
introduce () {
return `์ ๋ ${this.city}์ ์ฌ๋ ${this.name} ์
๋๋ค.
๋ด๋
์ ${super.nextYearAge()}์ด์ด๋ฉฐ,
์ฅ๋ํฌ๋ง์ ${this.futureHope} ์
๋๋ค.`
}
}
let kim = new introducePerson('kim','23','seoul', '๊ฐ๋ฐ์');
console.log(kim.introduce())
๊ฐ์ฒด์ ๋ฐฐ์ด์ ๊ฐ์ ์ฝ๊ฒ ๋ณ์๋ก ์ ์ฅํ ์ ์๋ค.
๊ฐ์ฒด์์ ๊ฐ์ ๊บผ๋ผ ๋๋ ์ค๊ดํธ๋ฅผ ์ฌ์ฉํด์ key์ ๊ฐ์ ์ด๋ฆ์ผ๋ก ๊บผ๋ด์ฌ ์ ์๊ณ , key์ ๋ค๋ฅธ ์ด๋ฆ์ผ๋ก ๊บผ๋ผ ๋๋ ๋ณ์์ด๋ฆ: ํค๊ฐ์ผ๋ก ๊บผ๋ด์ฌ ์ ์๋ค.
const introduce = {name: 'unknown', age: 23};
// key์ ๊ฐ์ ์ด๋ฆ์ผ๋ก ๋ณ์ ์ ์ธ
const { name, age } = introduce;
// ๋ค๋ฅธ ์ด๋ฆ์ผ๋ก ๋ณ์ ์ ์ธ -> ๋ณ์์ด๋ฆ: ํค๊ฐ
const { myName: name, myAge: age } = introduce;
console.log(myName) // unknown
console.log(myAge) // 23
๋ฐฐ์ด์์ ๊ฐ์ ๊บผ๋ผ ๋๋ ๋๊ดํธ๋ฅผ ์ฌ์ฉํด์ ์์์๋ถํฐ ์์ฐจ์ ์ผ๋ก ๊บผ๋ด์ฌ ์ ์๋ค.
const fruits = ['apple', 'mango', 'grape'];
// ์์์๋ถํฐ ์์ฐจ์ ์ผ๋ก ๋ณ์ ์ ์ธ ๊ฐ๋ฅ
const [zero, one, two] = fruits;
console.log(zero) // apple
Rest Operator(๋๋จธ์ง ๋งค๊ฐ๋ณ์)๋ ๋๋จธ์ง ํ์ ๋งค๊ฐ๋ณ์๋ค์ ๋ฌถ์ด ํ๋์ ๋ฐฐ์ด์ ์ ์ฅํด์ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. ๋ฌถ์ด์ค ๋งค๊ฐ๋ณ์ ์์ ...
์ ๋ถ์ฌ์ ์์ฑํ๋ฉด ๋๋ค.
์ฆ, Rest Operator๋ ๋ฐฐ์ด๊ณผ ํจ์์ ์ธ์ ์ค ๋๋จธ์ง๋ฅผ ๊ฐ๋ฆฌํค๋ฉฐ, ๊ฐ์ฒด์ ๋๋จธ์ง ํ๋๋ฅผ ๊ฐ๋ฆฌํจ๋ค.
// args์ 1,2,3,4,5๊ฐ ํ๊บผ๋ฒ์ ๋ฐฐ์ด๋ก ๋ด๊ฒจ ์ธ์๋ก ๋๊ฒจ์ง๋ค.
function func1(...args) {
console.log(`args: [${args}]`)
// args: [1,2,3,4,5]
}
func1(1,2,3,4,5);
// arg1์๋ 1, arg2์๋ 2, arg3์๋ ๋๋จธ์ง 3,4,5๊ฐ ๋ฐฐ์ด๋ก ๋ด๊ฒจ ์ธ์๋ก ๋๊ฒจ์ง๋ค.
function func2(arg1, arg2, ...arg3) {
console.log(`arg1: ${arg1}, arg2: ${arg2}, arg3: [${arg3}]`)
// arg1: 1, arg2: 2, arg3: [3,4,5]
}
func2(1,2,3,4,5);
func(์ธ์1, ์ธ์2, ...์ธ์๋ค)
๋ก ๋๊ฒจ์ฃผ๊ฒ ๋๋ฉด ์ธ์1, ์ธ์2์ฒ๋ผ ์ง์ ๋ ์ธ์๋ ์์์๋ถํฐ ๊ฐ๊ฐ์ ๊ฐ์ ๋ฃ์ด์ฃผ๊ณ ๊ทธ ๋ค์ ๋๋จธ์ง ํ์ ์ธ์๋ค์ ๋ฐฐ์ด์ ์ธ์๋ค๋ก ๋ฌถ์ด์ ๋ณด๋ด์ฃผ๋ ๊ฒ์ด๋ค.
Rest Operator๋ ํจ์ ์ ์์๋ ํ๋์ ...
๋ง ์กด์ฌํ ์ ์์ผ๋ฉฐ, ๋ฐ๋์ ๋ง์ง๋ง ๋งค๊ฐ๋ณ์์ฌ์ผ ํ๋ค.
func(...wrong, arg2, arg3)
// ํ๋ฆฐ ์. ...wrong์ด ๋ง์ง๋ง์ผ๋ก ์์ผ ํ๋ค.
Spread Operator(์ ๊ฐ ๊ตฌ๋ฌธ)๋ ๋ฌถ์ธ ๋ฐฐ์ด ํน์ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ณ์ ์ธ ์์๋ก ๋ถ๋ฆฌํ๋ค. ์ฆ, Rest์ ๋ฐ๋ ๊ฐ๋
์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋๊ณ , ๋ง์ฐฌ๊ฐ์ง๋ก ์ ๊ฐํ ๋งค๊ฐ๋ณ์ ์์ ...
์ ๋ถ์ฌ์ ์์ฑํ๋ฉด ๋๋ค.
๋ฐ๋ผ์, ๋ฐฐ์ด๊ณผ ํจ์์์ ๋ ๋ค๋ฅธ ๋ฐฐ์ด๊ณผ ํจ์์ ์ธ์๋ก์ ์ ๊ฐ๋ฅผ, ๊ฐ์ฒด์์ ๋ ๋ค๋ฅธ ๊ฐ์ฒด๋ก์ ์ ๊ฐ๋ฅผ ํ๋ค.
let arr = [1, 2, 3, 4, 5];
console.log(...arr);
// 1 2 3 4 5
var str = 'javascript';
console.log(...str);
// "j" "a" "v" "a" "s" "c" "r" "i" "p" "t"
Spread Operator๋ Rest Operator์ ๋ง์ฐฌ๊ฐ์ง๋ก ...
์ ์์ฑ ์์์ ์ฃผ์ํด์ผ ํ๋ค. ๋ฑ์ฅ ์์์ ๋ฐ๋ผ, ๋ฎ์ด์์ ์ง ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
var obj = { name: '์งฑ๊ตฌ', species: 'human'};
obj = { ...obj, age: 5};
console.log(obj)
// {name: "์งฑ๊ตฌ", species: "human", age: 5}
obj = { ...obj, name: '์งฑ์', age: 1};
console.log(obj);
// {name: "์งฑ์", species: "human", age: 11}
์ ์์ ์ ๊ฐ์ด ...obj
๊ฐ ๋จผ์ ๋์ค๊ณ name๊ณผ age๊ฐ ๋์ค์ ๋ฑ์ฅํจ์ผ๋ก์จ ๋ฎ์ด์์์ ธ ๊ฐ์ด ๋ณ๊ฒฝ๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
forEach()์ map()์ ๋ฐ๋ณต๋ฌธ์ ๋๋ฉฐ ๋ฐฐ์ด ์์ ์์๋ค์ 1๋1๋ก ์ง์ง์ด ์ฃผ๋ ์ญํ ์ ํ๋ค.
- forEach()
: ๋ฐฐ์ด ์์๋ง๋ค ํ ๋ฒ์ฉ ์ฃผ์ด์ง ํจ์(์ฝ๋ฐฑ)๋ฅผ ์คํ
๋ฐฐ์ด.forEach((์์, ์ธ๋ฑ์ค, ๋ฐฐ์ด) => { return ์์ });
- map()
: ๋ฐฐ์ด ๋ด์ ๋ชจ๋ ์์ ๊ฐ๊ฐ์ ๋ํ์ฌ ์ฃผ์ด์ง ํจ์(์ฝ๋ฐฑ)๋ฅผ ํธ์ถํ ๊ฒฐ๊ณผ๋ฅผ ๋ชจ์ ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํ
๋ฐฐ์ด.map((์์, ์ธ๋ฑ์ค, ๋ฐฐ์ด) => { return ์์ });
ํ์ง๋ง forEach()์ map()์ ์ญํ ์ ๊ฐ์ง๋ง, ๋ฆฌํด๊ฐ์ ์ฐจ์ด๊ฐ ์๋ค.
forEach()๋ ๊ธฐ์กด์ ๋ฐฐ์ด์ ๋ณ๊ฒฝํ๋ ๋ฐ๋ฉด, map()์ ๊ฒฐ๊ณผ๊ฐ์ผ๋ก ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํํ๋ค.
var arr = [1,2,3,4,5];
// forEach()
var newArr = arr.forEach(function(e, i) {
return e;
});
// return -> undefined
// map()
var newArr = arr.map(function(v, i, arr) {
return v + 1;
});
// return -> 2, 3, 4, 5, 6
reduce()
: ๋ฐฐ์ด์ ๊ฐ ์์๋ฅผ ์ํํ๋ฉฐ callbackํจ์์ ์คํ ๊ฐ์ ๋์ ํ์ฌ ํ๋์ ๊ฒฐ๊ณผ๊ฐ์ ๋ฐํ
๋ฐฐ์ด.reduce((๋์ ๊ฐ, ํ์ฟ๊ฐ, ์ธ๋ฑ์ค, ์์) => { return ๊ฒฐ๊ณผ }, ์ด๊น๊ฐ);
result = sum.reduce((prev, curr, i) => {
console.log(prev, curr, i);
return prev + curr;
}, 0);
// 0 1 0
// 1 2 1
// 3 3 2
result; // 6
* ์ด๊น๊ฐ์ ์ ์ด์ฃผ์ง ์์ผ๋ฉด ์๋์ผ๋ก ์ด๊น๊ฐ์ด 0๋ฒ์งธ ์ธ๋ฑ์ค์ ๊ฐ์ด ๋๋ค.
* reduce()๋ ์ด๊น๊ฐ์ ๋ฐฐ์ด๋ก ๋ง๋ค๊ณ , ๋ฐฐ์ด์ ๊ฐ๋ค์ pushํ๋ฉด map๊ณผ ๊ฐ์์ง๋ค.
์ฐธ๊ณ ์๋ฃ
๐ฐ ์๋ฆฌ์ค SW ์์ง๋์ด ํธ๋ 2๊ธฐ
๐ var, let, const ์ฐจ์ด์ / var, let, const์ ์ฐจ์ด
๐ ํ ํ๋ฆฟ ๋ฆฌํฐ๋ด: ๋ฐฑํฑ(``), ๋ฌ๋ฌ(${ }) ์ฌ์ฉ๋ฒ
๐ ํ์ดํ ํจ์ ๊ธฐ๋ณธ
๐ default export์ named export ์ฐจ์ด์
๐ ์๋ฐ์คํฌ๋ฆฝํธ์์ Class ์ฌ์ฉํ๊ธฐ
๐ ๋๋จธ์ง ๋งค๊ฐ๋ณ์
๐ ์ ๊ฐ ๊ตฌ๋ฌธ
๐ Spread Operator (์คํ๋ ๋ ์ฐ์ฐ์)
๐ forEach()์ map()์ ๋น๊ต ๋ฐ ๋ถ์
๐ reduce() ํ์ฉํ๊ธฐ