ECMAScript6(0)：ES6简明参考手册(2)

对于一个简单返回一个值的函数来说，箭头函数显得更加简洁

var squares = arr.map(function (x) { return x * x }); // Function Expression

const arr = [1, 2, 3, 4, 5];

const squares = arr.map(x => x * x); // Arrow Function for terser implementation

建议: 尽可能用箭头函数替换你的函数定义

字符串(Strings)

---

在ES6中, 标准库也在不断的扩充。在这些变化中就有很多方法可以用于字符串，比如.includes()和.repeat()

.includes()

var string = ‘food’;

var substring = ‘foo’;

console.log(string.indexOf(substring) > -1);

检测返回值是否大于-1表示字符串是否存在，我们可以用.includes()替换，它返回一个boolean值。

const string = ‘food’;

const substring = ‘foo’;

console.log(string.includes(substring)); // true

.repeat()

function repeat(string, count) {

var strings = [];

while(strings.length < count) {

strings.push(string);

}

return strings.join(‘’);

}

在ES6中，我们一种更简洁的实现方法：

// String.repeat(numberOfRepetitions)

‘meow’.repeat(3); // ‘meowmeowmeow’

模板字面量(Template Literals)

---

（译注：原文是Template Literals，而非Template Strings)

利用模板字面量，我们可以直接在字符串使用特殊字符而不用转义它们。

var text = “This string contains “double quotes” which are escaped.”;

let text = This string contains "double quotes" which don't need to be escaped anymore.;

模板字面量还支持插值，可以轻松完成连接字符串和值的任务:

var name = ‘Tiger’;

var age = 13;

console.log(‘My cat is named ’ + name + ’ and is ’ + age + ’ years old.’);

const name = ‘Tiger’;

const age = 13;

console.log(My cat is named ${name} and is ${age} years old.);

在ES5中，我们这样操作多行字符串：

var text = (

‘cat\n’ +

‘dog\n’ +

‘nickelodeon’

);

或者

var text = [

‘cat’,

‘dog’,

‘nickelodeon’

].join(‘\n’);

模板字面量可以保留多行字符串，我们无需显式的放置它们：

let text = ( `cat

dog

nickelodeon`

);

模板字面量可以接受表达式, 比如:

let today = new Date();

let text = The time and date is ${today.toLocaleString()};

解构赋值（Destructuring）

---

解构赋值允许我们从数组或对象中提取出值(甚至深度嵌套的值)，并把他们存入变量的简单语法

解构数组（Destructuring Arrays）

var arr = [1, 2, 3, 4];

var a = arr[0];

var b = arr[1];

var c = arr[2];

var d = arr[3];

let [a, b, c, d] = [1, 2, 3, 4];

console.log(a); // 1

console.log(b); // 2

解构对象（Destructuring Objects）

var luke = { occupation: ‘jedi’, father: ‘anakin’ };

var occupation = luke.occupation; // ‘jedi’

var father = luke.father; // ‘anakin’

let luke = { occupation: ‘jedi’, father: ‘anakin’ };

let {occupation, father} = luke;

console.log(occupation); // ‘jedi’

console.log(father); // ‘anakin’

模块（Modules）

---

ES6之前，我们只用如Browserify的库在客户端创建模块，并且需要用到Node.js。利用ES6，我们现在可以直接使用任何类型的模块（AMD和CommonJS）

CommonJS中的exports

module.exports = 1;

module.exports = { foo: ‘bar’ };

module.exports = [‘foo’, ‘bar’];

module.exports = function bar () {};

ES6中的export

在ES6中，提供各种不同类型的exports，我们可以运行如下：

export let name = ‘David’;

export let age = 25;​​

输出对象列表:

function sumTwo(a, b) {

return a + b;

}

function sumThree(a, b, c) {

return a + b + c;

}

export { sumTwo, sumThree };

我们也可以简单地通过export关键字输出函数、对象和值（等等）：

export function sumTwo(a, b) {

return a + b;

}

export function sumThree(a, b, c) {

return a + b + c;

}

And lastly, we can export default bindings:

function sumTwo(a, b) {

return a + b;

}

function sumThree(a, b, c) {

return a + b + c;

}

let api = {

sumTwo,

sumThree

};

输出默认api：

/* Which is the same as

• export { api as default };

*/

