ES 6新特性(Day07)
Part1 · JavaScript【深度剖析】
ES 6新特性
檢視我整理的ES新特性思維導圖,參照思維導圖可以巨集觀角度來學習ES6的新特性。傳送門:ES新特性思維導圖,或直接儲存下圖。
文章說明:本專欄內容為本人參加【拉鉤大前端高新訓練營】的學習筆記以及思考總結,學徒之心,僅為分享。如若有誤,請在評論區支出,如果您覺得專欄內容還不錯,請點贊、關注、評論。
共同進步!
上一篇:【ECMAScript模板字串】、【ES6引數】、【展開陣列、物件】、【箭頭函式】、【物件】、【代理Proxy】、【class類】、【set、map資料結構】
接上一篇文章繼續看ES6的特性,本片主要講Symbol、for…of迴圈、可迭代介面、迭代器模式、生成器及生成器的應用、ES Modules、ES2016和2017的概述。同樣,本篇部落格內容較多,可以先Mark後看。
十六、Symbol符號
在ES6之前,物件的屬性名都是用字串表示,而這樣會導致,物件的屬性名重複造成衝突,例如屬性值覆蓋等問題。
// shared.js ====================================
const cache = {}
// a.js =========================================
cache['foo'] = Math.random()
// b.js =========================================
cache['foo'] = '123'
console.log(cache['foo']) // 123
之前的解決方式基本為約定,例如a.js檔案中的鍵名都為a_foo,b.js檔案中的鍵名為b_foo,這樣就不會造成屬性名重複衝突的問題。而約定只是為了規避這個問題,並沒有實際解決這個問題。
ES6中為了解決這個問題,提出了一個新的資料型別**(Symbol)符號**。符號是原始值,且符號例項是唯一、不可變的。符號的用途是確保物件屬性使用唯一識別符號,不會發生屬性衝突的危險。
1.基本使用–Symbol()
const s = Symbol()
console.log(s)
console.log(typeof s)
// 兩個 Symbol 永遠不會相等
console.log(
Symbol() === Symbol()
) // false
呼叫 Symbol()函式時,也可以傳入一個字串引數作為對符號的描述(description),將來可以通過這個字串來除錯程式碼。但是,這個字串引數與符號定義或標識完全無關:
let genericSymbol = Symbol();
let otherGenericSymbol = Symbol();
let fooSymbol = Symbol('foo');
let otherFooSymbol = Symbol('foo');
console.log(genericSymbol == otherGenericSymbol); // false
console.log(fooSymbol == otherFooSymbol); // false
符號沒有字面量語法,這也是它們發揮作用的關鍵。按照規範,你只要建立 Symbol()例項並將其用作物件的新屬性,就可以保證它不會覆蓋已有的物件屬性,無論是符號屬性還是字串屬性。
let genericSymbol = Symbol();
console.log(genericSymbol); // Symbol()
let fooSymbol = Symbol('foo');
console.log(fooSymbol); // Symbol(foo);
最重要的是,Symbol()函式不能與 new 關鍵字一起作為建構函式使用。這樣做是為了避免建立符號包裝物件,像使用 Boolean、String 或 Number 那樣,它們都支援建構函式且可用於初始化包含原始值的包裝物件:
let myBoolean = new Boolean();
console.log(typeof myBoolean); // "object"
let myString = new String();
console.log(typeof myString); // "object"
let myNumber = new Number();
console.log(typeof myNumber); // "object"
let mySymbol = new Symbol(); // TypeError: Symbol is not a constructor
2.使用全域性符號登錄檔–Symbol.for()
如果執行時的不同部分需要共享和重用符號例項,那麼可以用一個字串作為鍵,在全域性符號登錄檔中建立並重用符號。也就是說可以使用一個字串引數作為Symbol的描述符,這樣在使用過程中可以重用這一定義的symbol。
let fooGlobalSymbol = Symbol.for('foo'); // 建立新符號
let otherFooGlobalSymbol = Symbol.for('foo'); // 重用已有符號
console.log(fooGlobalSymbol === otherFooGlobalSymbol); // true
Symbol.for()對每個字串鍵都執行冪等操作。第一次使用某個字串呼叫時,它會檢查全域性執行時登錄檔(也可以理解為一個對映關係表),發現不存在對應的符號,於是就會生成一個新符號例項並新增到登錄檔中。後續使用相同字串的呼叫同樣會檢查登錄檔,發現存在與該字串對應的符號,然後就會返回該符號例項。
即使採用相同的符號描述,在全域性登錄檔中定義的符號跟使用 Symbol()定義的符號也並不等同:
let localSymbol = Symbol('foo');
let globalSymbol = Symbol.for('foo');
console.log(localSymbol === globalSymbol); // false
全域性登錄檔中的符號必須使用字串來建立,因此傳遞給Symbol的任何引數都會被轉換為字串:
const boolSymbol = Symbol.for(true);
const stringSymbol = Symbol.for('true');
console.log(boolSymbol === stringSymbol); // true
還可以使用**Symbol.keyFor()**來查詢全域性登錄檔,這個方法接收符號,返回該全域性符號對應的字串鍵。如果查詢的不是全域性符號,則返回 undefined。
// 建立全域性符號
let s = Symbol.for('foo');
console.log(Symbol.keyFor(s)); // foo
// 建立普通符號
let s2 = Symbol('bar');
console.log(Symbol.keyFor(s2)); // undefined
// 如果傳給 Symbol.keyFor()的不是符號,則該方法丟擲 TypeError:
Symbol.keyFor(123); // TypeError: 123 is not a symbol
3.使用符號作為屬性
**凡是可以使用字串或數值作為屬性的地方,都可以使用符號。這就包括了物件字面量屬性和Object.defineProperty()/Object.defineProperties()**定義的屬性。物件字面量只能在計算屬性語法中使用符號作為屬性。
let s1 = Symbol('foo'),
s2 = Symbol('bar'),
s3 = Symbol('baz'),
s4 = Symbol('qux');
let o = {
[s1]: 'foo val'
};
// 這樣也可以:o[s1] = 'foo val';
console.log(o);
// {Symbol(foo): foo val}
Object.defineProperty(o, s2, {value: 'bar val'});
console.log(o);
// {Symbol(foo): foo val, Symbol(bar): bar val}
Object.defineProperties(o, {
[s3]: {value: 'baz val'},
[s4]: {value: 'qux val'}
});
console.log(o);
// {Symbol(foo): foo val, Symbol(bar): bar val,
// Symbol(baz): baz val, Symbol(qux): qux val}
類似於 Object.getOwnPropertyNames()返回物件例項的常規屬性陣列,Object.getOwnPropertySymbols()返回物件例項的符號屬性陣列。這兩個方法的返回值彼此互斥。Object.getOwnPropertyDescriptors()會返回同時包含常規和符號屬性描述符的物件。Reflect.ownKeys()會返回兩種型別的鍵:
let s1 = Symbol('foo'),
s2 = Symbol('bar');
let o = {
[s1]: 'foo val',
[s2]: 'bar val',
baz: 'baz val',
qux: 'qux val'
};
console.log(Object.getOwnPropertySymbols(o));
// [Symbol(foo), Symbol(bar)] 返回物件例項的符號屬性陣列
console.log(Object.getOwnPropertyNames(o));
// ["baz", "qux"] 返回物件例項的常規屬性陣列
console.log(Object.getOwnPropertyDescriptors(o));
// {baz: {...}, qux: {...}, Symbol(foo): {...}, Symbol(bar): {...}} 返回同時包含常規和符號屬性描述符的物件
console.log(Reflect.ownKeys(o));
// ["baz", "qux", Symbol(foo), Symbol(bar)]返回兩種型別的鍵**
因為符號屬性是對記憶體中符號的一個引用,所以直接建立並用作屬性的符號不會丟失。但是,如果沒有顯式地儲存對這些屬性的引用,那麼必須遍歷物件的所有符號屬性才能找到相應的屬性鍵:
let o = {
[Symbol('foo')]: 'foo val',
[Symbol('bar')]: 'bar val'
};
console.log(o);
// {Symbol(foo): "foo val", Symbol(bar): "bar val"}
let barSymbol = Object.getOwnPropertySymbols(o)
.find((symbol) => symbol.toString().match(/bar/));
console.log(barSymbol);
// Symbol(bar)
4.常用內建符號
ECMAScript 6 也引入了一批常用內建符號(well-known symbol),用於暴露語言內部行為,開發者可以直接訪問、重寫或模擬這些行為。這些內建符號都以 Symbol 工廠函式字串屬性的形式存在。這些內建符號最重要的用途之一是重新定義它們,從而改變原生結構的行為。比如,我們知道for-of 迴圈會在相關物件上使用 Symbol.iterator 屬性,那麼就可以通過在自定義物件上重新定義Symbol.iterator 的值,來改變 for-of 在迭代該物件時的行為。
for of中的Symbol.iterator我們會在下面的一節講到
這些內建符號也沒有什麼特別之處,它們就是全域性函式 Symbol 的普通字串屬性,指向一個符號的例項。所有內建符號屬性都是不可寫、不可列舉、不可配置的。
注意 在提到 ECMAScript 規範時,經常會引用符號在規範中的名稱,字首為@@。比如,@@iterator 指的就是 Symbol.iterator。
5.Symbol方法
Symbol提供了一些方法,方法如下所示,具體使用技巧可檢視MDN或《JavaScript高階程式設計第四版》
- Symbol.asyncIterator
- Symbol.hasInstance
- Symbol.isConcatSpreadable
- Symbol.iterator
- Symbol.match
- Symbol.replace
- Symbol.search
- Symbol.species
- Symbol.split
- Symbol.toPrimitive
- Symbol.toStringTag
- Symbol.unscopables
十七、for…of迴圈
在ECMAScript中,遍歷資料有很多的方法。例如,for迴圈通常用來遍歷陣列,for…in迴圈通常用來遍歷鍵值對,函式式的遍歷方法如:forEach方法。這些方法都會有一定的侷限性。所有ES2015引入了一種全新的遍歷方式,for…of,其作為以後遍歷所有資料結構的統一方式。
for-of 語句是一種嚴格的迭代語句,用於遍歷可迭代物件的元素,語法如下:
for (property of expression) statement
// 示例
for (const el of [2,4,6,8]) {
document.write(el);
}
在這個例子中,我們使用 for-of 語句顯示了一個包含 4 個元素的陣列中的所有元素。迴圈會一直持續到將所有元素都迭代完。與 for 迴圈一樣,這裡控制語句中的 const 是非必需的。但為了確保這個區域性變數不被修改,推薦使用 const。
for-of 迴圈會按照可迭代物件的 next()方法產生值的順序迭代元素。關於可迭代物件,將在下面進行詳細介紹。
如果嘗試迭代的變數不支援迭代,則 for-of 語句會丟擲錯誤。
const arr = [100, 200, 300, 400]
for (const item of arr) {
console.log(item)
}
// for...of 迴圈可以替代 陣列物件的 forEach 方法
其可替代forEach方法進行遍歷,而且優點是可以隨時使用break方法終止迴圈:
arr.forEach(item => {
console.log(item)
})
for (const item of arr) {
console.log(item)
if (item > 100) {
break
}
// forEach 無法跳出迴圈,必須使用 some 或者 every 方法
除了陣列可以使用for…of遍歷,一些偽陣列同樣也可以進行迴圈遍歷,例如:函式中arguments物件、DOM中元素節點列表,他們與普通陣列物件沒有任何區別,這裡就不單獨演示了。
Set和Map物件:
// 遍歷 Set 與遍歷陣列相同
const s = new Set(['foo', 'bar'])
for (const item of s) {
console.log(item)
}
// foo
// bar
// 遍歷 Map 可以配合陣列結構語法,直接獲取鍵值
const m = new Map()
m.set('foo', '123')
m.set('bar', '345')
for (const [key, value] of m) {
// 使用陣列展開方法
console.log(key, value)
}
// foo 123
// bar 345
普通物件不能被for…of遍歷,至於原因,請看下面的可迭代介面,其中包含了一下Symbol.iterator:
// 普通物件不能被直接 for...of 遍歷
const obj = { foo: 123, bar: 456 }
for (const item of obj) {
console.log(item)
}
十八、可迭代介面
ES中能夠表示有結構的資料型別越來越多,從最早的陣列和物件,到現在新增了set和map,並且還可以組合使用這些型別。為了提供一種統一的遍歷方式,ES2015提供了一種統一的Iterable介面。例如ES中任意一種資料型別都有toString方法,這就是他們都實現了統一的規格標準(統一的介面)
實現Iterable介面就是for…of的前提,只要資料結構實現了可迭代介面,他就能被for…of遍歷,也就是說之前的所有資料型別都實現了可迭代介面。
1.Iterator
在chrome瀏覽器的控制檯進行測試:
Chrome-console控制檯
console.log([]); // 列印陣列
[]
length: 0
__proto__: Array(0)
...
Symbol(Symbol.iterator): ƒ values() // Symbol.iterator可迭代介面
Symbol(Symbol.unscopables): {copyWithin: true, entries: true, fill: true, find: true, findIndex: true, …}
__proto__: Object
console.log(new Set()); // 列印Set
Set(0) {}
[[Entries]]
size: (...)
__proto__: Set
add: ƒ add()
...
Symbol(Symbol.iterator): ƒ values() // Symbol.iterator可迭代介面
Symbol(Symbol.toStringTag): "Set"
get size: ƒ size()
__proto__: Object
console.log(new Map()); // 列印Map
Map(0) {}
[[Entries]]
size: (...)
__proto__: Map
clear: ƒ clear()
...
Symbol(Symbol.iterator): ƒ entries() // Symbol.iterator可迭代介面
Symbol(Symbol.toStringTag): "Map"
get size: ƒ size()
__proto__: Object
繼續看看Symbol.iterator到底實現了什麼:
Chrome-console控制檯
const arr = ['foo', 'bar', 'baz']
undefined
arr[Symbol.iterator]()
Array Iterator {}
__proto__: Array Iterator
next: ƒ next()
arguments: (...)
caller: (...)
length: 0
name: "next"
...
const iterator = arr[Symbol.iterator]()
undefined
iterator.next()
{value: "foo", done: false}
value中的就是陣列中的第一個元素,done為false,當再次呼叫時,結果為相同的結構,此時的done為false。
Chrome-console控制檯
iterator.next()
{value: "bar", done: false}
iterator.next()
{value: "bar", done: true}
done屬性的作用就是表示陣列內部的屬性是否全部遍歷完成。
模擬迭代器:
// 迭代器(Iterator)
const set = new Set(['foo', 'bar', 'baz'])
const iterator = set[Symbol.iterator]()
console.log(iterator.next()) // { value: 'foo', done: false }
console.log(iterator.next()) // { value: 'bar', done: false }
console.log(iterator.next()) // { value: 'baz', done: false }
console.log(iterator.next()) // { value: undefined, done: true }
console.log(iterator.next()) // { value: undefined, done: true }
while (true) {
const current = iterator.next()
if (current.done) {
break // 迭代已經結束了,沒必要繼續了
}
console.log(current.value)
}
2.實現iterator介面
// 實現可迭代介面(Iterable)
const obj = {
// 實現了可迭代介面,Iterable,約定內部必須有用於範湖迭代器的iterator方法
[Symbol.iterator]: function () {
// 實現了迭代器介面,iterator其內部有用於迭代的next方法
return {
next: function () {
// 迭代結果介面,iterationResult,約定物件內部必須要有value屬性,來表示當前被迭代到的資料,值為任意型別,done屬性用來表示迭代是否結束
return {
value: 'zce',
done: true
}
}
}
}
}
const obj = {
store: ['foo', 'bar', 'baz'],
[Symbol.iterator]: function () {
let index = 0
const self = this
return {
next: function () {
const result = {
value: self.store[index],
done: index >= self.store.length
}
index++
return result
}
}
}
}
3.迭代器模式
迭代器模式(特別是在 ECMAScript 這個語境下)描述了一個方案,即可以把有些結構稱為“可迭代物件”(iterable),因為它們實現了正式的 Iterable 介面,而且可以通過迭代器 Iterator 消費。
// 迭代器設計模式
// 場景:你我協同開發一個任務清單應用
// 我的程式碼 ===============================
const todos = {
life: ['吃飯', '睡覺', '打豆豆'],
learn: ['語文', '數學', '外語'],
work: ['喝茶'],
// 提供統一遍歷訪問介面
each: function (callback) {
const all = [].concat(this.life, this.learn, this.work)
for (const item of all) {
callback(item)
}
},
// 提供迭代器(ES2015 統一遍歷訪問介面)
[Symbol.iterator]: function () {
const all = [...this.life, ...this.learn, ...this.work]
let index = 0
return {
next: function () {
return {
value: all[index],
done: index++ >= all.length
}
}
}
}
}
// 你的程式碼 ===============================
// 實現統一遍歷介面之前
// for (const item of todos.life) {
// console.log(item)
// }
// for (const item of todos.learn) {
// console.log(item)
// }
// for (const item of todos.work) {
// console.log(item)
// }
// 實現統一遍歷介面之後
todos.each(function (item) {
console.log(item)
})
console.log('-------------------------------')
for (const item of todos) {
console.log(item)
}
十九、生成器及生成器的應用
生成器是 ECMAScript 6 新增的一個極為靈活的結構,擁有在一個函式塊內暫停和恢復程式碼執行的能力。這種新能力具有深遠的影響,比如,使用生成器可以自定義迭代器和實現協程。其可以避免非同步程式設計中回撥巢狀過深的問題,提供更好的額非同步程式設計解決方案。
1.基本用法
生成器的形式是一個函式,函式名稱前面加一個星號(*)表示它是一個生成器。只要是可以定義函式的地方,就可以定義生成器。
// 生成器函式宣告
function* generatorFn() {}
// 生成器函式表示式
let generatorFn = function* () {}
// 作為物件字面量方法的生成器函式
let foo = {
* generatorFn() {}
}
// 作為類例項方法的生成器函式
class Foo {
* generatorFn() {}
}
// 作為類靜態方法的生成器函式
class Bar {
static* generatorFn() {}
}
呼叫生成器函式會產生一個生成器物件。生成器物件一開始處於暫停執行(suspended)的狀態。與迭代器相似,生成器物件也實現了 Iterator 介面,因此具有 next()方法。呼叫這個方法會讓生成器開始或恢復執行。
function* foo() {
console.log('zce')
return 100
}
const result = foo()
console.log(result) // Object [Generator] {}
console.log(result.next()) // { value: 100, done: false }
yield 關鍵字可以讓生成器停止和開始執行,也是生成器最有用的地方。生成器函式在遇到 yield關鍵字之前會正常執行。遇到這個關鍵字後,執行會停止,函式作用域的狀態會被保留。停止執行的生成器函式只能通過在生成器物件上呼叫 next()方法來恢復執行:
function* foo() {
console.log('1111')
yield 100
console.log('2222')
yield 200
console.log('3333')
yield 300
}
const generator = foo()
console.log(generator.next()) // 第一次呼叫,函式體開始執行,遇到第一個 yield 暫停
console.log(generator.next()) // 第二次呼叫,從暫停位置繼續,直到遇到下一個 yield 再次暫停
console.log(generator.next()) // 。。。
console.log(generator.next()) // 第四次呼叫,已經沒有需要執行的內容了,所以直接得到 undefined
2.實際應用
在生成器物件上顯式呼叫 next()方法的用處並不大。其實,如果把生成器物件當成可迭代物件,那麼使用起來會更方便:
function* generatorFn() {
yield 1;
yield 2;
yield 3;
}
for (const x of generatorFn()) {
console.log(x);
}
// 1
// 2
// 3
// Generator 應用
// 案例1:發號器
function* createIdMaker() {
let id = 1
while (true) {
yield id++
}
}
const idMaker = createIdMaker()
console.log(idMaker.next().value) // 1
console.log(idMaker.next().value) // 2
console.log(idMaker.next().value) // 3
console.log(idMaker.next().value) // 4
// 案例2:使用 Generator 函式實現 iterator 方法
const todos = {
life: ['吃飯', '睡覺', '打豆豆'],
learn: ['語文', '數學', '外語'],
work: ['喝茶'],
[Symbol.iterator]: function* () {
const all = [...this.life, ...this.learn, ...this.work]
for (const item of all) {
yield item
}
}
}
for (const item of todos) {
console.log(item)
}
二十、ES2016和ES2017概述
1.ES2016
新增陣列例項物件的includes方法,檢查陣列中是否包含某個指定元素
const arr = ['foo', 1, NaN, false]
// 找到返回元素下標
console.log(arr.indexOf('foo'))
// 找不到返回 -1
console.log(arr.indexOf('bar'))
// 無法找到陣列中的 NaN
console.log(arr.indexOf(NaN))
includes方法
// 直接返回是否存在指定元素
console.log(arr.includes('foo'))
// 能夠查詢 NaN
console.log(arr.includes(NaN))
新增指數運算子
console.log(Math.pow(2, 10))
console.log(2 ** 10) // 語言本身的運算子與加減乘除相同
2.ES2017
object物件的三個擴充套件方法
- Object.values
- Object.entries
- Object.getOwnPropertyDescriptiors
const obj = {
foo: 'value1',
bar: 'value2'
}
// Object.values -------------------返回物件中所有值組成的陣列----------------------------------------
console.log(Object.values(obj))
// Object.entries ------------------以陣列的形式返回物件中所有的鍵值對----------------------------------------
console.log(Object.entries(obj))
// 可以直接使用for...of遍歷
for (const [key, value] of Object.entries(obj)) {
console.log(key, value)
}
// 將物件轉換為Map型別的物件
console.log(new Map(Object.entries(obj)))
// Object.getOwnPropertyDescriptors ----------獲取物件中屬性的完整描述資訊------------------------------
const p1 = {
firstName: 'Lei',
lastName: 'Wang',
get fullName() {
return this.firstName + ' ' + this.lastName
}
}
console.log(p1.fullName)
const p2 = Object.assign({}, p1)
p2.firstName = 'zce'
console.log(p2)
const descriptors = Object.getOwnPropertyDescriptors(p1)
console.log(descriptors)
const p2 = Object.defineProperties({}, descriptors)
p2.firstName = 'zce'
console.log(p2.fullName)
字串方法
- String.prototype.padStart
- String.prototype.padEnd
const books = {
html: 5,
css: 16,
javascript: 128
}
for (const [name, count] of Object.entries(books)) {
console.log(name, count)
}
for (const [name, count] of Object.entries(books)) {
console.log(`${name.padEnd(16, '-')}|${count.toString().padStart(3, '0')}`)
}
//html 5
//css 16
//javascript 128
//html------------|005
//css-------------|016
//javascript------|128
今日分享截止到這裡,明天更新:TypeScript部分。
記錄:2020/11/07
相關文章
- ES6新特性
- es6新特性分享
- ES6新特性總結
- 玩轉ES6新特性
- ES6 新特性之SymbolSymbol
- 前端-JavaScript新特性(ES6)前端JavaScript
- ES6常用的新特性
- 淺析ES6新特性
- ES6新特性Promise詳解Promise
- javascript ES6 新特性之 解構JavaScript
- js--ES6新特性之解構JS
- 簡單說說ES6新特性
- ES6常用的新特性總結
- es6新特性之 class 基本用法
- 快速掌握es6+新特性及es6核心語法盤點
- ES6中的新特性:Iterables和iterators
- es6新語法新特性總結(上)
- ES 6 新特性彙總(一圖全覽)
- ES6新特性:JavaScript中的Reflect物件JavaScript物件
- Node.js 4.0的ES6新特性。Node.js
- ES6、ES7、ES8、ES9、ES10新特性一覽
- ES5+ES6+ES7特性整理
- ES6中let 和 const 的新特性
- ES6 新特性(一部分)
- es6新特性--let,const關鍵字
- 使用ES6新特性開發微信小程式微信小程式
- JavaScript ES6 特性JavaScript
- ES6核心特性
- ES6系列之專案中常用的新特性
- es6、7、8、9新語法新特性-總結
- ES6新特性:JavaScript中的Map和WeakMap物件JavaScript物件
- ES的那些新特性
- ES7-ES9新特性概述
- ES7 ES8 新特性
- es6核心特性圖
- ES6特性之:類
- ES6、7、8常用新特性總結(超實用)
- ES6中常用的10個新特性講解