Le sucre de syntaxe ES6 comprend : 1. Un objet littéral, qui fait référence à un objet directement exprimé sous la forme de "{}" ; 2. Une fonction flèche, une nouvelle fa?on d'écrire des fonctions anonymes ; certains modèles, extrayez les valeurs des tableaux ou des objets et attribuez des valeurs aux variables?; 4. Paramètres et extensions restants 5. Cha?nes de modèle 6. Déclarations Let et const?;
L'environnement d'exploitation de ce tutoriel : système Windows 7, ECMAScript version 6, ordinateur Dell G3.
Syntaxe sugar?: fait référence à la syntaxe d'un langage de programmation qui peut exprimer plus facilement une opération. Elle peut faciliter l'utilisation du langage par les programmeurs, et l'opération peut devenir plus claire et plus pratique, ou plus conforme à celle des programmeurs. habitudes de programmation.
ES6 fournit des mises à jour non destructives pour certaines fonctions existantes. La plupart de ces mises à jour peuvent être comprises comme du sucre syntaxique, appelé sucre syntaxique, cela signifie que les choses que cette nouvelle syntaxe peut faire sont réellement applicables à ES5. être fait, mais c'est un peu plus compliqué. Dans ce chapitre, nous nous concentrerons sur ces sucres syntaxiques. Après avoir lu ceci, vous aurez peut-être une compréhension différente de certaines des nouvelles syntaxes ES6 que vous connaissez.
Object literal
Object literal fait référence à un objet directement exprimé sous la forme de {}, tel que le suivant?:{}形式直接表示的對象，比如下面這樣：
var book = {
title: 'Modular ES6',
author: 'Nicolas',
publisher: 'O′Reilly'
}ES6 為對象字面量的語法帶來了一些改進(jìn)：包括屬性/方法的簡潔表示，可計算的屬性名等等，我們逐一來看：
屬性的簡潔表示法
你有沒有遇到過這種場景，一個我們聲明的對象中包含若干屬性，其屬性值由變量表示，且變量名和屬性名一樣的。比如下面這樣，我們想把一個名為 listeners 的數(shù)組賦值給events對象中的listeners屬性，用ES5我們會這樣做：
var listeners = []
function listen() {}
var events = {
listeners: listeners,
listen: listen
}ES6則允許我們簡寫成下面這種形式：
var listeners = []
function listen() {}
var events = { listeners, listen }怎么樣，是不是感覺簡潔了許多，使用對象字面量的簡潔寫法讓我們在不影響語義的情況下減少了重復(fù)代碼。
這是ES6帶來的好處之一，它提供了眾多更簡潔，語義更清晰的語法，讓我們的代碼的可讀性，可維護(hù)性大大提升。
可計算的屬性名
對象字面量的另一個重要更新是允許你使用可計算的屬性名，在ES5中我們也可以給對象添加屬性名為變量的屬性，一般說來，我們要按下面方法這樣做，首先聲明一個名為expertise的變量，然后通過person[expertise]這種形式把變量添加為對象person的屬性：
var expertise = 'journalism'
var person = {
name: 'Sharon',
age: 27
}
person[expertise] = {
years: 5,
interests: ['international', 'politics', 'internet']
}ES6 中，對象字面量可以使用計算屬性名了，把任何表達(dá)式放在中括號中，表達(dá)式的運(yùn)算結(jié)果將會是對應(yīng)的屬性名，上面的代碼，用ES6可以這樣寫：
var expertise = 'journalism'
var person = {
name: 'Sharon',
age: 27,
[expertise]: {
years: 5,
interests: ['international', 'politics', 'internet']
}
}不過需要注意的是，簡寫屬性和計算的屬性名不可同時使用。這是因為，簡寫屬性是一種在編譯階段的就會生效的語法糖，而計算的屬性名則在運(yùn)行時才生效。如果你把二者混用，代碼會報錯。而且二者混用往往還會降低代碼的可讀性，所以JavaScript在語言層面上限制二者不能混用也是個好事。
var expertise = 'journalism'
var journalism = {
years: 5,
interests: ['international', 'politics', 'internet']
}
var person = {
name: 'Sharon',
age: 27,
[expertise] // 這里會報語法錯誤
}遇到以下情景時，可計算的屬性名會讓我們的代碼更簡潔：
某個新對象的屬性引自另一個對象：
var grocery = {
id: 'bananas',
name: 'Bananas',
units: 6,
price: 10,
currency: 'USD'
}
var groceries = {
[grocery.id]: grocery
}需構(gòu)建的對象的屬性名來自函數(shù)參數(shù)。如果使用ES5來處理這種問題，我們需要先聲明一個對象字面量，再動態(tài)的添加屬性，再返回這個對象。下面的例子中，我們創(chuàng)建了一個響應(yīng)Ajax請求的函數(shù)，這個函數(shù)的作用在于，請求失敗時，返回的對象擁有一個名為
error屬性及對應(yīng)的描述，請求成功時，該對象擁有一個名為success屬性及對應(yīng)的描述。
// ES5 寫法
function getEnvelope(type, description) {
var envelope = {
data: {}
}
envelope[type] = description
return envelope
}使用ES6提供的利用計算屬性名，更簡潔的實現(xiàn)如下：
// ES6 寫法
function getEnvelope(type, description) {
return {
data: {},
[type]: description
}
}對象字面量的屬性可以簡寫，方法其實也是可以的。
方法定義
我們先看看傳統(tǒng)上如何定義對象方法，下述代碼中，我們構(gòu)建了一個事件發(fā)生器，其中的on方法用以注冊事件，emit方法用以執(zhí)行事件：
var emitter = {
events: {},
on: function (type, fn) {
if (this.events[type] === undefined) {
this.events[type] = []
}
this.events[type].push(fn)
},
emit: function (type, event) {
if (this.events[type] === undefined) {
return
}
this.events[type].forEach(function (fn) {
fn(event)
})
}
}ES6 的對象字面量方法簡寫允許我們省略對象方法的function關(guān)鍵字及之后的冒號，改寫后的代碼如下：
var emitter = {
events: {},
on(type, fn) {
if (this.events[type] === undefined) {
this.events[type] = []
}
this.events[type].push(fn)
},
emit(type, event) {
if (this.events[type] === undefined) {
return
}
this.events[type].forEach(function (fn) {
fn(event)
})
}
}ES6中的箭頭函數(shù)可謂大名鼎鼎了，它有一些特別的優(yōu)點(diǎn)(關(guān)于this
function name(parameters) {
// function body
}ES6 est la syntaxe de l'objet littéral Il a apporté quelques améliorations?: notamment une représentation concise des propriétés/méthodes, des noms de propriétés calculables, etc. Regardons-les un par un?: ????Représentation concise des propriétés????Avez-vous déjà rencontré ce scénario ? Un objet que nous déclarons contient plusieurs attributs, dont les valeurs d'attribut sont représentées par des variables, et les noms de variables sont les mêmes que les noms d'attribut. Par exemple, comme indiqué ci-dessous, nous souhaitons attribuer un tableau nommé listeners à la propriété listeners dans l'objet events en utilisant ES5. ceci : ??var example = function (parameters) {
// function body
}??ES6 nous permet de l'abréger sous la forme suivante : ??var example = (parameters) => {
// function body
}??Que diriez-vous, cela semble beaucoup plus simple. La méthode d'écriture concise consistant à utiliser des littéraux d'objet nous permet de réduire le code répété sans affecter la sémantique. ????C'est l'un des avantages apportés par ES6. Il fournit une syntaxe sémantique beaucoup plus simple et plus claire, ce qui améliore considérablement la lisibilité et la maintenabilité de notre code. ????Noms de propriétés calculables??
??Une autre mise à jour importante des littéraux d'objet est de vous permettre d'utiliser des noms de propriétés calculables. Dans ES5, nous pouvons également donner à l'objet un attribut. variable nommée. De manière générale, nous devons procéder de la manière suivante. Déclarez d'abord une variable nommée expertise, puis passez person[expertise]. Ce formulaire ajoute la variable comme une propriété de l'objet person?: ??// ES5
var timer = {
seconds: 0,
start() {
setInterval(function(){
this.seconds++
}, 1000)
}
}
timer.start()
setTimeout(function () {
console.log(timer.seconds)
}, 3500)
> 0??Dans ES6, les littéraux d'objet peuvent utiliser des noms de propriété calculés. Mettez n'importe quelle expression entre crochets et le résultat de l'expression sera calculé sera le nom d'attribut correspondant. . Le code ci-dessus peut être écrit comme ceci dans ES6?: ??// ES6
var timer = {
seconds: 0,
start() {
setInterval(() => {
this.seconds++
}, 1000)
}
}
timer.start()
setTimeout(function () {
console.log(timer.seconds)
}, 3500)
// <- 3?? Cependant, il convient de noter que ??les attributs abrégés et les noms d'attributs calculés ne peuvent pas être utilisés en même temps??. En effet, la propriété abrégée est un sucre syntaxique qui prend effet au stade de la compilation, tandis que le nom de propriété calculé prend effet au moment de l'exécution. Si vous mélangez les deux, le code signalera une erreur. De plus, mélanger les deux réduit souvent la lisibilité du code, c'est donc également une bonne chose pour JavaScript de restreindre le mélange des deux au niveau du langage. ??function puzzle() {
return function () {
console.log(arguments)
}
}
puzzle('a', 'b', 'c')(1, 2, 3)??Lorsque vous rencontrez les scénarios suivants, les noms de propriétés calculables rendront notre code plus concis?: ??- ??Les propriétés d'un nouvel objet sont citées à partir d'un autre objet : ??
function puzzle() {
return ()=>{
console.log(arguments)
}
}
puzzle('a', 'b', 'c')(1, 2, 3)- ??Le nom d'attribut de l'objet à construire provient des paramètres de la fonction. Si nous utilisons ES5 pour résoudre ce problème, nous devons d'abord déclarer un objet littéral, puis ajouter dynamiquement des attributs, puis renvoyer l'objet. Dans l'exemple suivant, nous créons une fonction qui répond aux requêtes Ajax. La fonction de cette fonction est que lorsque la requête échoue, l'objet renvoyé a un attribut nommé
erreur et une description correspondante lors de la requête. réussit, l'objet a une propriété nommée success et une description correspondante. ??
var example = (parameters) => {
// function body
}??En utilisant le nom de propriété calculé fourni par ES6, l'implémentation la plus concise est la suivante?: ??var double = value => {
return value * 2
}??Les propriétés des littéraux d'objet peuvent être abrégées, et la méthode est en fait également possible. ????Définition de méthode??
??Voyons d'abord comment définir les méthodes objet de manière traditionnelle Dans le code suivant, nous construisons un générateur d'événements, dans lequel . La méthode on est utilisée pour enregistrer les événements, et la méthode emit est utilisée pour exécuter les événements?: ??var double = (value) => value * 2
??L'abréviation de la méthode littérale d'objet d'ES6 nous permet d'omettre la fonction des mots-clés de la méthode objet et des deux points après eux, le code réécrit est le suivant?: ??var double = value => value * 2
??La fonction flèche dans ES6 est célèbre, elle présente des avantages particuliers (à propos de this), peut-être que vous êtes comme moi, utiliser les fonctions fléchées existe depuis longtemps, mais il y a certains détails que je n'ai jamais compris auparavant, comme plusieurs abréviations des fonctions fléchées et les précautions pour leur utilisation. ??箭頭函數(shù)
erreur et une description correspondante lors de la requête. réussit, l'objet a une propriété nommée success et une description correspondante. ??JS中聲明的普通函數(shù)，一般有函數(shù)名，一系列參數(shù)和函數(shù)體，如下：
function name(parameters) {
// function body
}普通匿名函數(shù)則沒有函數(shù)名，匿名函數(shù)通常會被賦值給一個變量/屬性，有時候還會被直接調(diào)用：
var example = function (parameters) {
// function body
}ES6 為我們提供了一種寫匿名函數(shù)的新方法，即箭頭函數(shù)。箭頭函數(shù)不需要使用function關(guān)鍵字，其參數(shù)和函數(shù)體之間以=>相連接：
var example = (parameters) => {
// function body
}盡管箭頭函數(shù)看起來類似于傳統(tǒng)的匿名函數(shù)，他們卻具有根本性的不同：
箭頭函數(shù)不能被直接命名，不過允許它們賦值給一個變量；
箭頭函數(shù)不能用做構(gòu)造函數(shù)，你不能對箭頭函數(shù)使用
new關(guān)鍵字；箭頭函數(shù)也沒有
prototype屬性；箭頭函數(shù)綁定了詞法作用域，不會修改
this的指向。
最后一點(diǎn)是箭頭函數(shù)最大的特點(diǎn)，我們來仔細(xì)看看。
詞法作用域
我們在箭頭函數(shù)的函數(shù)體內(nèi)使用的this,arguments,super等都指向包含箭頭函數(shù)的上下文，箭頭函數(shù)本身不產(chǎn)生新的上下文。下述代碼中，我們創(chuàng)建了一個名為timer的對象，它的屬性seconds用以計時，方法start用以開始計時，若我們在若干秒后調(diào)用start方法，將打印出當(dāng)前的seconds值。
// ES5
var timer = {
seconds: 0,
start() {
setInterval(function(){
this.seconds++
}, 1000)
}
}
timer.start()
setTimeout(function () {
console.log(timer.seconds)
}, 3500)
> 0// ES6
var timer = {
seconds: 0,
start() {
setInterval(() => {
this.seconds++
}, 1000)
}
}
timer.start()
setTimeout(function () {
console.log(timer.seconds)
}, 3500)
// <- 3第一段代碼中start方法使用的是常規(guī)的匿名函數(shù)定義，在調(diào)用時this將指向了window，console出的結(jié)果為undefined，想要讓代碼正常工作，我們需要在start方法開頭處插入var self = this，然后替換匿名函數(shù)函數(shù)體中的this為self，第二段代碼中，我們使用了箭頭函數(shù)，就不會發(fā)生這種情況了。
還需要說明的是，箭頭函數(shù)的作用域也不能通過.call,.apply,.bind等語法來改變，這使得箭頭函數(shù)的上下文將永久不變。
我們再來看另外一個箭頭函數(shù)與普通匿名函數(shù)的不同之處，你猜猜，下面的代碼最終打印出的結(jié)果會是什么：
function puzzle() {
return function () {
console.log(arguments)
}
}
puzzle('a', 'b', 'c')(1, 2, 3)答案是1,2,3，原因是對常規(guī)匿名函數(shù)而言，arguments指向匿名函數(shù)本身。
作為對比，我們看看下面這個例子，再猜猜，打印結(jié)果會是什么？
function puzzle() {
return ()=>{
console.log(arguments)
}
}
puzzle('a', 'b', 'c')(1, 2, 3)答案是a,b,c,箭頭函數(shù)的特殊性決定其本身沒有arguments對象，這里的arguments其實是其父函數(shù)puzzle的。
前面我們提到過，箭頭函數(shù)還可以簡寫，接下來我們一起看看。
簡寫的箭頭函數(shù)
完整的箭頭函數(shù)是這樣的：
var example = (parameters) => {
// function body
}簡寫1：
當(dāng)只有一個參數(shù)時，我們可以省略箭頭函數(shù)參數(shù)兩側(cè)的括號：
var double = value => {
return value * 2
}簡寫2：
對只有單行表達(dá)式且，該表達(dá)式的值為返回值的箭頭函數(shù)來說，表征函數(shù)體的{}，可以省略，return 關(guān)鍵字可以省略，會靜默返回該單一表達(dá)式的值。
var double = (value) => value * 2
簡寫3：
上述兩種形式可以合并使用，而得到更加簡潔的形式
var double = value => value * 2
現(xiàn)在，你肯定學(xué)會了箭頭函數(shù)的基本使用方法，接下來我們再看幾個使用示例。
簡寫箭頭函數(shù)帶來的一些問題
當(dāng)你的簡寫箭頭函數(shù)返回值為一個對象時，你需要用小括號括起你想返回的對象。否則，瀏覽器會把對象的{}解析為箭頭函數(shù)函數(shù)體的開始和結(jié)束標(biāo)記。
// 正確的使用形式
var objectFactory = () => ({ modular: 'es6' })下面的代碼會報錯，箭頭函數(shù)會把本想返回的對象的花括號解析為函數(shù)體，number被解析為label,value解釋為沒有做任何事情表達(dá)式，我們又沒有顯式使用return,返回值默認(rèn)是undefined。
[1, 2, 3].map(value => { number: value })
// <- [undefined, undefined, undefined]當(dāng)我們返回的對象字面量不止一個屬性時，瀏覽器編譯器不能正確解析第二個屬性，這時會拋出語法錯誤。
[1, 2, 3].map(value => { number: value, verified: true })
// <- SyntaxError解決方案是把返回的對象字面量包裹在小括號中，以助于瀏覽器正確解析：
[1, 2, 3].map(value => ({ number: value, verified: true }))
/* <- [
{ number: 1, verified: true },
{ number: 2, verified: true },
{ number: 3, verified: true }]
*/該何時使用箭頭函數(shù)
其實我們并不應(yīng)該盲目的在一切地方使用ES6,ES6也不是一定比ES5要好，是否使用主要看其能否改善代碼的可讀性和可維護(hù)性。
箭頭函數(shù)也并非適用于所有的情況，比如說，對于一個行數(shù)很多的復(fù)雜函數(shù)，使用=>代替function關(guān)鍵字帶來的簡潔性并不明顯。不過不得不說，對于簡單函數(shù)，箭頭函數(shù)確實能讓我們的代碼更簡潔。
給函數(shù)以合理的命名，有助于增強(qiáng)程序的可讀性。箭頭函數(shù)并不能直接命名，但是卻可以通過賦值給變量的形式實現(xiàn)間接命名，如下代碼中，我們把箭頭函數(shù)賦值給變量 throwError，當(dāng)函數(shù)被調(diào)用時，會拋出錯誤，我們可以追溯到是箭頭函數(shù)throwError報的錯。
var throwError = message => {
throw new Error(message)
}
throwError('this is a warning')
<- Uncaught Error: this is a warning
at throwError如果你想完全控制你的函數(shù)中的this，使用箭頭函數(shù)是簡潔高效的，采用函數(shù)式編程尤其如此。
[1, 2, 3, 4] .map(value => value * 2) .filter(value => value > 2) .forEach(value => console.log(value))// <- 4// <- 6// <- 8
解構(gòu)賦值
ES6提供的最靈活和富于表現(xiàn)性的新特性莫過于解構(gòu)了。一旦你熟悉了，它用起來也很簡單，某種程度上解構(gòu)可以看做是變量賦值的語法糖，可應(yīng)用于對象，數(shù)組甚至函數(shù)的參數(shù)。
對象解構(gòu)
為了更好的描述對象解構(gòu)如何使用，我們先構(gòu)建下面這樣一個對象（漫威迷一定知道這個對象描述的是誰）：
// 描述Bruce Wayne的對象
var character = {
name: 'Bruce',
pseudonym: 'Batman',
metadata: {
age: 34,
gender: 'male'
},
batarang: ['gas pellet', 'bat-mobile control', 'bat-cuffs']
}假如現(xiàn)有有一個名為 pseudonym 的變量，我們想讓其變量值指向character.pseudonym,使用ES5，你往往會按下面這樣做：
var pseudonym = character.pseudonym
ES6致力于讓我們的代碼更簡潔，通過ES6我們可以用下面的代碼實現(xiàn)一樣的功能：
var { pseudonym } = character如同你可以使用var加逗號在一行中同時聲明多個變量，解構(gòu)的花括號內(nèi)使用逗號可以做一樣的事情。
var { pseudonym, name } = character我們還可以混用解構(gòu)和常規(guī)的自定義變量，這也是解構(gòu)語法靈活性的表現(xiàn)之一。
var { pseudonym } = character, two = 2解構(gòu)還允許我們使用別名，比如我們想把character.pseudonym賦值給變量 alias,可以按下面的語句這樣做，只需要在pseudonym后面加上:即可：
var { pseudonym: alias } = character
console.log(alias)
// <- 'Batman'解構(gòu)還有另外一個強(qiáng)大的功能，解構(gòu)值還可以是對象：
var { metadata: { gender } } = character當(dāng)然，對于多層解構(gòu)，我們同樣可以賦予別名，這樣我們可以通過非常簡潔的方法修改子屬性的名稱：
var { metadata: { gender: characterGender } } = character在ES5 中，當(dāng)你調(diào)用一個未曾聲明的值時，你會得到undefined:
console.log(character.boots) // <- undefined console.log(character['boots']) // <- undefined
使用解構(gòu)，情況也是類似的，如果你在左邊聲明了一個右邊對象中不存在的屬性，你也會得到undefined.
var { boots } = character
console.log(boots)
// <- undefined對于多層解構(gòu)，如下述代碼中，boots并不存在于character中，這時程序會拋出異常，這就好比你你調(diào)用undefined或者null的屬性時會出現(xiàn)異常。
var { boots: { size } } = character
// <- Exception
var { missing } = null
// <- Exception解構(gòu)其實就是一種語法糖，看以下代碼，你肯定就能很快理解為什么會拋出異常了。
var nothing = null var missing = nothing.missing // <- Exception
解構(gòu)也可以添加默認(rèn)值，如果右側(cè)不存在對應(yīng)的值，默認(rèn)值就會生效，添加的默認(rèn)值可以是數(shù)值，字符串，函數(shù)，對象，也可以是某一個已經(jīng)存在的變量：
var { boots = { size: 10 } } = character
console.log(boots)
// <- { size: 10 }對于多層的解構(gòu)，同樣可以使用默認(rèn)值
var { metadata: { enemy = 'Satan' } } = character
console.log(enemy)
// <- 'Satan'默認(rèn)值和別名也可以一起使用，不過需要注意的是別名要放在前面，默認(rèn)值添加給別名：
var { boots: footwear = { size: 10 } } = character對象解構(gòu)同樣支持計算屬性名，但是這時候你必須要添加別名，這是因為計算屬性名允許任何類似的表達(dá)式，不添加別名，瀏覽器解析時會有問題，使用如下：
var { ['boo' + 'ts']: characterBoots } = character
console.log(characterBoots)
// <- true還是那句話，我們也不是任何情況下都應(yīng)該使用解構(gòu)，語句characterBoots = character[type]看起來比{ [type]: characterBoots } = character語義更清晰，但是當(dāng)你需要提取對象中的子對象時，解構(gòu)就很簡潔方便了。
我們再看看在數(shù)組中該如何使用解構(gòu)。
數(shù)組解構(gòu)
數(shù)組解構(gòu)的語法和對象解構(gòu)是類似的。區(qū)別在于，數(shù)組解構(gòu)我們使用中括號而非花括號，下面的代碼中，通過結(jié)構(gòu)，我們在數(shù)組coordinates中提出了變量 x,y 。 你不需要使用x = coordinates[0]這樣的語法了，數(shù)組解構(gòu)不使用索引值，但卻讓你的代碼更加清晰。
var coordinates = [12, -7] var [x, y] = coordinates console.log(x) // <- 12
數(shù)組解構(gòu)也允許你跳過你不想用到的值，在對應(yīng)地方留白即可：
var names = ['James', 'L.', 'Howlett'] var [ firstName, , lastName ] = names console.log(lastName) // <- 'Howlett'
和對象解構(gòu)一樣，數(shù)組解構(gòu)也允許你添加默認(rèn)值：
var names = ['James', 'L.'] var [ firstName = 'John', , lastName = 'Doe' ] = names console.log(lastName) // <- 'Doe'
在ES5中，你需要借助第三個變量，才能完成兩個變量值的交換，如下：
var left = 5, right = 7; var aux = left left = right right = aux
使用解構(gòu)，一切就簡單多了：
var left = 5, right = 7; [left, right] = [right, left]
我們再看看函數(shù)解構(gòu)。
函數(shù)默認(rèn)參數(shù)
在ES6中，我們可以給函數(shù)的參數(shù)添加默認(rèn)值了，下例中我們就給參數(shù) exponent 分配了一個默認(rèn)值：
function powerOf(base, exponent = 2) {
return Math.pow(base, exponent)
}箭頭函數(shù)同樣支持使用默認(rèn)值，需要注意的是，就算只有一個參數(shù)，如果要給參數(shù)添加默認(rèn)值，參數(shù)部分一定要用小括號括起來。
var double = (input = 0) => input * 2
我們可以給任何位置的任何參數(shù)添加默認(rèn)值。
function sumOf(a = 1, b = 2, c = 3) {
return a + b + c
}
console.log(sumOf(undefined, undefined, 4))
// <- 1 + 2 + 4 = 7在JS中，給一個函數(shù)提供一個包含若干屬性的對象字面量做為參數(shù)的情況并不常見，不過你依舊可以按下面方法這樣做：
var defaultOptions = { brand: 'Volkswagen', make: 1999 }
function carFactory(options = defaultOptions) {
console.log(options.brand)
console.log(options.make)
}
carFactory()
// <- 'Volkswagen'
// <- 1999不過這樣做存在一定的問題，當(dāng)你調(diào)用該函數(shù)時，如果傳入的參數(shù)對象只包含一個屬性，另一個屬性的默認(rèn)值會自動失效：
carFactory({ make: 2000 })
// <- undefined
// <- 2000函數(shù)參數(shù)解構(gòu)就可以解決這個問題。
函數(shù)參數(shù)解構(gòu)
通過函數(shù)參數(shù)解構(gòu)，可以解決上面的問題，這里我們?yōu)槊恳粋€屬性都提供了默認(rèn)值，單獨(dú)改變其中一個并不會影響其它的值：
function carFactory({ brand = 'Volkswagen', make = 1999 }) {
console.log(brand)
console.log(make)
}
carFactory({ make: 2000 })
// <- 'Volkswagen'
// <- 2000不過這種情況下，函數(shù)調(diào)用時，如果參數(shù)為空即carFactory()函數(shù)將拋出異常。這種問題可以通過下面的方法來修復(fù)，下述代碼中我們添加了一個空對象作為options的默認(rèn)值，這樣當(dāng)函數(shù)被調(diào)用時，如果參數(shù)為空，會自動以{}作為參數(shù)。
function carFactory({
brand = 'Volkswagen',
make = 1999
} = {}) {
console.log(brand)
console.log(make)
}
carFactory()
// <- 'Volkswagen'
// <- 1999除此之外，使用函數(shù)參數(shù)解構(gòu)，還可以讓你的函數(shù)自行匹配對應(yīng)的參數(shù)，看接下來的例子，你就能明白這一點(diǎn)了，我們定義一個名為car的對象，這個對象擁有很多屬性：owner，brand，make，model，preferences等等。
var car = {
owner: {
id: 'e2c3503a4181968c',
name: 'Donald Draper'
},
brand: 'Peugeot',
make: 2015,
model: '208',
preferences: {
airbags: true,
airconditioning: false,
color: 'red'
}
}解構(gòu)能讓我們的函數(shù)方便的只使用里面的部分?jǐn)?shù)據(jù)，下面代碼中的函數(shù)getCarProductModel說明了具體該如何使用：
var getCarProductModel = ({ brand, make, model }) => ({
sku: brand + ':' + make + ':' + model,
brand,
make,
model
})
getCarProductModel(car)解構(gòu)使用示例
當(dāng)一個函數(shù)的返回值為對象或者數(shù)組時，使用解構(gòu)，我們可以非常簡潔的獲取返回對象中某個屬性的值（返回數(shù)組中某一項的值）。比如說，函數(shù)getCoordinates()返回了一系列的值，但是我們只想用其中的x,y，我們可以這樣寫，解構(gòu)幫助我們避免了很多中間變量的使用，也使得我們代碼的可讀性更高。
function getCoordinates() {
return { x: 10, y: 22, z: -1, type: '3d' }
}
var { x, y } = getCoordinates()通過使用默認(rèn)值，可以減少重復(fù)，比如你想寫一個random函數(shù)，這個函數(shù)將返回一個位于min和max之間的值。我們可以分辨設(shè)置min默認(rèn)值為1，max默認(rèn)值為10，在需要的時候還可以單獨(dú)改變其中的某一個值：
function random({ min = 1, max = 10 } = {}) {
return Math.floor(Math.random() * (max - min)) + min
}
console.log(random())// <- 7
console.log(random({ max: 24 }))// <- 18解構(gòu)還可以配合正則表達(dá)式使用?？聪旅孢@個例子：
function splitDate(date) {
var rdate = /(\d+).(\d+).(\d+)/
return rdate.exec(date)
}
var [ , year, month, day] = splitDate('2015-11-06')不過當(dāng).exec不比配時會返回null,因此我們需要修改上述代碼如下：
var matches = splitDate('2015-11-06')if (matches === null) {
return
}
var [, year, month, day] = matches下面我們繼續(xù)來講講spread和rest操作符。
剩余參數(shù)和拓展符
ES6之前，對于不確定數(shù)量參數(shù)的函數(shù)。你需要使用偽數(shù)組arguments，它擁有length屬性，卻又不具備很多一般數(shù)組有的特性。需要通過Array#slice.call轉(zhuǎn)換arguments對象真數(shù)組后才能進(jìn)行下一步的操作：
function join() {
var list = Array.prototype.slice.call(arguments)
return list.join(', ')
}
join('first', 'second', 'third')// <- 'first, second, third'對于這種情況，ES6提供了一種更好的解決方案：rest。
剩余參數(shù)rest
使用rest, 你只需要在任意JavaScript函數(shù)的最后一個參數(shù)前添加三個點(diǎn)...即可。當(dāng)rest參數(shù)是函數(shù)的唯一參數(shù)時，它就代表了傳遞給這個函數(shù)的所有參數(shù)。它起到和前面說的.slice一樣的作用，把參數(shù)轉(zhuǎn)換為了數(shù)組，不需要你再對arguments進(jìn)行額外的轉(zhuǎn)換了。
function join(...list) {
return list.join(', ')
}
join('first', 'second', 'third')// <- 'first, second, third'rest參數(shù)之前的命名參數(shù)不會被包含在rest中，
function join(separator, ...list) {
return list.join(separator)
}
join('; ', 'first', 'second', 'third')// <- 'first; second; third'在箭頭函數(shù)中使用rest參數(shù)時，即使只有這一個參數(shù)，也需要使用圓括號把它圍起來，不然就會報錯SyntaxError，使用示例如下：
var sumAll = (...numbers) => numbers.reduce( (total, next) => total + next ) console.log(sumAll(1, 2, 5))// <- 8
上述代碼的ES5實現(xiàn)如下：
// ES5的寫法
function sumAll() {
var numbers = Array.prototype.slice.call(arguments)
return numbers.reduce(function (total, next) {
return total + next
})
}
console.log(sumAll(1, 2, 5))// <- 8拓展運(yùn)算符
拓展運(yùn)算符可以把任意可枚舉對象轉(zhuǎn)換為數(shù)組，使用拓展運(yùn)算符可以高效處理目標(biāo)對象，在拓展目前前添加...就可以使用拓展運(yùn)算符了。下例中...arguments就把函數(shù)的參數(shù)轉(zhuǎn)換為了數(shù)組字面量。
function cast() {
return [...arguments]
}
cast('a', 'b', 'c')// <- ['a', 'b', 'c']使用拓展運(yùn)算符，我們也可以把字符串轉(zhuǎn)換為由每一個字母組成的數(shù)組：
[...'show me']// <- ['s', 'h', 'o', 'w', ' ', 'm', 'e']
使用拓展運(yùn)算符，還可以拼合數(shù)組:
function cast() {
return ['left', ...arguments, 'right']
}
cast('a', 'b', 'c')// <- ['left', 'a', 'b', 'c', 'right']var all = [1, ...[2, 3], 4, ...[5], 6, 7] console.log(all)// <- [1, 2, 3, 4, 5, 6, 7]
這里我還想再強(qiáng)調(diào)一下，拓展運(yùn)算符不僅僅適用于數(shù)組和arguments對象，對任意可迭代的對象都可以使用。迭代也是ES6新提出的一個概念，在[ Iteration and Flow Control]()這一章，我們將詳細(xì)敘述迭代。
Shifting和Spreading
當(dāng)你想要抽出一個數(shù)組的前一個或者兩個元素時，常用的解決方案是使用.shift.盡管是函數(shù)式的，下述代碼在第一次看到的時候卻不好理解，我們使用了兩次.slice從list中抽離出兩個不同的元素。
var list = ['a', 'b', 'c', 'd', 'e'] var first = list.shift() var second = list.shift() console.log(first)// <- 'a'
在ES6中，結(jié)合使用拓展和解構(gòu)，可以讓代碼的可讀性更好：
var [first, second, ...other] = ['a', 'b', 'c', 'd', 'e'] console.log(other)// <- ['c', 'd', 'e']
除了對數(shù)組進(jìn)行拓展，你同樣可以對函數(shù)參數(shù)使用拓展，下例展示了如何添加任意數(shù)量的參數(shù)到multiply函數(shù)中。
function multiply(left, right) {
return left * right
}
var result = multiply(...[2, 3])
console.log(result)// <- 6向在數(shù)組中一樣，函數(shù)參數(shù)中的拓展運(yùn)算符同樣可以結(jié)合常規(guī)參數(shù)一起使用。下例中，print函數(shù)結(jié)合使用了rest,普通參數(shù)，和拓展運(yùn)算符：
function print(...list) {
console.log(list)
}
print(1, ...[2, 3], 4, ...[5])// <- [1, 2, 3, 4, 5]下表總結(jié)了，拓展運(yùn)算符的常見使用方法：
| 使用示例 | ES5 | ES6 |
|---|---|---|
| Concatenation | [1, 2].concat(more) | [1, 2, ...more] |
| Push an array onto list | list.push.apply(list, items) | list.push(...items) |
| Destructuring | a = list[0], other = list.slice(1) | <span class="Apple-tab-span" style="white-space: pre;"> </span>[a, ...other] = list |
new and apply | new (Date.bind.apply(Date, [null,2015,31,8])) | new Date(...[2015,31,8]) |
模板字符串
模板字符串是對常規(guī)JavaScript字符串的重大改進(jìn)，不同于在普通字符串中使用單引號或者雙引號，模板字符串的聲明需要使用反撇號，如下所示：
var text = `This is my first template literal`
因為使用的是反撇號，你可以在模板字符串中隨意使用單雙引號了，使用時不再需要考慮轉(zhuǎn)義，如下：
var text = `I'm "amazed" at these opportunities!`
模板字符串具有很多強(qiáng)大的功能，可在其中插入JavaScript表達(dá)式就是其一。
在字符串中插值
通過模板字符串，你可以在模板中插入任何JavaScript表達(dá)式了。當(dāng)解析到表達(dá)式時，表達(dá)式會被執(zhí)行，該處將渲染表達(dá)式的值，下例中，我們在字符串中插入了變量name：
var name = 'Shannon'
var text = `Hello, ${ name }!`
console.log(text)// <- 'Hello, Shannon!'模板字符串是支持任何表達(dá)式的。使用模板字符串，代碼將更容易維護(hù)，你無須再手動連接字符串和JavaScript表達(dá)式了。
看下面插入日期的例子，是不是又直觀又方便：
`The time and date is ${ new Date().toLocaleString() }.`// <- 'the time and date is 8/26/2015, 3:15:20 PM'表達(dá)式中還可以包含數(shù)學(xué)運(yùn)算符：
`The result of 2+3 equals ${ 2 + 3 }`// <- 'The result of 2+3 equals 5'鑒于模板字符串本身也是JavaScript表達(dá)式，我們在模板字符串中還可以嵌套模板字符串;
`This template literal ${ `is ${ 'nested' }` }!`// <- 'This template literal is nested!'模板字符串的另外一個優(yōu)點(diǎn)是支持多行字符串;
多行文本模板
在ES6之前，如果你想表現(xiàn)多行字符串，你需要使用轉(zhuǎn)義，數(shù)組拼合，甚至使用使用注釋符做復(fù)雜的hacks.如下所示：
var escaped ='The first line\n\ A second line\n\ Then a third line' var concatenated ='The first line\n' ` 'A second line\n' `'Then a third line' var joined = ['The first line','A second line','Then a third line'].join('\n')
應(yīng)用ES6，這種處理就簡單多了，模板字符串默認(rèn)支持多行：
var multiline =`The first line A second line Then a third line`
當(dāng)你需要返回的字符串基于html和數(shù)據(jù)生成，使用模板字符串是很簡潔高效的，如下所示：
var book = {
title: 'Modular ES6',
excerpt: 'Here goes some properly sanitized HTML',
tags: ['es6', 'template-literals', 'es6-in-depth']
}
var html = `<article>
<header>
<h1>${ book.title }</h1>
</header>
<section>${ book.excerpt }</section>
<footer>
<ul> ${
book.tags
.map(tag => `<li>${ tag }</li>`)
.join('\n ')
}
</ul>
</footer>
</article>`上述代碼將得到下面這樣的結(jié)果?？崭竦靡员Ａ?，多個li也按我們的預(yù)期被合適的渲染：
<article>
<header>
<h1>Modular ES6</h1>
</header>
<section>Here goes some properly sanitized HTML</section>
<footer>
<ul>
<li>es6</li>
<li>template-literals</li>
<li>es6-in-depth</li>
</ul>
</footer>
</article>不過有時候我們并不希望空格被保留，下例中我們在函數(shù)中使用包含縮進(jìn)的模板字符串，我們希望結(jié)果沒有縮進(jìn)，但是實際的結(jié)果卻有四格的縮進(jìn)。
function getParagraph() {
return `
Dear Rod,
This is a template literal string that's indented
four spaces. However, you may have expected for it
to be not indented at all.
Nico
`}我們可以用下面這個功能函數(shù)對生成的字符串進(jìn)行處理已得到我們想要的結(jié)果：
function unindent(text) {
return text
.split('\n')
.map(line => line.slice(4))
.join('\n')
.trim()
}不過，使用被稱為標(biāo)記模板的模板字符串新特性處理這種情況可能會更好。
標(biāo)記模板
默認(rèn)情況下，JavaScript會把\解析為轉(zhuǎn)義符號，對瀏覽器來說，以\開頭的字符一般具有特殊的含義。比如說\n意味著新行，\u00f1表示?等等。如果你不想瀏覽器執(zhí)行這種特殊解析，你也可以使用String.raw來標(biāo)記模板。下面的代碼就是這樣做的，這里我們使用了String.row來處理模板字符串，相應(yīng)的這里面的\n沒有被解析為新行。
var text = String.raw`"\n" is taken literally. It'll be escaped instead of interpreted.` console.log(text) // "\n" is taken literally. // It'll be escaped instead of interpreted.
我們添加在模板字符串之前的String.raw前綴，這就是標(biāo)記模板，這樣的模板字符串在被渲染前被該標(biāo)記代表的函數(shù)預(yù)處理。
一個典型的標(biāo)記模板字符串如下：
tag`Hello, ${ name }. I am ${ emotion } to meet you!`實際上，上面標(biāo)記模板可以用以下函數(shù)形式表示：
tag( ['Hello, ', '. I am ', ' to meet you!'], 'Maurice', 'thrilled' )
我們還是用代碼來說明這個概念，下述代碼中，我們先定義一個名為tag函數(shù)：
function tag(parts, ...values) {
return parts.reduce(
(all, part, index) => all + values[index - 1] + part
)
}然后我們調(diào)用使用使用標(biāo)記模板，不過此時的結(jié)果和不使用標(biāo)記模板是一樣的，這是因為我們定義的tag函數(shù)實際上并未對字符串進(jìn)行額外的處理。
var name = 'Maurice'
var emotion = 'thrilled'
var text = tag`Hello, ${ name }. I am ${ emotion } to meet you!`
console.log(text)// <- 'Hello Maurice, I am thrilled to meet you!'我們看一個進(jìn)行額外處理的例子，比如轉(zhuǎn)換所有用戶輸入的值為大寫（假設(shè)用戶只會輸入英語），這里我們定義標(biāo)記函數(shù)upper來做這件事：
function upper(parts, ...values) {
return parts.reduce((all, part, index) =>
all + values[index - 1].toUpperCase() + part
)
}
var name = 'Maurice'
var emotion = 'thrilled'
upper`Hello, ${ name }. I am ${ emotion } to meet you!`
// <- 'Hello MAURICE, I am THRILLED to meet you!'既然可以轉(zhuǎn)換輸入為大寫，那我們再進(jìn)一步想想，如果提供合適的標(biāo)記模板函數(shù)，使用標(biāo)記模板，我們還可以對模板中的表達(dá)式進(jìn)行各種過濾處理，比如有這么一個場景，假設(shè)表達(dá)式的值都來自用戶輸入，假設(shè)有一個名為sanitize的庫可用于去除用戶輸入中的html標(biāo)簽，那通過使用標(biāo)記模板，就可以有效的防止XSS攻擊了，使用方法如下。
function sanitized(parts, ...values) {
return parts.reduce((all, part, index) =>
all + sanitize(values[index - 1]) + part
)
}
var comment = 'Evil comment<iframe src="http://evil.corp">
</iframe>'
var html = sanitized`<div>${ comment }</div>`console.log(html)
// <- '<div>Evil comment</div>'ES6中的另外一個大的改變是提供了新的變量聲明方式：let和const聲明，下面我們一起來學(xué)習(xí)。
let & const 聲明
可能很早之前你就聽說過 let 了，它用起來像 var 但是，卻有不同的作用域規(guī)則。
JavaScript的作用域有一套復(fù)雜的規(guī)則，變量提升的存在常常讓新手忐忑不安。變量提升，意味著無論你在那里聲明的變量，在瀏覽器解析時，實際上都被提升到了當(dāng)前作用域的頂部被聲明?？聪旅娴倪@個例子：
function isItTwo(value) {
if (value === 2) {
var two = true
} return two
}
isItTwo(2)// <- true
isItTwo('two')// <- undefined盡管two是在代碼分支中被聲明，之后被外部分支引用，上述的JS代碼還是可以工作的。var 聲明的變量two實際是在isItTwo頂部被聲明的。由于聲明提升的存在，上述代碼其實和下面代碼的效果是一樣的
function isItTwo(value) {
var two if (value === 2) {
two = true
} return two
}帶來了靈活性的同事，變量提升也帶來了更大的迷惑性，還好ES6 為我們提供了塊作用域。
塊作用域和let 聲明
相比函數(shù)作用域，塊作用域允許我們通過if,for,while聲明創(chuàng)建新作用域，甚至任意創(chuàng)建{}塊也能創(chuàng)建新的作用域：
{{{{{ var deep = 'This is available from outer scope.'; }}}}}
console.log(deep)
// <- 'This is available from outer scope.'由于這里使用的是var，考慮到變量提升的存在，我們在外部依舊可以讀取到深層中的deep變量，這里并不會報錯。不過在以下情況下，我們可能希望這里會報錯：
訪問內(nèi)部變量會打破我們代碼中的某種封裝原則；
父塊中已有有一個一個同名變量，但是內(nèi)部也需要用同名變量；
使用let就可以解決這個問題，let 創(chuàng)建的變量在塊作用域內(nèi)有效，在ES6提出let以前，想要創(chuàng)建深層作用域的唯一辦法就是再新建一個函數(shù)。使用let，你只需添加另外一對{}：
let topmost = {}
{
let inner = {}
{
let innermost = {}
}
// attempts to access innermost here would throw
}
// attempts to access inner here would throw
// attempts to access innermost here would throw在for循環(huán)中使用let是一個很好的實踐，這樣定義的變量只會在當(dāng)前塊作用域內(nèi)生效。
for (let i = 0; i < 2; i++) {
console.log(i) // <- 0 // <- 1
}
console.log(i)// <- i is not defined考慮到let聲明的變量在每一次循環(huán)的過程中都重復(fù)聲明，這在處理異步函數(shù)時就很有效，不會發(fā)生使用var時產(chǎn)生的詭異的結(jié)果，我們看一個具體的例子。
我們先看看 var 聲明的變量是怎么工作的，下述代碼中 i變量 被綁定在 printNumber 函數(shù)作用域中，當(dāng)每個回調(diào)函數(shù)被調(diào)用時，它的值會逐步升到10，但是當(dāng)每個回調(diào)函數(shù)運(yùn)行時（每100us）,此時的i的值已經(jīng)是10了，因此每次打印的結(jié)果都是10.
function printNumbers() {
for (var i = 0; i < 10; i++) {
setTimeout(function () {
console.log(i)
}, i * 100)
}
}
printNumbers()使用let,則會把i綁定到每一個塊作用域中。每一次循環(huán) i 的值還是在增加，但是每次其實都是創(chuàng)建了一個新的 i ，不同的 i 之間不會相互影響 ，因此打印出的就是預(yù)想的0到9了。
function printNumbers() {
for (let i = 0; i < 10; i++) {
setTimeout(function () {
console.log(i)
}, i * 100)
}
}
printNumbers()為了細(xì)致的講述let的工作原理， 我們還需要弄懂一個名為 Temporal Dead Zone 的概念。
Temporal Dead Zone
簡言之，如果你的代碼類似下面這樣，就會報錯。即在某個作用域中，在let聲明之前調(diào)用了let聲明的變量，導(dǎo)致的問題就是由于，Temporal Dead Zone（TDZ）的存在。
{
console.log(name)
// <- ReferenceError: name is not defined
let name = 'Stephen Hawking'
}如果定義的是一個函數(shù)，函數(shù)中引用了name變量則是可以的，但是這個函數(shù)并未在聲明前執(zhí)行則不會報錯。如果let聲明之前就調(diào)用了該函數(shù)，同樣會導(dǎo)致TDZ。
// 不會報錯
function readName() {
return name
}
let name = 'Stephen Hawking'
console.log(readName())
// <- 'Stephen Hawking'// 會報錯
function readName() {
return name
}
console.log(readName())
// ReferenceError: name is not defined
let name = 'Stephen Hawking'即使像下面這樣let定義的變量沒有被賦值，下面的代碼也會報錯，原因依舊是它試圖在聲明前訪問一個被let定義的變量
function readName() {
return name
}
console.log(readName())// ReferenceError: name is not definedlet name下面的代碼則是可行的：
function readName() {
return name
}
let nameconsole.log(readName())// <- undefinedTDZ的存在使得程序更容易報錯，由于聲明提升和不好的編碼習(xí)慣常常會存在這樣的問題。在ES6中則可以比較好的避免了這種問題了，需要注意的是let聲明的變量同樣存在聲明提升。這意味著，變量會在我們進(jìn)入塊作用域時就會創(chuàng)建，TDZ也是在這時候創(chuàng)建的，它保證該變量不許被訪問，只有在代碼運(yùn)行到let聲明所在位置時，這時候TDZ才會消失，訪問限制才會取消，變量才可以被訪問。
Const 聲明
const聲明也具有類似let的塊作用域，它同樣具有TDZ機(jī)制。實際上，TDZ機(jī)制是因為const才被創(chuàng)建，隨后才被應(yīng)用到let聲明中。const需要TDZ的原因是為了防止由于變量提升，在程序解析到const語句之前，對const聲明的變量進(jìn)行了賦值操作，這樣是有問題的。
下面的代碼表明，const具有和let一致的塊作用域：
const pi = 3.1415{
const pi = 6 console.log(pi) // <- 6
}
console.log(pi)// <- 3.1415下面我們說說const和let的主要區(qū)別，首先const聲明的變量在聲明時必須賦值,否則會報錯：
const pi = 3.1415 const e // SyntaxError, missing initializer
除了必須初始化，被const聲明的變量不能再被賦予別的值。在嚴(yán)格模式下，試圖改變const聲明的變量會直接報錯，在非嚴(yán)格模式下，改變被靜默被忽略。
const people = ['Tesla', 'Musk'] people = [] console.log(people)// <- ['Tesla', 'Musk']
請注意，const聲明的變量并非意味著，其對應(yīng)的值是不可變的。真正不能變的是對該值的引用，下面我們具體說明這一點(diǎn)。
通過const聲明的變量值并非不可改變
使用const只是意味著，變量將始終指向相同的對象或初始的值。這種引用是不可變的。但是值并非不可變。
下面的例子說明，雖然people的指向不可變，但是數(shù)組本身是可以被修改的。
const people = ['Tesla', 'Musk'] people.push('Berners-Lee') console.log(people)// <- ['Tesla', 'Musk', 'Berners-Lee']
const只是阻止變量引用另外一個值，下例中，盡管我們使用const聲明了people,然后把它賦值給了humans,我們還是可以改變humans的指向，因為humans不是由const聲明的，其引用可隨意改變。people 是由 const 聲明的，則不可改變。
const people = ['Tesla', 'Musk'] var humans = people humans = 'evil' console.log(humans)// <- 'evil'
如果我們的目的是讓值不可修改，我們需要借助函數(shù)的幫助，比如使用Object.freeze：
const frozen = Object.freeze( ['Ice', 'Icicle', 'Ice cube'] ) frozen.push('Water') // Uncaught TypeError: Can't add property 3 // object is not extensible
下面我們詳細(xì)討論一下const和let的優(yōu)點(diǎn)
const和let的優(yōu)點(diǎn)
新功能并不應(yīng)該因為是新功能而被使用，ES6語法被使用的前提是它可以顯著的提升我們代碼的可讀寫和可維護(hù)性。let聲明在大多數(shù)情況下，可以替換var以避免預(yù)期之外的問題。使用let你可以把聲明在塊的頂部進(jìn)行而非函數(shù)的頂部進(jìn)行。
有時，我們希望有些變量的引用不可變，這時候使用const就能防止很多問題的發(fā)生。下述代碼中 在checklist函數(shù)外給items變量傳遞引用時就非常容易出錯，它返回的todo API和items有了交互。當(dāng)items變量被改為指向另外一個列表時，我們的代碼就出問題了。todo API 用的還是items之前的值，items本身的指代則已經(jīng)改變。
var items = ['a', 'b', 'c']
var todo = checklist(items)
todo.check()
console.log(items)
// <- ['b', 'c']
items = ['d', 'e']
todo.check()
console.log(items)
// <- ['d', 'e'], would be ['c'] if items had been constant
function checklist(items) {
return {
check: () => items.shift()
}
}這類問題很難debug，找到問題原因就會花費(fèi)你很長一段時間。使用const運(yùn)行時就會報錯，可以幫助你可以避免這種問題。
如果我們默認(rèn)只使用cosnt和let聲明變量，所有的變量都會有一樣的作用域規(guī)則，這讓代碼更易理解，由于const造成的影響最小，它還曾被提議作為默認(rèn)的變量聲明。
總的來說，const不允許重新指定值，使用的是塊作用域，存在TDZ。let則允許重新指定值，其它方面和const類似，而var聲明使用函數(shù)作用域，可以重新指定值，可以在未聲明前調(diào)用，考慮到這些，推薦盡量不要使用var聲明了。
【相關(guān)推薦：javascript視頻教程、編程視頻】
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Outils d'IA chauds
Undress AI Tool
Images de déshabillage gratuites
Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes
AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.
Clothoff.io
Dissolvant de vêtements AI
Video Face Swap
échangez les visages dans n'importe quelle vidéo sans effort grace à notre outil d'échange de visage AI entièrement gratuit?!
Article chaud
Outils chauds
Bloc-notes++7.3.1
éditeur de code facile à utiliser et gratuit
SublimeText3 version chinoise
Version chinoise, très simple à utiliser
Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP
Dreamweaver CS6
Outils de développement Web visuel
SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)
Comment inverser un tableau dans ES6
Oct 26, 2022 pm 06:19 PM
Dans ES6, vous pouvez utiliser la méthode reverse() de l'objet tableau pour inverser le tableau. Cette méthode est utilisée pour inverser l'ordre des éléments du tableau, en pla?ant le dernier élément en premier et le premier élément en dernier. .inverse()". La méthode reverse() modifiera le tableau d'origine. Si vous ne souhaitez pas le modifier, vous devez l'utiliser avec l'opérateur d'expansion "...", et la syntaxe est "[...array].reverse(). ".
L'async est-il pour es6 ou es7 ?
Jan 29, 2023 pm 05:36 PM
async est es7. async et wait sont de nouveaux ajouts à ES7 et sont des solutions pour les opérations asynchrones?; async/await peut être considéré comme un sucre syntaxique pour les modules co et les fonctions de générateur, résolvant le code asynchrone js avec une sémantique plus claire. Comme son nom l'indique, async signifie ? asynchrone ?. Async est utilisé pour déclarer qu'une fonction est asynchrone ; il existe une règle stricte entre async et wait. Les deux sont inséparables l'un de l'autre et wait ne peut être écrit que dans des fonctions asynchrones.
Pourquoi le mini-programme doit-il convertir es6 en es5??
Nov 21, 2022 pm 06:15 PM
Pour la compatibilité du navigateur. En tant que nouvelle spécification pour JS, ES6 ajoute de nombreuses nouvelles syntaxes et API. Cependant, les navigateurs modernes ne prennent pas en charge les nouvelles fonctionnalités d'ES6, le code ES6 doit donc être converti en code ES5. Dans les outils de développement Web WeChat, babel est utilisé par défaut pour convertir le code de syntaxe ES6 du développeur en code ES5 bien pris en charge par les trois terminaux, aidant les développeurs à résoudre les problèmes de développement causés par différents environnements uniquement dans le projet. Il suffit de configurer et de vérifier le ; Option "ES6 à ES5".
Comment trouver différents éléments dans deux tableaux dans Es6
Nov 01, 2022 pm 06:07 PM
étapes?: 1. Convertissez respectivement les deux tableaux en types d'ensemble, avec la syntaxe "newA=new Set(a); newB=new Set(b);" 2. Utilisez has() et filter() pour trouver l'ensemble de différences. , avec la syntaxe " new Set([...newA].filter(x =>!newB.has(x)))", les éléments de l'ensemble de différences seront inclus dans une collection d'ensembles et renvoyés 3. Utilisez Array. from pour convertir l'ensemble en tableau Tapez, syntaxe "Array.from(collection)".
Comment implémenter la déduplication de tableau dans es5 et es6
Jan 16, 2023 pm 05:09 PM
Dans es5, vous pouvez utiliser l'instruction for et la fonction indexOf() pour réaliser la déduplication de tableau. La syntaxe "for(i=0;i<array length;i++){a=newArr.indexOf(arr[i]);if( a== -1){...}}". Dans es6, vous pouvez utiliser l'opérateur spread, Array.from() et Set pour supprimer la duplication?; vous devez d'abord convertir le tableau en un objet Set pour supprimer la duplication, puis utiliser l'opérateur spread ou la fonction Array.from(). pour reconvertir l'objet Set en un groupe Just.
Que signifie la zone morte temporaire es6 ?
Jan 03, 2023 pm 03:56 PM
Dans es6, la zone morte temporaire est une erreur de syntaxe, qui fait référence aux commandes let et const qui font que le bloc forme une portée fermée. Dans un bloc de code, avant qu'une variable ne soit déclarée à l'aide de la commande let/const, la variable est indisponible et appartient à la ? zone morte ? de la variable avant que la variable ne soit déclarée ; c'est ce qu'on appelle syntaxiquement une ? zone morte temporaire ?. ES6 stipule que la promotion des variables ne se produit pas dans les zones mortes temporaires et dans les instructions let et const, principalement pour réduire les erreurs d'exécution et empêcher l'utilisation de la variable avant qu'elle ne soit déclarée, ce qui peut entra?ner un comportement inattendu.
Est-ce qu'il faut une syntaxe es6??
Oct 21, 2022 pm 04:09 PM
Non, require est la syntaxe modulaire de la spécification CommonJS et la syntaxe modulaire de la spécification es6 est import ; require est chargé au moment de l'exécution et import est chargé au moment de la compilation?; require peut être écrit n'importe où dans le code, import ne peut être écrit qu'en haut du fichier et ne peut pas être utilisé dans les instructions conditionnelles ou les attributs de module de fonction sont introduits uniquement?; lorsque require est exécuté, les performances sont donc relativement faibles. Les propriétés du module introduites lors de la compilation de l'importation ont des performances légèrement supérieures.
Comment déterminer le nombre d'éléments dans un tableau dans es6
Jan 18, 2023 pm 07:22 PM
Dans es6, vous pouvez utiliser l'attribut length de l'objet tableau pour déterminer le nombre d'éléments dans le tableau, c'est-à-dire pour obtenir le nombre d'éléments dans le tableau, cet attribut peut renvoyer le nombre d'éléments dans le tableau ; utilisez l'instruction "array.length". Renvoie une valeur représentant le nombre d'éléments de l'objet tableau, c'est-à-dire la valeur de longueur.
