一.let和const聲明
(1).let聲明具有以下4個特性:
1.let聲明的變量不會掛在window中，不會造成全局變量的污染
2.新增了一個塊級作用域{}，以前只有函數作用域，全局作用域
3.let是不允許重複聲明
4.let不會有聲明提前
eg:
{
let a = 10;
var b = 1;
var a=1;//報錯 let是不允許重複聲明
}
console.log(a) //報錯 ReferenceError: a is not defined.
console.log(b) // 1
(2).const
1.跟let完全相同 增加幾個點
2.不允許被修改(不允許改變內存空間的地址)
3.const聲明和賦值必須一次性完成，並且後期不允許改變存儲空間的地址
eg:
const PI = 3.1415;
PI // 3.1415
PI = 3;// TypeError: Assignment to constant variable.
const PI=44;//報錯
const a;//報錯(const一旦聲明變量，就必須立即初始化，不能留到以後賦值)
二.字符串模板
eg:插入字符串模板
var a = 5;
var b = 10;
console.log('Fifteen is ' + (a + b) + ' and\nnot ' + (2 * a + b) + '.');
// "Fifteen is 15 and
// not 20."
模板字符串使用反引號 (``) 來代替普通字符串中的用雙引號和單引號。模板字符串可以包含特定語法（${expression}）的佔位符。佔位符中的表達式和周圍的文本會一起傳遞給一個默認函數，該函數負責將所有的部分連接起來，如果一個模板字符串由表達式開頭，則該字符串被稱爲帶標籤的模板字符串，該表達式通常是一個函數，它會在模板字符串處理後被調用，在輸出最終結果前，你都可以通過該函數來對模板字符串進行操作處理。在模版字符串內使用反引號（`）時，需要在它前面加轉義符（\）。
三.結構化賦值
可以簡化書寫的長度，提升效率
eg:
var a = 1;
var b = 2;
var c = 3;
//ES6允許寫成下面這樣。
var [a, b, c] = [1, 2, 3];
//這種寫法屬於“模式匹配”，只要等號兩邊的模式相同，左邊的變量就會被賦予對應的值。下面是一些使用嵌套數組進行解構的例子。
let [foo, [[bar], baz]] = [1, [[2], 3]];
foo // 1
bar // 2
baz // 3
let [ , , third] = ["foo", "bar", "baz"];
third // "baz"
let [x, , y] = [1, 2, 3];
x // 1
y // 3
let [head, ...tail] = [1, 2, 3, 4];
head // 1
tail // [2, 3, 4]
let [x, y, ...z] = ['a'];
x // "a"
y // undefined
z // []
//如果解構不成功的話值爲undefin
var [foo] = [];
var [bar, foo] = [1];
//foo值爲undefin
…運算符
寫 收集
運用在數組中，函數中 object是ES7新增的
eg:
//擴展運算符（ spread ）是三個點（...）。它好比 rest 參數的逆運算，將一個數組轉爲用逗號分隔的參數序列。
console.log(...[1,2,3]); // 1 2 3 2 console.log(1,...[1,2,3],5); // 1 1 2 3 5
//擴展運算符提供了數組合並的新寫法。
var arr1 = [0,1,2];
var arr2 = [3,4,5];
arr1.push(...arr2); // [0,1,2,3,4,5]
console.log(arr1);
var arr4 = ['a','b'];
var arr5 = ['c'];
var arr6 = ['d','e'];
// es5合併數組
arr4.concat(arr5,arr6);
// es6合併數組
var newArr = [...arr4,...arr5,...arr6];
console.log(newArr);
//求數組的的最大值
console.log(Math.max(...[14,2,7])); // 14
//如果將擴展運算符用於數組賦值，只能放在參數的最後一位，否則會報錯
const [first,...rest] = [1,2,3,4,5];
console.log(first); // 1
console.log(rest); // [2,3,4,5]
// 如果將擴展運算符用於數組賦值，只能放在參數的最後一位，否則會報錯。
const [f,...r] = [];
console.log(f,r); // undfined,[]
const [f1,...r1] = ["foo"];
console.log(f1,r1); // foo,[]
函數的真正用途
1.普通函數 純小寫
2.構造函數 大駝峯命名 首字母大寫
3.新增 new.target 構造函數必須使用new來進行調用
1()new.target的作用
限制類的調用方法，判斷new.target是不是未定義和寫出只能被繼承使用的類
eg:
class Shape {
constructor() {
if (new.target === Shape) {
throw new Error('本類不能實例化');
}
}
}
class Rectangle extends Shape {//繼承
constructor(length, width) {
super();
// ...
}
}
var x = new Shape(); // 報錯
var y = new Rectangle(3, 4); // 正確
箭頭函數
語法：箭頭函數是一個函數表達式，理論上，任何使用函數表達式的地方都可以改成箭頭函數
(參數1,參數2…) => {
函數體
}
//在ES5中我們實現一個求和的函數：
var sum = function(x, y) {
return x + y
}
//es6:
var sum = (x, y) => {
return x + y
}
//函數體只有一條返回語句時， 我們可以省略括號{}和return關鍵詞：
var sum = (x, y) => x + y
// ES5
var array = ['1', '2345', '567', '89'];
array = array.filter(function (item) {
return item.length > 2;
});
// ["2345", "567"]
// ES6
let array = ['1', '2345', '567', '89'];
array = array.filter(item => item.length > 2);
// ["2345", "567"]
箭頭函數中的 this
箭頭函數內的this值繼承自外圍作用域。運行時它會首先到它的父作用域找，如果父作用域還是箭頭函數，那麼接着向上找，直到找到我們要的this指向。
eg:經典面試題
// var name = 'leo';
// var teacher = {
// name: "lilei",
// showName: function () {
// let showTest = ()=>alert(this.name);
// showTest();
// }
// };
// teacher.showName();//lilei
var name = 'leo';
var teacher = {
name: "lilei",
showName: function () {
function showTest() {
alert(this.name);
}
showTest();
}
};
teacher.showName()//leo
對象
ES6允許直接寫入變量和函數，作爲對象的屬性和方法
eg:
var foo = 'bar';
var baz = {foo};
baz // {foo: "bar"}
// 等同於
var baz = {foo: foo};
//ES6允許在對象之中，直接寫變量。這時，屬性名爲變量名, 屬性值爲變量的值
function f(x, y) {
return {x, y};
}
// 等同於
function f(x, y) {
return {x: x, y: y};
}
f(1, 2) // Object {x: 1, y: 2}
//方法也可以簡寫
var o = {
method() {
return "Hello!";
}
};
// 等同於
var o = {
method: function() {
return "Hello!";
}
};
//綜合實際舉例:
var birth = '2000/01/01';
var Person = {
name: '張三',
//等同於birth: birth
birth,
// 等同於hello: function ()...
hello() { console.log('我的名字是', this.name); }
};
新增了API:
eg:
//1.is() ===
Object.is('foo', 'foo')
// true
Object.is({}, {})
// false
//2.assign() 用於混合對象，帶淺克隆
var obj1 = {a: {b: 1}};
var obj2 = Object.assign({}, obj1);
obj1.a.b = 2;
obj2.a.b // 2
//3..getOwnPropertyNames()返回一個數組，包含對象自身的所有屬性
//4.setPrototypeOf() 等價於==