建议：在模块结束的地方，始终输出默认的方法。这样可以清晰地看到接口，并且通过弄清楚输出值的名称节省时间。所以在CommonJS模块中通常输出一个对象或值。坚持使用这种模式，会使我们的代码易读，并且可以轻松的在ES6和CommonJS中进行插补。

ES6

ES6 提供提供各种不同的imports,我们输入一整个文件：

import ‘underscore’;

这里值得注意的是，简单的输入一文件会在文件的最顶层执行代码。和Python类似，我们已经命名了imports：

import { sumTwo, sumThree } from ‘math/addition’;

我们还可以重命名这些已经有名的imports：

import {

sumTwo as addTwoNumbers,

sumThree as sumThreeNumbers

} from ‘math/addition’;

此外，我们可以输入各种东西（也叫做 namespace import）

import * as util from ‘math/addition’;

最后，我们可以从模块输入一列值：

import * as additionUtil from ‘math/addition’;

const { sumTwo, sumThree } = additionUtil;

如下这样从默认绑定进行输入

import api from ‘math/addition’;

// 例如: import { default as api } from ‘math/addition’;

虽然最好要保持输出简单，但是如果我们需要，我们有时可以混用默认输入，当我们想如下输出的时候：

// foos.js

export { foo as default, foo1, foo2 };

我们可以如下输入它们：

import foo, { foo1, foo2 } from ‘foos’;

当使用commonj语法（如React）输入一个模型的输出时，我们可以这样做：

import React from ‘react’;

const { Component, PropTypes } = React;

这个也可以进一步简化，使用：

import React, { Component, PropTypes } from ‘react’;

注意：输出的值是绑定，不是引用。因此，绑定的值发生变化会影响输出的模型中的值。避免修改这些输出值的公共接口。

参数(Parameters)

---

在ES5中，我们可以很多方法操作函数参数的默认值、未定义的参数和有定义的参数。在ES6中，我们可以用更简单的语法实现这一切。

默认参数(Default Parameters)

function addTwoNumbers(x, y) {

x = x || 0;

y = y || 0;

return x + y;

}

在ES6中，我们可以简单的把默认值赋给参数：

function addTwoNumbers(x=0, y=0) {

return x + y;

}

addTwoNumbers(2, 4); // 6

addTwoNumbers(2); // 2

addTwoNumbers(); // 0

剩余参数(Rest Parameters)

在ES5中，我们这样操作一个未定义的参数：

function logArguments() {

for (var i=0; i < arguments.length; i++) {

console.log(arguments[i]);

}

}

使用休止符(…)我们可以传入大量未定义的参数：

function logArguments(…args) {

for (let arg of args) {

console.log(arg);

}

}

已命名的参数(Named Parameters)

ES5中，一种处理已命名参数的方式是使用选项方式，这种方法来自jQuery。

function initializeCanvas(options) {

var height = options.height || 600;

var width = options.width || 400;

var lineStroke = options.lineStroke || ‘black’;

}

通过解构成正式参数的方式，我们可以实现同样的功能：

function initializeCanvas(

{ height=600, width=400, lineStroke=‘black’}) {

// Use variables height, width, lineStroke here

}

如果我们想使全部参数值可选，我们可以用一个空对象这样结构：

function initializeCanvas(

{ height=600, width=400, lineStroke=‘black’} = {}) {

// …

}

展开运算符(Spread Operator)

---

在ES5中，查找一个array中的最大值需要使用Math.max的apply方法：

Math.max.apply(null, [-1, 100, 9001, -32]); // 9001

在es6中，我们使用展开运算符将array传递给函数作为参数：

Math.max(…[-1, 100, 9001, -32]); // 9001

我们可以用这样简洁的语法链接数组字面量：

let cities = [‘San Francisco’, ‘Los Angeles’];

let places = [‘Miami’, …cities, ‘Chicago’]; // [‘Miami’, ‘San Francisco’, ‘Los Angeles’, ‘Chicago’]

类（classes)

---

在ES6之前，我们通过创建构造器函数，并且在其prototype上添加属性的方法创建一个类:

function Person(name, age, gender) {

this.name = name;

this.age = age;

this.gender = gender;

}

Person.prototype.incrementAge = function () {

return this.age += 1;

};

并且用一下方法创建继承类：

function Personal(name, age, gender, occupation, hobby) {

Person.call(this, name, age, gender);

this.occupation = occupation;

this.hobby = hobby;

}

Personal.prototype = Object.create(Person.prototype);

Personal.prototype.constructor = Personal;

