book/es6tutorial
1
0
Fork 0
mirror of https://github.com/ruanyf/es6tutorial.git synced 2025-05-25 11:12:21 +00:00
Code Issues Releases Wiki Activity

Merge branch 'gh-pages' of github.com:ruanyf/es6tutorial into gh-pages

Browse Source
This commit is contained in:
ruanyf 2017-11-11 20:40:19 +08:00
commit 6d2fc73616
2 changed files with 36 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
docs/number.md
View File

@ -454,7 +454,7 @@ Math.clz32(0b00100000000000000000000000000000) // 2
上面代码中，0的二进制形式全为0，所以有32个前导0；1的二进制形式是`0b1`，只占1位，所以32位之中有31个前导0；1000的二进制形式是`0b1111101000`，一共有10位，所以32位之中有22个前导0。 上面代码中，0的二进制形式全为0，所以有32个前导0；1的二进制形式是`0b1`，只占1位，所以32位之中有31个前导0；1000的二进制形式是`0b1111101000`，一共有10位，所以32位之中有22个前导0。
`clz32`这个函数名就来自”count leading zero bits in 32-bit binary representations of a number“（计算32位整数的前导0）的缩写。 `clz32`这个函数名就来自”count leading zero bits in 32-bit binary representation of a number“（计算一个数的32位二进制形式的前导0的个数）的缩写。
左移运算符（`<<`）与`Math.clz32`方法直接相关。 左移运算符（`<<`）与`Math.clz32`方法直接相关。

70
docs/promise.md
View File

