update

amaler · amaler · commit 32016cf97299 · 2017-03-01T18:03:48.000+08:00
diff --git a/part3-promise/02-promise-use.md b/part3-promise/02-promise-use.md
@@ -72,7 +72,7 @@ result.then(data => {
 
 ## 异常捕获
 
-我们知道`then`会接收两个参数（函数），第一个参数会在执行`resolve`之后触发（还能传递参数），第二个参数会在执行`reject`之后触发（其实也可以传递参数，和`resolve`传递参数一样），但是上面的例子中，**我们没有用到`then`的第二个参数。这是为何呢 ———— 因为我没不建议这么用**。
+我们知道`then`会接收两个参数（函数），第一个参数会在执行`resolve`之后触发（还能传递参数），第二个参数会在执行`reject`之后触发（其实也可以传递参数，和`resolve`传递参数一样），但是上面的例子中，**我们没有用到`then`的第二个参数。这是为何呢 ———— 因为不建议这么用**。
 
 对于`Promise`中的异常处理，我们建议用`catch`方法，而不是`then`的第二个参数。请看下面的代码，以及注释。
 
diff --git a/part3-promise/03-promise-standard.md b/part3-promise/03-promise-standard.md
@@ -1,6 +1,60 @@
 # 对标一下 Promise/A+ 规范
 
+Promise/A 是由 CommonJS 组织制定的异步模式编程规范，后来又经过一些升级，就是当前的 Promise/A+ 规范。上一节讲述的`Promise`的一些功能实现，就是根据这个规范来的。
 
+## 本节内容概述
+
+- 介绍规范的核心内容
+- 状态变化
+- `then`方法
+- 接下来...
+
+## 介绍规范的核心内容
+
+网上有很多介绍 Promise/A+ 规范的文章，大家可以搜索来看，但是它的核心要点有以下几个，我也是从看了之后自己总结的
+
+**关于状态**
+
+- promise 可能有三种状态：等待（pending）、已完成（fulfilled）、已拒绝（rejected）
+- promise 的状态只可能从“等待”转到“完成”态或者“拒绝”态，不能逆向转换，同时“完成”态和“拒绝”态不能相互转换
+
+**关于`then`方法**
+
+- promise 必须实现`then`方法，而且`then`必须返回一个 promise ，同一个 promise 的`then`可以调用多次（链式），并且回调的执行顺序跟它们被定义时的顺序一致
+- `then`方法接受两个参数，第一个参数是成功时的回调，在 promise 由“等待”态转换到“完成”态时调用，另一个是失败时的回调，在 promise 由“等待”态转换到“拒绝”态时调用
+
+下面挨个介绍这些规范在上一节代码中的实现，所谓理论与实践相结合。**在阅读以下内容时，你要时刻准备参考上一节的代码**。
+
+## 状态变化
+
+> promise 可能有三种状态：等待（pending）、已完成（fulfilled）、已拒绝（rejected）
+
+拿到上一节的`readFilePromise`函数，然后执行`const result = readFilePromise(someFileName)`会得到一个`Promise`对象。
+
+- 刚刚创建时，就是 等待（pending）状态
+- 如果读取文件成功了，`readFilePromise`函数内部的`callback`中会自定调用`resolve()`，这样就变为 已完成（fulfilled）状态
+- 如果很不幸读取文件失败了（例如文件名写错了，找不到文件），`readFilePromise`函数内部的`callback`中会自定调用`reject()`，这样就变为 已拒绝（rejeced）状态
+
+> promise 的状态只可能从“等待”转到“完成”态或者“拒绝”态，不能逆向转换，同时“完成”态和“拒绝”态不能相互转换
+
+这个规则还是可以参考读取文件的这个例子。从一开始准备读取，到最后无论是读取成功或是读取失败，都是不可逆的。另外，读取成功和读取失败之间，也是不能互换的。这个逻辑没有任何问题，很好理解。
+
+## `then`方法
+
+> promise 必须实现`then`方法，而且`then`必须返回一个 promise ，同一个 promise 的`then`可以调用多次（链式），并且回调的执行顺序跟它们被定义时的顺序一致
+
+- `promise`对象必须实现`then`方法这个无需解释，没有`then`那就不叫`promise`
+- “而且`then`必须返回一个`promise`，同一个 promise 的`then`可以调用多次（链式）” ———— 这两句话说明了一个意思 ———— `then`肯定要再返回一个`promise`，要不然`then`后面怎么能再链式的跟一个`then`呢？
+
+> `then`方法接受两个参数，第一个参数是成功时的回调，在 promise 由“等待”态转换到“完成”态时调用，另一个是失败时的回调，在 promise 由“等待”态转换到“拒绝”态时调用
+
+这句话比较好理解了，我们从一开始就在 demo 中演示。
+
+## 接下来...
+
+`Promise`的应用、规范都介绍完了，看起来挺牛的，也解决了异步操作中使用`callback`带来的很多问题。但是`Promise`本质上到底是一种什么样的存在，它是真的把`callback`弃而不用了吗，还是两者有什么合作关系？它到底是真的神通广大，还是使用了障眼法？
+
+这些问题，大家学完`Promise`之后应该去思考，不能光学会怎么用就停止了。下一节我们一起来探讨~
 
 ## 求打赏
 
diff --git a/part3-promise/04-promise-callback.md b/part3-promise/04-promise-callback.md
@@ -1,6 +1,82 @@
 # Promise 真的取代 callback 了吗
 
+Promise 虽然改变了 JS 工程师对于异步操作的写法，但是却改变不了 JS 单线程、异步的执行模式。
 
+## 本节概述
+
+- JS 异步的本质
+- Promise 只是表面的写法上的改变
+- Promise 中不能缺少 callback
+- 接下来...
+
+## JS 异步的本质
+
+从最初的 ES3、4 到 ES5 再到现在的 ES6 和即将到来的 ES7，语法标准上更新很多，但是 JS 这种单线程、异步的本质是没有改变的。nodejs 中读取文件的代码一直都可以这样写
+
+```javascript
+fs.readFile('some.json', (err, data) => {
+})
+```
+
+既然异步这个本质不能改变，伴随异步在一起的永远都会有`callback`，因为没有`callback`就无法实现异步。因此`callback`永远存在。
+
+## Promise 只是表面的写法上的改变
+
+JS 工程师不会讨厌 JS 异步的本质，但是很讨厌 JS 异步操作中`callback`的书写方式，特别是遇到万恶的`callback-hell`（嵌套`callback`）时。
+
+计算机的抽象思维和人的具象思维是完全不一样的，人永远喜欢看起来更加符合逻辑、更加易于阅读的程序，因此现在特别强调代码可读性。而`Promise`就是一种代码可读性的变化。大家感受一下这两种不同（**这其中还包括异常处理，加上异常处理会更加复杂**）
+
+第一种，传统的`callback`方式
+
+```javascript
+fs.readFile('some1.json', (err, data) => {
+    fs.readFile('some2.json', (err, data) => {
+        fs.readFile('some3.json', (err, data) => {
+            fs.readFile('some4.json', (err, data) => {
+
+            })
+        })
+    })
+})
+```
+
+第二种，`Promise`方式
+
+```javascript
+readFilePromise('some1.json').then(data => {
+    return readFilePromise('some2.json')
+}).then(data => {
+    return readFilePromise('some3.json')
+}).then(data => {
+    return readFilePromise('some4.json')
+})
+```
+
+这两种方式对于代码可读性的对比，非常明显。**但是最后再次强调，`Promise`只是对于异步操作代码可读性的一种变化，它并没有改变 JS 异步执行的本质，也没有改变 JS 中存在`callback`的现象**。
+
+## Promise 中不能缺少 callback
+
+上文已经基本给出了上一节提问的答案，但是这里还需要再加一个补充：`Promise`不仅仅是没有取代`callback`或者弃而不用，反而`Promise`中要使用到`callback`。因为，JS 异步执行的本质，必须有`callback`存在，否则无法实现。
+
+再次粘贴处之前章节的封装好的一个`Promise`函数（进行了一点点简化）
+
+```javascript
+const readFilePromise = function (fileName) {
+    return new Promise((resolve, reject) => {
+        fs.readFile(fileName, (err, data) => {
+            resolve(data.toString())
+        })
+    })
+}
+```
+
+上面的代码中，`promise`对象的状态要从`pending`变化为`fulfilled`，就需要去执行`resolve()`函数。那么是从哪里执行的 ———— **还得从`callback`中执行`resolve`函数 ———— 这就是`Promise`也需要`callback`的最直接体现**。
+
+## 接下来...
+
+一块技术“火”的程度和第三方开源软件的数量、质量以及使用情况有很大的正比关系。例如为了简化 DOM 操作，jquery 风靡全世界。Promise 用的比较多，第三方库当然就必不可少，它们极大程度的简化了 Promise 的代码。
+
+接下来我们一起看看`Q.js`这个库的使用，学会了它，将极大程度提高你写 Promise 的效率。
 
 ## 求打赏
 
diff --git a/part3-promise/05-promise-q.md b/part3-promise/05-promise-q.md
@@ -1,7 +1,149 @@
 # 使用 Q.js 库
 
+如果实际项目中使用`Promise`，还是强烈建议使用比较靠谱的第三方插件，会极大增加你的开发效率。除了将要介绍的`Q.js`，还有`bluebird`也推荐使用，去 github 自行搜索吧。
 
+另外，使用第三方库不仅仅是提高效率，**它还让你在浏览器端（不支持`Promise`的环境中）使用`promise`**。
 
+本节展示的代码参考[这里](./test.js)
+
+## 本节内容概述
+
+- 下载和安装
+- 使用`Q.nfcall`和`Q.nfapply`
+- 使用`Q.defer`
+- 使用`Q.denodeify`
+- 使用`Q.all`和`Q.any`
+- 使用`Q.delay`
+- 其他
+
+## 下载和安装
+
+可以直接去它的 [github 地址](https://github.com/kriskowal/q) （近 1.3W 的 star 数量说明其用户群很大）查看文档。
+
+如果项目使用 CommonJS 规范直接 `npm i q --save`，如果是网页外链可寻找可用的 cdn 地址，或者干脆下载到本地。
+
+以下我将要演示的代码，都是使用 CommonJS 规范的，因此我要演示代码之前加上引用，以后的代码演示就不重复加了。
+
+```javascript
+const Q = require('q')
+```
+
+## 使用`Q.nfcall`和`Q.nfapply`
+
+要使用这两个函数，你得首先了解 JS 的`call`和`apply`，如果不了解，先去看看。熟悉了这两个函数之后，再回来看。
+
+`Q.nfcall`就是使用`call`的语法来返回一个`promise`对象，例如
+
+```javascript
+const fullFileName = path.resolve(__dirname, '../data/data1.json')
+const result = Q.nfcall(fs.readFile, fullFileName, 'utf-8')  // 使用 Q.nfcall 返回一个 promise
+result.then(data => {
+    console.log(data)
+}).catch(err => {
+    console.log(err.stack)
+})
+```
+
+`Q.nfapply`就是使用`apply`的语法返回一个`promise`对象，例如
+
+```javascript
+const fullFileName = path.resolve(__dirname, '../data/data1.json')
+const result = Q.nfapply(fs.readFile, [fullFileName, 'utf-8'])  // 使用 Q.nfapply 返回一个 promise
+result.then(data => {
+    console.log(data)
+}).catch(err => {
+    console.log(err.stack)
+})
+```
+
+怎么样，体验了一把，是不是比直接自己写`Promise`简单多了？
+
+## 使用`Q.defer`
+
+`Q.defer`算是一个比较偏底层一点的 API ，用于自己定义一个`promise`生成器，如果你需要在浏览器端编写，而且浏览器不支持`Promise`，这个就有用处了。
+
+```javascript
+function readFile(fileName) {
+    const defer = Q.defer()
+    fs.readFile(fileName, (err, data) => {
+        if (err) {
+            defer.reject(err)
+        } else {
+            defer.resolve(data.toString())
+        }
+    })
+    return defer.promise
+}
+readFile('data1.json')
+    .then(data => {
+        console.log(data)
+    })
+    .catch(err => {
+        console.log(err.stack)
+    })
+```
+
+
+## 使用`Q.denodeify`
+
+我们在很早之前的一节中自己封装了一个`fs.readFile`的`promise`生成器，这里再次回顾一下
+
+```javascript
+const readFilePromise = function (fileName) {
+    return new Promise((resolve, reject) => {
+        fs.readFile(fileName, (err, data) => {
+            if (err) {
+                reject(err)
+            } else {
+                resolve(data.toString())
+            }
+        })
+    })
+}
+```
+
+虽然看着不麻烦，但是还是需要很多行代码来实现，如果使用`Q.denodeify`，一行代码就搞定了！
+
+```javascript
+const readFilePromise = Q.denodeify(fs.readFile)
+```
+
+`Q.denodeif`就是一键将`fs.readFile`这种有回调函数作为参数的异步操作封装成一个`promise`生成器，非常方便！
+
+## 使用`Q.all`和`Q.any`
+
+这两个其实就是对应了之前讲过的`Promise.all`和`Promise.race`，而且应用起来一模一样，不多赘述。
+
+```javascript
+const r1 = Q.nfcall(fs.readFile, 'data1.json', 'utf-8')
+const r2 = Q.nfcall(fs.readFile, 'data2.json', 'utf-8')
+Q.all([r1, r2]).then(arr => {
+    console.log(arr)
+}).catch(err => {
+    console.log(err)
+})
+```
+
+## 使用`Q.delay`
+
+`Q.delay`，顾名思义，就是延迟的意思。例如，读取一个文件成功之后，再过五秒钟之后，再去做xxxx。这个如果是自己写的话，也挺费劲的，但是`Q.delay`就直接给我们分装好了。
+
+```javascript
+const result = Q.nfcall(fs.readFile, 'data1.json', 'utf-8')
+result.delay(5000).then(data => {
+    // 得到结果
+    console.log(data.toString())
+}).catch(err => {
+    // 捕获错误
+    console.log(err.stack)
+})
+```
+
+## 其他
+
+以上就是`Q.js`一些最常用的操作，其他的一些非常用技巧，大家可以去搜索或者去官网查看文档。
+
+至此，ES6 `Promise`的所有内容就已经讲完了。但是异步操作的优化到这里没有结束，更加精彩的内容还在后面 ———— `Generator`
 
 ## 求打赏
 
diff --git a/part3-promise/test.js b/part3-promise/test.js
@@ -1,5 +1,6 @@
 const fs = require('fs')
 const path = require('path')
+const Q = require('q')
 
 // 封装一个 Promise
 const readFilePromise = function (fileName) {
@@ -104,7 +105,7 @@ function fn4() {
 
 
 // ----- Promise.resolve() 的使用 -----
-function fnC() {
+function fn5() {
 
     // Promise.resolve('foo') 的写法等价于以下代码，
     // new Promise( resolve => resolve('foo') )
@@ -132,6 +133,29 @@ function fnC() {
     // 这里的 deferred 对象就是一个 thenable 对象
     // var jsPromise = Promise.resolve($.ajax('/whatever.json'));
 }
-fnC()
+// fn5()
+
+
+// ------ Q.nfcall 和 Q.nfapply --------
+function fn6() {
+
+    const fullFileName1 = path.resolve(__dirname, '../data/data1.json')
+    const result1 = Q.nfcall(fs.readFile, fullFileName1, 'utf-8')
+    result1.then(data => {
+        console.log(data)
+    }).catch(err => {
+        console.log(err.stack)
+    })
+
+    const fullFileName2 = path.resolve(__dirname, '../data/data2.json')
+    const result2 = Q.nfapply(fs.readFile, [fullFileName2, 'utf-8'])  // 使用 Q.nfapply 返回一个 promise
+    result2.then(data => {
+        console.log(data)
+    }).catch(err => {
+        console.log(err.stack)
+    })
+
+}
+fn6()
 
 