Personal.prototype.incrementAge = function () {

Person.prototype.incrementAge.call(this);

this.age += 20;

console.log(this.age);

};

ES6 提供了十分有用的句法在后台实现这一切，我们可以这样直接创建一个类：

class Person {

constructor(name, age, gender) {

this.name = name;

this.age = age;

this.gender = gender;

}

incrementAge() {

this.age += 1;

}

}

并且用关键字extends实现继承：

class Personal extends Person {

constructor(name, age, gender, occupation, hobby) {

super(name, age, gender);

this.occupation = occupation;

this.hobby = hobby;

}

incrementAge() {

super.incrementAge();

this.age += 20;

console.log(this.age);

}

}

建议：使用ES6的语法创建类模糊了后台的实现和原型如何工作，这个好特性可以使我们的代码更整洁。

Symbols

---

Symbol在ES6之前就已经出现了, 但是现在我们有了一个公共的接口可以直接使用。Symbol是唯一且不可改变的值，被用作哈希中的键。

Symbol()

调用Symbol()或者Symbol(description)会创建一个不能在全局查找的独一无二的符号。一种使用symbol()的情况是，利用自己的逻辑修补第三方的对象或命名空间，但不确定会不会在库更新时产生冲突。例如，如果你想添加一个方法refreshCompontent到React.Component，并且确信这个方法他们不会在以后的更新中添加。

const refreshComponent = Symbol();

React.Component.prototype[refreshComponent] = () => {

// do something

}

###Symbol.for(key)

Symbol.for(key) 依然会创建一个唯一且不能修改的Symbol，但是它可以在全局被查找。两次调用相同的Symbol.for(key) 会创建一样的Symbol实例。注意，他和Symbol(description)不是相同的:

Symbol(‘foo’) === Symbol(‘foo’) // false

Symbol.for(‘foo’) === Symbol(‘foo’) // false

Symbol.for(‘foo’) === Symbol.for(‘foo’) // true

一个常见的symbol方法Symbol.for(key)是可互操作的。(使用这个方法)这个可以通过使用自己的代码在包括已知接口的第三方的对象参数中查找symbol成员实现，例如：

function reader(obj) {

const specialRead = Symbol.for(‘specialRead’);

if (obj[specialRead]) {

const reader = objspecialRead;

// do something with reader

} else {

throw new TypeError(‘object cannot be read’);

}

}

在另一个库中：

const specialRead = Symbol.for(‘specialRead’);

class SomeReadableType {

specialRead {

const reader = createSomeReaderFrom(this);

return reader;

}

}

ES6中，一个值得注意的是关于Symbol的互操作性的例子是Symbol.iterator，它存在于Arrays、Strings、Generators等等的所有可迭代类型中。当作为一个方法调用的时候，它会返回一个具有迭代器接口的对象。

Maps

---

Maps是JavaScript中十分有用的结构。在ES6之前, 我们通过对象创建哈希maps:

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Web前端开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注：前端）

最后

---

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

大厂面试问深度，小厂面试问广度，如果有同学想进大厂深造一定要有一个方向精通的惊艳到面试官，还要平时遇到问题后思考一下问题的本质，找方法解决是一个方面，看到问题本质是另一个方面。还有大家一定要有目标，我在很久之前就想着以后一定要去大厂，然后默默努力，每天看一些大佬们的文章，总是觉得只有再学深入一点才有机会，所以才有恒心一直学下去。

一个方法调用的时候，它会返回一个具有迭代器接口的对象。

Maps

---

Maps是JavaScript中十分有用的结构。在ES6之前, 我们通过对象创建哈希maps:

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Web前端开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-2fqyxwL1-1710592472326)]
[外链图片转存中…(img-hSNUUBI1-1710592472327)]
[外链图片转存中…(img-bGMJoN9F-1710592472327)]
[外链图片转存中…(img-exvZ445H-1710592472328)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注：前端）
[外链图片转存中…(img-wj4qKda8-1710592472328)]

最后

---

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

大厂面试问深度，小厂面试问广度，如果有同学想进大厂深造一定要有一个方向精通的惊艳到面试官，还要平时遇到问题后思考一下问题的本质，找方法解决是一个方面，看到问题本质是另一个方面。还有大家一定要有目标，我在很久之前就想着以后一定要去大厂，然后默默努力，每天看一些大佬们的文章，总是觉得只有再学深入一点才有机会，所以才有恒心一直学下去。