原文：http://jsrun.pro/tutorial/FZKKp
Node 是 JavaScript 的服务器运行环境（runtime）
1- ES-Checker
2- Babel
3 ES6 块级作用域
4 “模式匹配”
5 解构赋值
6- 字符串的扩展
7- 正则的扩展
8- 数值的扩展
9- 数组的扩展
10-函数扩展
11-箭头函数
12- 对象的扩展
1- let命令:只在let命令所在的代码块内有效- 块作用域
let实际上为 JavaScript 新增了块级作用域。
for (let i = 0; i < 10; i++) {}
2- ES6 引入了块级作用域，明确允许在块级作用域之中声明函数。（非必须）
3- global 对象
4- 变量的解构赋值
4-1 数组的解构赋值
let [x, y] = [1, 2, 3];
4-2 对象的解构赋值 - 对象的扩展
let { foo, bar } = { foo: "aaa", bar: "bbb" };
4-3 字符串的解构赋值
const [a, b, c, d, e] = 'hello’;
4-4 函数参数的解构赋值
5-结构赋值的用途
5-1 从函数返回多个值
5-2 函数参数的定义
5-3 提取JSON数据 - Importent
5-4 函数参数的默认值
5-5 遍历Map结构
for (let [key, value] of map) {
console.log(key + " is " + value);
}
5-6 输入模块的指定方法
const { SourceMapConsumer, SourceNode } = require("source-map”);
6-1字符串拓展
- includes()
- startsWith()
- endsWith()
- repeat()
- padStart() - 字符串补全长
padStart的常见用途是为数值补全指定位数
'1'.padStart(10, '0') // "0000000001" - padEnd()- 字符串补全长度
6-2 模版字符串
7-正则表达式
7-1 String.prototype.* : match()、replace()、search()和split()
8-数值拓展
8-1 Number.parseInt(), Number.parseFloat()
8-2 Number.isInteger()
8-3 Number.MAX_SAFE_INTEGER；Number.MIN_SAFE_INTEGER
9-数组的扩展
9-1 Array.from() : 只要是部署了Iterator接口的数据结构，Array.from都能将其转为数组。
Array.from(arrayLike, x => x * x);
// 等同于
Array.from(arrayLike).map(x => x * x);
Array.from([1, 2, 3], (x) => x * x)
// [1, 4, 9]
9-2 Array.of():Array.of方法用于将一组值，转换为数组
9-3 copyWithin()指定位置的成员复制到其他位置
[1, 2, 3, 4, 5].copyWithin(0, 3)
// [4, 5, 3, 4, 5]
9-4 find()和findIndex()
[1, 4, -5, 10].find((n) => n < 0)
// -5
9-5 fill() fill方法使用给定值，填充一个数组
new Array(3).fill(7)
// [7, 7, 7]
9-6 entries()，keys()和values() 用于遍历数组。它们都返回一个遍历器对象
唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。
for (let index of ['a', 'b'].keys()) {
console.log(index);
}
// 0
// 1
for (let elem of ['a', 'b'].values()) {
console.log(elem);
}
// 'a'
// 'b'
for (let [index, elem] of ['a', 'b'].entries()) {
console.log(index, elem);
}
// 0 "a"
// 1 “b”
9-7 includes() 某个数组是否包含给定的值 = indexOf使用方法
Array.prototype.includes
[1, 2, 3].includes(2); // true
10函数扩展
10-1 参数默认值:允许为函数的参数设置默认值，即直接写在参数定义的后面
function log(x, y = 'World') {
console.log(x, y);
}
log('Hello') // Hello World
log('Hello', 'China') // Hello China
function Point(x = 0, y = 0) {
this.x = x;
this.y = y;
}
var p = new Point();
p // { x: 0, y: 0 }
10-2 参数默认值可以与解构赋值的默认值，结合起来使用。
function foo({x, y = 5}) {
console.log(x, y);
}
foo({x: 1}) // 1, 5
foo({x: 1, y: 2}) // 1, 2
10-3 作用域
10-4 利用参数默认值，可以指定某一个参数不得省略，如果省略就抛出一个错误。
function throwIfMissing() {
throw new Error('Missing parameter');
}
function foo(mustBeProvided = throwIfMissing()) {
return mustBeProvided;
}
foo()
// Error: Missing parameter
10-5 rest参数:形式为“...变量名”
function add(...values) {
let sum = 0;
for (var val of values) {
sum += val;
}
return sum;
}
add(2, 5, 3) // 10
10-6 扩展运算符: […]rest 参数的逆运算，将一个数组转为用逗号分隔的参数序列。
console.log(...[1, 2, 3])
// 1 2 3
10-7 Map和Set结构，Generator函数
10-7-1 扩展运算符内部调用的是数据结构的Iterator接口，因此只要具有Iterator接口的对象，都可以使用扩展运算符，比如Map结构。
let map = new Map([
[1, 'one'],
[2, 'two'],
[3, 'three'],
]);
let arr = [...map.keys()]; // [1, 2, 3]
11- 箭头函数:（=>）
var f = v => v;
var f = function(v) {
return v;
};
var f = () => 5;
var sum = (num1, num2) => num1 + num2;
- ()中的表示参数
12对象的扩展
12-1 属性简写，方法简写。
var birth = '2000/01/01';
var Person = {
name: '张三',
//等同于birth: birth
birth,
// 等同于hello: function ()...
hello() { console.log('我的名字是', this.name); }
};
4-5 Generator 函数
每一个语言的学习成本都很高，用起来还算容易，把里边的区别理解清楚就需要花费大量的时间和精力，我有一点不理解的是为什么要去关注细微的差别，还是说语言本身造就了细微的差别才是重点，如果是那么如何解决这个问题。
有一些比较奇怪的细微的变化的方法和操作为什么会存在呢，特别细微的差别本来就不容易记住，使用的情况也不是很多，不如舍弃，用了大量的时间来解释这些细微的差别，然而在实际应用的时候却很少用到，大家都在花费甚至浪费时间，不能理解。
一门语言的设计到底是为了更好的使用还是为了给学习制造障碍，这是个值得研究的问题。