@ -27,7 +27,7 @@ ES6 规定，`Promise`对象是一个构造函数，用来生成`Promise`实例
下面代码创造了一个`Promise`实例。 下面代码创造了一个`Promise`实例。
```javascript ```javascript
var promise = new Promise(function(resolve, reject) { const promise = new Promise(function(resolve, reject) {
// ... some code // ... some code
if (/* 异步操作成功 */){ if (/* 异步操作成功 */){
@ -96,7 +96,7 @@ console.log('Hi!');
```javascript ```javascript
function loadImageAsync(url) { function loadImageAsync(url) {
return new Promise(function(resolve, reject) { return new Promise(function(resolve, reject) {
var image = new Image(); const image = new Image();
image.onload = function() { image.onload = function() {
resolve(image); resolve(image);
@ -116,16 +116,9 @@ function loadImageAsync(url) {
下面是一个用`Promise`对象实现的 Ajax 操作的例子。 下面是一个用`Promise`对象实现的 Ajax 操作的例子。
```javascript ```javascript
var getJSON = function(url) { const getJSON = function(url) {
var promise = new Promise(function(resolve, reject){ const promise = new Promise(function(resolve, reject){
var client = new XMLHttpRequest(); const handler = function() {
client.open("GET", url);
client.onreadystatechange = handler;
client.responseType = "json";
client.setRequestHeader("Accept", "application/json");
client.send();
function handler() {
if (this.readyState !== 4) { if (this.readyState !== 4) {
return; return;
} }
@ -135,6 +128,13 @@ var getJSON = function(url) {
reject(new Error(this.statusText)); reject(new Error(this.statusText));
} }
}; };
const client = new XMLHttpRequest();
client.open("GET", url);
client.onreadystatechange = handler;
client.responseType = "json";
client.setRequestHeader("Accept", "application/json");
client.send();
}); });
return promise; return promise;
@ -152,11 +152,11 @@ getJSON("/posts.json").then(function(json) {
如果调用`resolve`函数和`reject`函数时带有参数，那么它们的参数会被传递给回调函数。`reject`函数的参数通常是`Error`对象的实例，表示抛出的错误；`resolve`函数的参数除了正常的值以外，还可能是另一个 Promise 实例，比如像下面这样。 如果调用`resolve`函数和`reject`函数时带有参数，那么它们的参数会被传递给回调函数。`reject`函数的参数通常是`Error`对象的实例，表示抛出的错误；`resolve`函数的参数除了正常的值以外，还可能是另一个 Promise 实例，比如像下面这样。
```javascript ```javascript
var p1 = new Promise(function (resolve, reject) { const p1 = new Promise(function (resolve, reject) {
// ... // ...
}); });
var p2 = new Promise(function (resolve, reject) { const p2 = new Promise(function (resolve, reject) {
// ... // ...
resolve(p1); resolve(p1);
}) })
@ -167,11 +167,11 @@ var p2 = new Promise(function (resolve, reject) {
注意，这时`p1`的状态就会传递给`p2`，也就是说，`p1`的状态决定了`p2`的状态。如果`p1`的状态是`pending`，那么`p2`的回调函数就会等待`p1`的状态改变；如果`p1`的状态已经是`resolved`或者`rejected`，那么`p2`的回调函数将会立刻执行。 注意，这时`p1`的状态就会传递给`p2`，也就是说，`p1`的状态决定了`p2`的状态。如果`p1`的状态是`pending`，那么`p2`的回调函数就会等待`p1`的状态改变；如果`p1`的状态已经是`resolved`或者`rejected`，那么`p2`的回调函数将会立刻执行。
```javascript ```javascript
var p1 = new Promise(function (resolve, reject) { const p1 = new Promise(function (resolve, reject) {
setTimeout(() => reject(new Error('fail')), 3000) setTimeout(() => reject(new Error('fail')), 3000)
}) })
var p2 = new Promise(function (resolve, reject) { const p2 = new Promise(function (resolve, reject) {
setTimeout(() => resolve(p1), 1000) setTimeout(() => resolve(p1), 1000)
}) })
@ -276,7 +276,7 @@ p.then((val) => console.log('fulfilled:', val))
下面是一个例子。 下面是一个例子。
```javascript ```javascript
var promise = new Promise(function(resolve, reject) { const promise = new Promise(function(resolve, reject) {
throw new Error('test'); throw new Error('test');
}); });
promise.catch(function(error) { promise.catch(function(error) {
@ -289,7 +289,7 @@ promise.catch(function(error) {
```javascript ```javascript
// 写法一 // 写法一
var promise = new Promise(function(resolve, reject) { const promise = new Promise(function(resolve, reject) {
try { try {
throw new Error('test'); throw new Error('test');
} catch(e) { } catch(e) {
@ -301,7 +301,7 @@ promise.catch(function(error) {
}); });
// 写法二 // 写法二
var promise = new Promise(function(resolve, reject) { const promise = new Promise(function(resolve, reject) {
reject(new Error('test')); reject(new Error('test'));
}); });
promise.catch(function(error) { promise.catch(function(error) {
@ -314,7 +314,7 @@ promise.catch(function(error) {
如果Promise状态已经变成`resolved`，再抛出错误是无效的。 如果Promise状态已经变成`resolved`，再抛出错误是无效的。
```javascript ```javascript
var promise = new Promise(function(resolve, reject) { const promise = new Promise(function(resolve, reject) {
resolve('ok'); resolve('ok');
throw new Error('test'); throw new Error('test');
}); });
@ -399,7 +399,7 @@ process.on('unhandledRejection', function (err, p) {
再看下面的例子。 再看下面的例子。
```javascript ```javascript
var promise = new Promise(function (resolve, reject) { const promise = new Promise(function (resolve, reject) {
resolve('ok'); resolve('ok');
setTimeout(function () { throw new Error('test') }, 0) setTimeout(function () { throw new Error('test') }, 0)
}); });
@ -413,7 +413,7 @@ promise.then(function (value) { console.log(value) });
一般总是建议，Promise 对象后面要跟`catch`方法，这样可以处理 Promise 内部发生的错误。`catch`方法返回的还是一个 Promise 对象，因此后面还可以接着调用`then`方法。 一般总是建议，Promise 对象后面要跟`catch`方法，这样可以处理 Promise 内部发生的错误。`catch`方法返回的还是一个 Promise 对象，因此后面还可以接着调用`then`方法。
```javascript ```javascript
var someAsyncThing = function() { const someAsyncThing = function() {
return new Promise(function(resolve, reject) { return new Promise(function(resolve, reject) {
// 下面一行会报错，因为x没有声明 // 下面一行会报错，因为x没有声明
resolve(x + 2); resolve(x + 2);
@ -449,7 +449,7 @@ Promise.resolve()
`catch`方法之中，还能再抛出错误。 `catch`方法之中，还能再抛出错误。
```javascript ```javascript
var someAsyncThing = function() { const someAsyncThing = function() {
return new Promise(function(resolve, reject) { return new Promise(function(resolve, reject) {
// 下面一行会报错，因为x没有声明 // 下面一行会报错，因为x没有声明
resolve(x + 2); resolve(x + 2);
@ -491,7 +491,7 @@ someAsyncThing().then(function() {
`Promise.all`方法用于将多个 Promise 实例，包装成一个新的 Promise 实例。 `Promise.all`方法用于将多个 Promise 实例，包装成一个新的 Promise 实例。
```javascript ```javascript
var p = Promise.all([p1, p2, p3]); const p = Promise.all([p1, p2, p3]);
``` ```
上面代码中，`Promise.all`方法接受一个数组作为参数，`p1`、`p2`、`p3`都是 Promise 实例，如果不是，就会先调用下面讲到的`Promise.resolve`方法，将参数转为 Promise 实例，再进一步处理。（`Promise.all`方法的参数可以不是数组，但必须具有 Iterator 接口，且返回的每个成员都是 Promise 实例。） 上面代码中，`Promise.all`方法接受一个数组作为参数，`p1`、`p2`、`p3`都是 Promise 实例，如果不是，就会先调用下面讲到的`Promise.resolve`方法，将参数转为 Promise 实例，再进一步处理。（`Promise.all`方法的参数可以不是数组，但必须具有 Iterator 接口，且返回的每个成员都是 Promise 实例。）
@ -506,7 +506,7 @@ var p = Promise.all([p1, p2, p3]);
```javascript ```javascript
// 生成一个Promise对象的数组 // 生成一个Promise对象的数组
var promises = [2, 3, 5, 7, 11, 13].map(function (id) { const promises = [2, 3, 5, 7, 11, 13].map(function (id) {
return getJSON('/post/' + id + ".json"); return getJSON('/post/' + id + ".json");
}); });
@ -586,7 +586,7 @@ Promise.all([p1, p2])
`Promise.race`方法同样是将多个Promise实例，包装成一个新的Promise实例。 `Promise.race`方法同样是将多个Promise实例，包装成一个新的Promise实例。
```javascript ```javascript
var p = Promise.race([p1, p2, p3]); const p = Promise.race([p1, p2, p3]);
``` ```
上面代码中，只要`p1`、`p2`、`p3`之中有一个实例率先改变状态，`p`的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给`p`的回调函数。 上面代码中，只要`p1`、`p2`、`p3`之中有一个实例率先改变状态，`p`的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给`p`的回调函数。
@ -613,7 +613,7 @@ p.catch(error => console.log(error));
有时需要将现有对象转为Promise对象，`Promise.resolve`方法就起到这个作用。 有时需要将现有对象转为Promise对象，`Promise.resolve`方法就起到这个作用。
```javascript ```javascript
var jsPromise = Promise.resolve($.ajax('/whatever.json')); const jsPromise = Promise.resolve($.ajax('/whatever.json'));
``` ```
上面代码将jQuery生成的`deferred`对象，转为一个新的Promise对象。 上面代码将jQuery生成的`deferred`对象，转为一个新的Promise对象。
@ -666,7 +666,7 @@ p1.then(function(value) {
如果参数是一个原始值，或者是一个不具有`then`方法的对象，则`Promise.resolve`方法返回一个新的Promise对象，状态为`resolved`。 如果参数是一个原始值，或者是一个不具有`then`方法的对象，则`Promise.resolve`方法返回一个新的Promise对象，状态为`resolved`。
```javascript ```javascript
var p = Promise.resolve('Hello'); const p = Promise.resolve('Hello');
p.then(function (s){ p.then(function (s){
console.log(s) console.log(s)
@ -683,7 +683,7 @@ p.then(function (s){
所以，如果希望得到一个Promise对象，比较方便的方法就是直接调用`Promise.resolve`方法。 所以，如果希望得到一个Promise对象，比较方便的方法就是直接调用`Promise.resolve`方法。
```javascript ```javascript
var p = Promise.resolve(); const p = Promise.resolve();
p.then(function () { p.then(function () {
// ... // ...
@ -717,9 +717,9 @@ console.log('one');
`Promise.reject(reason)`方法也会返回一个新的 Promise 实例，该实例的状态为`rejected`。 `Promise.reject(reason)`方法也会返回一个新的 Promise 实例，该实例的状态为`rejected`。
```javascript ```javascript
var p = Promise.reject('出错了'); const p = Promise.reject('出错了');
// 等同于 // 等同于
var p = new Promise((resolve, reject) => reject('出错了')) const p = new Promise((resolve, reject) => reject('出错了'))
p.then(null, function (s) { p.then(null, function (s) {
console.log(s) console.log(s)
@ -814,7 +814,7 @@ Promise.prototype.finally = function (callback) {
```javascript ```javascript
const preloadImage = function (path) { const preloadImage = function (path) {
return new Promise(function (resolve, reject) { return new Promise(function (resolve, reject) {
var image = new Image(); const image = new Image();
image.onload = resolve; image.onload = resolve;
image.onerror = reject; image.onerror = reject;
image.src = path; image.src = path;
@ -833,9 +833,9 @@ function getFoo () {
}); });
} }
var g = function* () { const g = function* () {
try { try {
var foo = yield getFoo(); const foo = yield getFoo();
console.log(foo); console.log(foo);
} catch (e) { } catch (e) {
console.log(e); console.log(e);
@ -843,7 +843,7 @@ var g = function* () {
}; };
function run (generator) { function run (generator) {
var it = generator(); const it = generator();
function go(result) { function go(result) {
if (result.done) return result.value; if (result.done) return result.value;