本文档是一份 JavaScript 速查表，你在现代项目中会经常遇到，以及最新的代码示例。
本指南不是为了教你从头开始学习 JavaScript ，而是为了帮助那些可能不熟悉当前代码库（例如 React）所用到 JavaScript 概念的开发人员。
此外，我有时还会提供一些个人的建议，这些建议可能是有争议的，但我也会注意到，当我这么做的时候，这是我个人的建议。
注意： 这里介绍的大多数概念来自于最新的 JavaScript 语言（ ES2015，通常称为 ES6）。你可以在 这里 找到新增的特性，网站做得很棒。
当您努力了解一个新概念时，我建议你在以下资源网站上寻找相关的答案：
在 JavaScript 中，有 3 个关键字可用于声明一个变量，他们之间有些差异。那些是 var ，let 和 const。
使用 const 关键字声明的变量无法重新分配，而 let 和 var 可以。
我建议总是默认使用 const 来声明你的变量，如果你需要改变它，或者稍后需要重新分配，那么实用 let 。
| 作用域 | 可否重新分配 | 可变性 | 暂时性死区 | |
|---|---|---|---|---|
| const | Block | No | Yes | Yes |
| let | Block | Yes | Yes | Yes |
| var | Function | Yes | Yes | No |
const person = "Nick"; person = "John" // 将会引起错误，person 不能重新分配
let person = "Nick"; person = "John"; console.log(person) // "John", 使用 let 允许重新分配
变量的 作用域 大致意思是“在哪里可以访问这个变量”。
var 声明的变量是 函数作用域 ，这意味着当在函数中创建变量时，该函数中的所有内容都可以访问该变量。
此外，函数中创建的 函数作用域 变量无法在此函数外访问。
我建议你把它看作一个 X 作用域 变量，意味着这个变量是 X 的属性。
function myFunction() {
var myVar = "Nick";
console.log(myVar); // "Nick" - 在这个函数中 myVar 可被访问到
}
console.log(myVar); // 抛出错误 ReferenceError, 在函数之外 myVar 则无法访问
继续关注变量的作用域，这里是一个更微妙的例子：
function myFunction() {
var myVar = "Nick";
if (true) {
var myVar = "John";
console.log(myVar); // "John"
// 实际上，myVar是函数作用域，我们只是将之前 myVar 的值 "Nick" 抹去，重新声明为 "John"
}
console.log(myVar); // "John" - 看看 if 语句块中的指令是如何影响这个值的
}
console.log(myVar); // 抛出错误 ReferenceError, 在函数之外 myVar 则无法访问
此外，在执行过程中，var声明的变量被移动到范围的顶部。这就是我们所说的变量声明提升（var hoisting)。
这部分的代码：
console.log(myVar) // undefined -- 不会报错 var myVar = 2;
在执行时，被解析为：
var myVar; console.log(myVar) // undefined -- 不会报错 myVar = 2;
愚人码头注：变量提升和函数声明提升可以查看：JavaScript 中的 Hoisting (变量提升和函数声明提升)
var 和 let 大致相同，但是用 let 声明的变量时有以下几个特性：
我们来看看我们前面的例子，采用块级作用域（ block scoping ）后的效果：
function myFunction() {
let myVar = "Nick";
if (true) {
let myVar = "John";
console.log(myVar); // "John"
// 实际上 myVar 在块级作用域中，（在 if 语句块中）我们只是创建了一个新变量 myVar。
// 此变量在 if 语句块之外不可访问，
// 完全独立于创建的第一个 myVar 变量！
}
console.log(myVar); // "Nick", 可以看到 if 语句块中的指令不会影响这个值
}
console.log(myVar); // 抛出错误 ReferenceError，myVar 无法在函数外部被访问。
现在，我们来看看 let（和 const）变量在被赋值之前不可访问是什么意思：
console.log(myVar) // 抛出一个引用错误 ReferenceError ! let myVar = 2;
与 var 变量不同的是，如果你在 let 或者 const 变量被赋值之前读写，那么将会出现错误。这种现象通常被称为暂存死区（Temporal dead zone）或者 TDZ。
注意： 从技术上讲，let 和 const 变量声明时也存在提升，但并不代表它们的赋值也会被提升。但由于它被设计成了赋值之前无法使用，所以我们直观感觉上它没有被提升，但其实是存在提升的。如果想了解更多细节，请看这篇文章。
此外，您不能重新声明一个 let 变量：
let myVar = 2; let myVar = 3; // 抛出语法错误 SyntaxError
const 声明的变量很像 let ，但它不能被重新赋值。
总结一下 const 变量：
const myVar = "Nick"; myVar = "John" // 抛出一个错误， 不允许重新分配
const myVar = "Nick"; const myVar = "John" // 抛出一个错误， 不允许重新声明
但这里有一个小细节：const 变量并不是不可变，具体来说，如果 const 声明的变量是 object 和 array 类型的值，那它是 可变的 。
对于对象：
const person = {
name: 'Nick'
};
person.name = 'John' // 这是有效的！person 变量并非完全重新分配，只是值被改变
console.log(person.name) // "John"
person = "Sandra" // 抛出一个错误， 因为用 const 声明的变量不能被重新分配
对于数组：
const person = [];
person.push('John'); // 这是有效的！person 变量并非完全重新分配，只是值被改变
console.log(person[0]) // "John"
person = ["Nick"] // 抛出一个错误， 因为用 const 声明的变量不能被重新分配
ES6 JavaScript 更新引入了 箭头函数 ，这是另一种声明和使用函数的方法。以下是他们带来的好处：
function double(x) { return x * 2; } // 传统的方法
console.log(double(2)) // 4
const double = x => x * 2; // 相同的函数写成带有隐式返回的箭头函数 console.log(double(2)) // 4
在箭头函数中， this 意味着封闭执行上下文的 this 值。基本上，使用箭头函数，在函数中调用函数之前，您不需要执行 “that = this” 这样的的技巧。
function myFunc() {
this.myVar = 0;
setTimeout(() => {
this.myVar++;
console.log(this.myVar) // 1
}, 0);
}
箭头函数在许多方面比传统函数更简洁。让我们来看看所有可能的情况：
显式返回 (explicit return) 是指在函数体中明确的使用 return 这个关键字。
function double(x) {
return x * 2; // 这个函数显示返回 x * 2, 并且使用了 *return* 关键字
}
在函数传统的写法中，返回总是显式的。但是如果是使用箭头函数，你可以执行 隐式返回(implicit return)，这表示你不需要使用关键字 return 来返回一个值。
要做隐式回传，代码必须用一行语句写完。
const double = (x) => {
return x * 2; // 这里是显式返回
}
由于这里只有一个返回值，我们可以做一个隐式的返回。
const double = (x) => x * 2;
这样做，我们只需要 移除括号 以及 return 关键字。这就是为什么它会被称为 隐式 返回，return 关键字不在了，但是这个函数确实会返回 x * 2。
注意： 如果你的函数没有回传一个值 (这种作法有 副作用)，那么它将不会做显式或隐式返回。
另外，如果你想隐式地返回一个 对象(object)，你必须用括号包裹，否则它将与块大括号冲突：
const getPerson = () => ({ name: "Nick", age: 24 })
console.log(getPerson()) // { name: "Nick", age: 24 } -- 箭头函数隐式地返回一个对象
如果你的函数只接受一个参数，你可以省略包裹它的括号。如果我们拿上述的 double 代码做为举例：
const double = (x) => x * 2; // 这个箭头函数只接受一个参数
包裹参数的括号是可以被省略：
const double = x => x * 2; // 这个箭头函数只接受一个参数
当没有为箭头函数提供任何参数时，你就必须加上括号，否则将会抛出语法错误。
() => { // 提供括号，一切都能正常运行
const x = 2;
return x;
}
=> { // 没有括号，这不能正常运行！
const x = 2;
return x;
}
要理解箭头函数的精妙之处，你就必须知道 this 在 JavaScript 中是如何运作的。
在一个箭头函数中，this 等同于封闭执行上下文的 this 值。这意味着，一个箭头函数并不会创造一个新的 this，而是从它的外围作用域中抓取的。
如果没有箭头函数，你想在一个函数内部的函数中通过 this 访问变量，你就只能使用 that = this 或者是 self = this 这样的技巧。
举例来说，你在 myFunc 中使用 setTimeout 函数：
function myFunc() {
this.myVar = 0;
var that = this; // that = this 技巧
setTimeout(
function() { // 在这个函数作用域中，一个新的 *this* 被创建
that.myVar++;
console.log(that.myVar) // 1
console.log(this.myVar) // undefined -- 见上诉函数声明
},
0
);
}
但是如果你使用箭头函数，this 是从它的外围作用域中抓取的：
function myFunc() {
this.myVar = 0;
setTimeout(
() => { // this 值来自它的外围作用域, 在这个示例中，也就是 myFunc 函數
this.myVar++;
console.log(this.myVar) // 1
},
0
);
}
从 ES2015 JavaScript 更新之后开始，你可以通过下列的语法为函数的参数设定默认值：
function myFunc(x = 10) {
return x;
}
console.log(myFunc()) // 10 -- 没有提供任何值，所以在 myFunc 中 10 做为默认值分配给 x
console.log(myFunc(5)) // 5 -- 有提供一个参数值，所以在 myFunc 中 x 等于 5
console.log(myFunc(undefined)) // 10 -- 提供 undefined 值，所以默认值被分配给 x
console.log(myFunc(null)) // null -- 提供一个值 (null)，详细资料请见下文
默认参数应用于两种且仅两种情况：
换句话说，如果您传入 null ，则不会应用默认参数。
注意： 默认值分配也可以与解构参数一起使用（参见下一个概念以查看示例）。
解构 (destructuring) 是通过从存储在对象或数组中的数据中提取一些值来创建新变量的简便方法。
举个简单的实例，destructuring 可以被用来解构函数中的参数，或者像是 React 项目中 this.props 这样的用法。
我们考虑一下以下对象的所有属性：
const person = {
firstName: "Nick",
lastName: "Anderson",
age: 35,
sex: "M"
}
不使用解构：
const first = person.firstName; const age = person.age; const city = person.city || "Paris";
使用解构，只需要 1 行代码：
const { firstName: first, age, city = "Paris" } = person; // 就是这么简单！
console.log(age) // 35 -- 一个新变量 age 被创建，并且其值等同于 person.age
console.log(first) // "Nick" -- 一个新变量 first 被创建，并且其值等同于 person.firstName A new variable first is created and is equal to person.firstName
console.log(firstName) // Undefined -- person.firstName 虽然存在，但是新变量名为 first
console.log(city) // "Paris" -- 一个新变量 city 被创建，并且因为 person.city 为 undefined(未定义) ，所以 city 将等同于默认值也就是 "Paris"。
注意： 在 const { age } = person; 中, const 关键字后的括号不是用于声明对象或代码块，而是 解构(structuring) 语法。
解构(structuring) 经常被用来解构函数中的对象参数。
不使用解构：
function joinFirstLastName(person) {
const firstName = person.firstName;
const lastName = person.lastName;
return firstName + '-' + lastName;
}
joinFirstLastName(person); // "Nick-Anderson"
在解构对象参数 person 这个参数时，我们可以得到一个更简洁的函数：
function joinFirstLastName({ firstName, lastName }) { // 通过解构 person 参数，我们分别创建了 firstName 和 lastName 这两个变数
return firstName + '-' + lastName;
}
joinFirstLastName(person); // "Nick-Anderson"
箭头函数中使用解构，使得开发过程更加愉快：
const joinFirstLastName = ({ firstName, lastName }) => firstName + '-' + lastName;
joinFirstLastName(person); // "Nick-Anderson"
我们考虑一下以下数组：
const myArray = ["a", "b", "c"];
不使用解构：
const x = myArray[0]; const y = myArray[1];
使用解构：
const [x, y] = myArray; // 就是这么简单！ console.log(x) // "a" console.log(y) // "b"
map，filter 和 reduce 都是数组提供的方法，它们源自于 函数式编程 。
总结一下：
我建议尽可能地使用它们来遵循函数式编程 (functional programming) 的原则，因为它们是可组合的，简洁的且优雅的。
通过这三种方法，您可以避免在大多数情况下使用 for 和 forEach 。当你试图做一个 for 循环时，尝试用 map，filter 和 reduce 来组合试试。起初你可能很难做到这一点，因为它需要你学习一种新的思维方式，但一旦你得到它，事情会变得更容易。
愚人码头注：JavaScript 函数式编程建议看看以下几篇文章
const numbers = [0, 1, 2, 3, 4, 5, 6]; const doubledNumbers = numbers.map(n => n * 2); // [0, 2, 4, 6, 8, 10, 12] const evenNumbers = numbers.filter(n => n % 2 === 0); // [0, 2, 4, 6] const sum = numbers.reduce((prev, next) => prev + next, 0); // 21
通过组合 map，filter 和 reduce 来计算 10 分以上的学生成绩总和 sum ：
const students = [
{ name: "Nick", grade: 10 },
{ name: "John", grade: 15 },
{ name: "Julia", grade: 19 },
{ name: "Nathalie", grade: 9 },
];
const aboveTenSum = students
.map(student => student.grade) // 我们将学生数组映射到他们成绩的数组中
.filter(grade => grade >= 10) // 我们过滤成绩数组以保持10分以上的元素
.reduce((prev, next) => prev + next, 0); // 我们将合计所有10分以上的成绩
console.log(aboveTenSum) // 44 -- 10 (Nick) + 15 (John) + 19 (Julia), 低于10的 Nathalie 被忽略
让我们考虑一下下列数组：
const numbers = [0, 1, 2, 3, 4, 5, 6];
const doubledNumbers = numbers.map(function(n) {
return n * 2;
});
console.log(doubledNumbers); // [0, 2, 4, 6, 8, 10, 12]
这里发生了什么？我们在 numbers 这个数组中使用 .map 方法，map 将会迭代数组的每个元素，并传递给我们的函数。该函数的目标是生成并返回一个新的值，以便 map 可以替换掉原本的数组。
我们来解释一下这个函数，使之更清楚一点：
const doubleN = function(n) { return n * 2; };
const doubledNumbers = numbers.map(doubleN);
console.log(doubledNumbers); // [0, 2, 4, 6, 8, 10, 12]
numbers.map(doubleN) 将会产生 [doubleN(0), doubleN(1), doubleN(2), doubleN(3), doubleN(4), doubleN(5), doubleN(6)] 而它们分别等同于 [0, 2, 4, 6, 8, 10, 12]。
注意： 如果你不需要返回一个新的数组， 且只想执行一个带有副作用的循环，使用 for / forEach 循环会更为符合你的需求。
const evenNumbers = numbers.filter(function(n) {
return n % 2 === 0; // 如果 "n" 符合条件返回 true , 如果 "n" 不符合条件则 false 。
});
console.log(evenNumbers); // [0, 2, 4, 6]
我们在 numbers 数组中使用 .filter 方法，过滤器遍历数组中的每个元素，并将其传递给我们的函数。函数的目标是返回一个布尔值，它将确定当前值是否被保留。过滤之后返回的数组将只包含保留值。
reduce 方法的目标是将迭代数组中的所有元素，减少 到只留下单一值。如何聚合这些元素取决于你。
const sum = numbers.reduce(
function(acc, n) {
return acc + n;
},
0 // 累加器迭代变量的初始值
);
console.log(sum) //21
就像 .map 和 .filter 方法一样， .reduce 方法被应用在数组上并接收一个函数做为第一个参数。
下面是一些差异：
第一个参数是一个函数，将在每个迭代步骤中被调用。
第二个参数是在第一个迭代步骤（读取下一个用的）的累加器变量的值（此处是 acc）。
作为 .reduce 的第一个参数传递的函数需要两个参数。第一个（此处是 acc）是累加器变量，而第二个参数（n）则是当前元素。
累加器变量的值等于 上一次 迭代步骤中函数的返回值。在迭代过程的第一步，acc 等于你做为 .reduce 时第二个参数所传递的值（愚人码头注：也就是累加器初始值）。
acc = 0 因为我们把 0 做为 reduce 的第二个参数
n = 0 number 数组的第一个元素
函数返回 acc + n –> 0 + 0 –> 0
acc = 0 因为它是上次迭代所返回的值
n = 1 number 数组的第二个元素
函数返回 acc + n –> 0 + 1 –> 1
acc = 1 因为它是上次迭代所返回的值
n = 2 number 数组的第三个元素
函数返回 acc + n –> 1 + 2 –> 3
acc = 3 因为它是上次迭代所返回的值
n = 3 number 数组的第四个元素
函数返回 acc + n –> 3 + 3 –> 6
acc = 15 因为它是上次迭代所返回的值
n = 6 number 数组的最后一个元素
函数返回 acc + n –> 15 + 6 –> 21
因为它是最后一个迭代步骤了， .reduce 将返回 21 。
ES2015 已经引入了展开操作符 ... ，可以将可迭代多个元素（如数组）展开到适合的位置。
const arr1 = ["a", "b", "c"]; const arr2 = [...arr1, "d", "e", "f"]; // ["a", "b", "c", "d", "e", "f"]
function myFunc(x, y, ...params) {
console.log(x);
console.log(y);
console.log(params)
}
myFunc("a", "b", "c", "d", "e", "f")
// "a"
// "b"
// ["c", "d", "e", "f"]
const { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
console.log(x); // 1
console.log(y); // 2
console.log(z); // { a: 3, b: 4 }
const n = { x, y, ...z };
console.log(n); // { x: 1, y: 2, a: 3, b: 4 }
如果我们有以下两个数组:
const arr1 = ["a", "b", "c"]; const arr2 = [arr1, "d", "e", "f"]; // [["a", "b", "c"], "d", "e", "f"]
arr2 的第一个元素是一个数组 ，因为 arr1 是被注入到 arr2 之中的。但我们真正想要得到的 arr2 是一个纯字母的数组。为了做到这点，我们可以将 arr1 展开(spread) 到 arr2。
通过展开操作符：
const arr1 = ["a", "b", "c"]; const arr2 = [...arr1, "d", "e", "f"]; // ["a", "b", "c", "d", "e", "f"]
在函数参数中，我们可以使用 rest 操作符将参数注入到我们可以循环的数组中。这里已经有一个 argument 对象绑定到每个函数上，等同于把数组中的所有参数都传递给函数。
function myFunc() {
for (var i = 0; i < arguments.length; i++) {
console.log(arguments[i]);
}
}
myFunc("Nick", "Anderson", 10, 12, 6);
// "Nick"
// "Anderson"
// 10
// 12
// 6
但是如果说，我们希望创造的是一个包含各科成绩和平均成绩的新学生。将前两个参数提取为两个单独的变量，并把剩下的元素生成一个可迭代的数组是不是更加方便呢？
这正是 rest 操作符允许我们做的事情！
function createStudent(firstName, lastName, ...grades) {
// firstName = "Nick"
// lastName = "Anderson"
// [10, 12, 6] -- "..." 将传递所有剩余参数，并创建一个包含它们的 "grades" 数组变量
const avgGrade = grades.reduce((acc, curr) => acc + curr, 0) / grades.length; // 根据 grade 计算平均成绩
return {
firstName: firstName,
lastName: lastName,
grades: grades,
avgGrade: avgGrade
}
}
const student = createStudent("Nick", "Anderson", 10, 12, 6);
console.log(student);
// {
// firstName: "Nick",
// lastName: "Anderson",
// grades: [10, 12, 6],
// avgGrade: 9.333333333333334
// }
注意： 在这个示例中， createStudent 函数其实并不太好，因为我们并没有去检查 grades.length 是否存在又或者它等于 0 的情况。但是这个例子现在这样写，能够更好的帮助我们理解剩余参数的运作，所以我没有处理上述的这种情况。
对于这一点，我建议你阅读有关 rest 操作符以前的有关迭代和函数参数的相关说明。
const myObj = { x: 1, y: 2, a: 3, b: 4 };
const { x, y, ...z } = myObj; // 这里是对象被解构
console.log(x); // 1
console.log(y); // 2
console.log(z); // { a: 3, b: 4 }
// z是对象解构后的剩余部分：myObj 对象除去 x 和 y 属性后剩余部分被解构
const n = { x, y, ...z };
console.log(n); // { x: 1, y: 2, a: 3, b: 4 }
// 这里 z 对象的属性展开到 n 中
将变量分配给一个对象属性时，如果变量名称和属性名称相同，你可以执行以下操作：
const x = 10;
const myObj = { x };
console.log(myObj.x) // 10
通常（ES2015之前）当你声明一个新的 对象字面量 并且想要使用变量作为对象属性值时，你会写这样类似的代码：
const x = 10;
const y = 20;
const myObj = {
x: x, // 将 x 分配给 myObj.x
y: y // 将 y 变量给 myObj.y
};
console.log(myObj.x) // 10
console.log(myObj.y) // 20
如您所见，这样的作法其实相当重复，因为 myObj 的属性名称与要分配给这些属性的变量名相同。
使用ES2015，当变量名与属性名称相同时，您可以进行以下简写：
const x = 10;
const y = 20;
const myObj = {
x,
y
};
console.log(myObj.x) // 10
console.log(myObj.y) // 20
Promises 是一个可以从异步函数 (参考) 同步返回的对象。
可以使用 Promises 来避免 回调地狱 (callback hell) ，而且它们在现代 JavaScript 项目中越来越频繁地遇到。
const fetchingPosts = new Promise((res, rej) => {
$.get("/posts")
.done(posts => res(posts))
.fail(err => rej(err));
});
fetchingPosts
.then(posts => console.log(posts))
.catch(err => console.log(err));
当你在执行 Ajax 请求 时，响应不是同步的，因为资源请求需要时间。如果你要的资源由于某些原因 (404) 不可用，甚至可能永远都不会请求到。
为了处理这类情况，ES2015 为我们提供了 promises。 Promises 可以有三种不同的状态：
假设我们希望使用 promises 去进行 Ajax 请求以获取 X 资源。
我们首先要创建一个 promise。我们将会使用 jQuery 的 get 方法对 X 资源执行 Ajax 请求。
const xFetcherPromise = new Promise( // 使用 "new" 关键字创建promise，并把它保存至一个变量
function(resolve, reject) { // Promise 构造函数需要一个带有着 resolve 和 reject 这两个参数的函数作为参数
$.get("X") // 执行 Ajax 请求
.done(function(X) { // 一旦请求完成...
resolve(X); // ... 把 X 值做为参数去 resolve promise
})
.fail(function(error) { // 如果请求失败...
reject(error); // ... 把 error 做为参数去 reject promise
});
}
)
如上示例所示，Promise 对象需要一个带有两个参数 ( resolve 和 reject ) 的执行函数。这两个参数会把 pending 状态的 promise 分别进行 fulfilled 和 rejected 的处理。
Promise 在实例创建后处于待处理状态，并且它的执行器函数立即执行。一旦在执行函数中调用了 resolve 或 reject 函数，Promise 将调用相关的处理程序。
为了获得 promise 结果（或错误），我们必须通过执行以下操作来附加处理程序：
xFetcherPromise
.then(function(X) {
console.log(X);
})
.catch(function(err) {
console.log(err)
})
如果 promise 成功，则执行 resolve ，并执行 .then 参数所传递的函数。
如果失败，则执行 reject ，并执行 .catch 参数所传递的函数。
注意： 如果 promise 在相应的处理程序附加时已经 fulfilled 或 rejected，处理程序将被调用，
因此在异步操作完成和其处理程序被附加之间没有竞争条件。 (参考： MDN)（MDN）。
模板字符串是一种单行和多行字符串的 表达式插值 (expression interpolation)。
换句话说，它是一种新的字符串语法，你可以更方便地在 JavaScript 表达式中使用 (例如变量)。
const name = "Nick";
`Hello ${name}, the following expression is equal to four : ${2+2}`;
// Hello Nick, the following expression is equal to four: 4
模板标签是可以作为模板字符串(template literal)的前缀函数。当一个函数被这钟方式调用时，第一个参数是出现在模板插值变量之间的字符串数组，并且随后的参数是插值变量的值。可以使用展开运算符 ... 捕获所有这些参数。 (参考: MDN)。
注意： 名为styled-components的著名库很大程度上依赖于此功能。
以下是他们工作的玩具示例。
function highlight(strings, ...values) {
// 愚人码头注：为了更好的理解函数的参数，我增加了这样两行代码，特殊说明见示例代码下面的说明；
console.log(strings);//(3) ["I like ", " on ", ".", raw: Array(3)]
console.log(values);//(2) ["jam", "toast"]
const interpolation = strings.reduce((prev, current) => {
return prev + current + (values.length ? "<mark>" + values.shift() + "</mark>" : "");
}, "");
return interpolation;
}
const condiment = "jam";
const meal = "toast";
highlight`I like ${condiment} on ${meal}.`;
// "I like <mark>jam</mark> on <mark>toast</mark>."
——-愚人码头注开始——-
标签函数的第一个参数是一个包含了字符串字面值的数组（在本例中分别为”I like “,” on “和”.”）。如果我们这样调用 highlight`I like ${condiment} on ${meal}` (注意最后面没”.”)，那么第一个参数还是一个 3 个元素的数组：[“I like “, ” on “, “”]，特别注意最后一个元素是的空字符串””；
strings 确实是一个数组，但是它还有一个 raw 属性。其属性值 strings.raw 也是一个数组，其元素分别表示 strings 中对应的，经过转义之前在 模板字符串(Template literals) 中由用户输入的字符串。我们来看一个例子：
const myTag = (strs, ...exprs) => {
console.log(strs); //(3) ["x", "\y", "", raw: Array(3)]
console.log(strs.raw); //(3) ["x", "\\y", ""
console.log(exprs); //[1, 2]
};
const obj = { a: 1, b: 2 };
const result = myTag`x${obj.a}\\y${obj.b}`;
上例中 "\y" 未转义之前对应的字符串为 "\\y" ，显然这两个字符串长度是不同的。
String.raw 是ES2015，内置对象 String 的一个静态方法，把它作为Tag，可以做到只替换嵌入表达式而不转义字符。
const raw = String.raw`1\\2\\${1+2}`;
console.log(raw); //1\\2\\3
console.log(raw.length); //7
const x = `1\\2\\${1+2}`;
console.log(x); //1\2\3
console.log(x.length); //5
Template literals遵从字符串的转义规则：
（1）以 \u 开头，后跟4个16进制数字，例如，\u00B1表示±
（2）以 \u 开头，使用大括号括起来的16进制数字，例如，\u{2F804} 表示 你
（3）以 \x 开头，后跟2个16进制数字，例如，\xB1 表示 ±
（4）以 \ 开头，后跟10进制数字，用来表示八进制字面量（注：strict mode下不支持）
解释器遇到 \u 和 \x ，如果发现后面的字符不满足以上条件，就会报语法错。例如，
> latex`\unicode` > Uncaught SyntaxError: Invalid Unicode escape sequence
不再展开，具体参考:Template literals。
在第一个参数后的每一个参数，都是已经求值后的替换表达式。 看下面这个例子：
var a = 5;
var b = 10;
function tag(strings, ...values) {
console.log(values[0]); // 15
console.log(values[1]); // 50
return values[0]+values[1]; //65
}
tag`Hello ${ a + b } world ${ a * b}`;
上例中，剩余的2个参数值分别是 15 和 50;
——-愚人码头注结束——-
一个更有趣的例子：
function comma(strings, ...values) {
return strings.reduce((prev, next) => {
let value = values.shift() || [];
value = value.join(", ");
return prev + next + value;
}, "");
}
const snacks = ['apples', 'bananas', 'cherries'];
comma`I like ${snacks} to snack on.`;
// "I like apples, bananas, cherries to snack on."
ES6模块用于访问模块中显式导出的模块中的变量或函数。
我强烈建议您查看 MDN 上有关 import/export（请参阅下面的扩展阅读资源），它们写的既简洁又完整。
命名导出用于从一个模块导出多个值。
注意： 您命名导出的变量是一等公民(first-class citizens)。
// mathConstants.js
export const pi = 3.14;
export const exp = 2.7;
export const alpha = 0.35;
// -------------
// myFile.js
import { pi, exp } from './mathConstants.js'; // 命名导入 -- 类似于解构语法
console.log(pi) // 3.14
console.log(exp) // 2.7
// -------------
// mySecondFile.js
import * as constants from './mathConstants.js'; // 将所有导出的值注入到 constants 变量中
console.log(constants.pi) // 3.14
console.log(constants.exp) // 2.7
虽然命名导入看起来像是 解构(destructuring)，但它们具有不同的语法，并且不一样。 他们不支持默认值，也不支持深层次的解构。
此外，您可以使用别名，但语法不同于解构中使用的语法：
import { foo as bar } from 'myFile.js'; // foo 被导入并注入到一个新的 bar 变量中
关于默认导出，每个模块只能有一个默认导出。默认导出可以是函数，类，对象或其他任何东西。这个值被认为是“主要”的导出值，因为它将是最简单的导入。 参考： MDN。
// coolNumber.js const ultimateNumber = 42; export default ultimateNumber; // ------------ // myFile.js import number from './coolNumber.js'; // 默认导出，将独立于其名称，自动注入到 number 这个变量; console.log(number) // 42
函数导出：
// sum.js
export default function sum(x, y) {
return x + y;
}
// -------------
// myFile.js
import sum from './sum.js';
const result = sum(1, 2);
console.log(result) // 3
this 操作符的行为与其他语言不同，在大多数情况之下是由函数的调用方式决定。 (参考： MDN)。
this 概念有很多细节，并不是那么容易理解，我强烈建议你深入了解下面的扩展阅读。因此，我会提供我个人对于 this 的一点理解和想法。我是从 Yehuda Katz 写的这篇文章 学到了这个提示。
function myFunc() {
...
}
// 在每个述句后面，你都可以在 myFunc 中找到 this 的值
myFunc.call("myString", "hello") // "myString" -- 首先， .call的参数值被注入到 *this*
// 在非严格模式下（non-strict-mode）
myFunc("hello") // window -- myFunc() 是 myFunc.call(window, "hello") 的语法糖
// 在严格模式下（strict-mode）
myFunc("hello") // undefined -- myFunc() 是 myFunc.call(undefined, "hello") 的语法糖
var person = {
myFunc: function() { ... }
}
person.myFunc.call(person, "test") // person 对象 -- 首先， .call的参数值被注入到 *this*
person.myFunc("test") // person 对象 -- person.myFunc() 是 person.myFunc.call(person, "test") 的语法糖
var myBoundFunc = person.myFunc.bind("hello") // 创造了一个函数，并且把 "hello" 注入到 *this*
person.myFunc("test") // person 对象 -- bind 方法对原有方法并无造成影响
myBoundFunc("test") // "hello" -- myBoundFunc 是把带有 "hello" 的 person.myFunc 绑定到 *this*
JavaScript 是一个基于原型 的语言(然而Java 是基于类别 的语言)。 ES6 引入了 JavaScript 类，它们是用于基于原型的继承的语法糖，而 不是 一种新的基于类继承的模型(参考).
如果您熟悉其他语言的类，那么 类 (class) 这个词的确容易理解出错。 如果真的有此困扰，请避免在这样的认知下思考 JavaScript 类的行为，并将其视为完全不同的新概念。
由于本文档不是从根本上教你 JavaScript 语言，我会相信你知道什么是原型，以及它们的行为。 如果没有，请参阅示例代码下面列出的扩展阅读，以方便你去理解这些概念：
ES6 之前，原型語法:
var Person = function(name, age) {
this.name = name;
this.age = age;
}
Person.prototype.stringSentence = function() {
return "Hello, my name is " + this.name + " and I'm " + this.age;
}
使用 ES6 类(class)* 语法:
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
stringSentence() {
return "Hello, my name is " + this.name + " and I'm " + this.age;
}
}
const myPerson = new Person("Manu", 23);
console.log(myPerson.age) // 23
console.log(myPerson.stringSentence()) // "Hello, my name is Manu and I'm 23
更好的理解原型：
更好的理解类：
extends 关键字用于类声明或类表达式中，以创建一个类，该类是另一个类的子类(参考: MDN)。 子类继承超类的所有属性，另外可以添加新属性或修改继承的属性。
super 关键字用于调用对象的父对象的函数，包括其构造函数。
class Polygon {
constructor(height, width) {
this.name = 'Polygon';
this.height = height;
this.width = width;
}
getHelloPhrase() {
return `Hi, I am a ${this.name}`;
}
}
class Square extends Polygon {
constructor(length) {
// 这里，它调用父类的构造函数的 length,
// 提供给 Polygon 的 width 和 height。
super(length, length);
// 注意: 在派生的类中, 在你可以使用 'this' 之前, 必须先调用 super() 。
// 忽略这个, 这将导致引用错误。
this.name = 'Square';
this.length = length;
}
getCustomHelloPhrase() {
const polygonPhrase = super.getHelloPhrase(); // 通过 super.X() 语法访问父级方法
return `${polygonPhrase} with a length of ${this.length}`;
}
get area() {
return this.height * this.width;
}
}
const mySquare = new Square(10);
console.log(mySquare.area) // 100
console.log(mySquare.getHelloPhrase()) // 'Hi, I am a Square' -- Square 继承自 Polygon 并可以访问其方法
console.log(mySquare.getCustomHelloPhrase()) // 'Hi, I am a Square with a length of 10'
注意 : 如果我们在 Square 类中调用 super() 之前尝试使用 this，将引发一个引用错误：
class Square extends Polygon {
constructor(length) {
this.height; // 引用错误, 必须首先调用 super() !
// 这里，它调用父类的构造函数的 length,
// 提供给 Polygon 的 width 和 height。
super(length, length);
// 注意: 在派生的类中, 在你可以使用 'this' 之前, 必须先调用 super() 。
// 忽略这个, 这将导致引用错误。
this.name = 'Square';
}
}