1
  const fs = require('fs')
2
  const path = require('path')
3

4
  // 普通读取文件的方式
5
  function getFileByPath(fpath){
6
    fs.readFile(fpath,'utf-8',(err,data) => {
7
      if(err) throw err
8
      console.log(data)
9
      return data
10
    })
11
  }
12

13
  let result = getFileByPath(path.join(__dirname,'.files/1.txt'))
14
  console.log(result)
15
```
16

17
这样确实可以读到文件内容，但是`result`却是`undefined`，因为`readFiles`是异步读取的
18

19
于是想到在调用`getFileByPath`时添加回调函数
20

21
```js
22
  function getFileByPath(fpath，callback){
23
    fs.readFile(fpath,'utf-8',(err,data) => {
24
      if(err) throw err
25
      callback(data)
26
    })
27
  }
28

29
  getFileByPath(path.join(__dirname,'.files/1.txt'),(data)=>{
30
    console.log(data)
31
  })
32
```
33

34
但是如果error了，`readFile`里的`callback`就不执行了，
35
需要将成功的结果和失败的结果都返回给用户，所以添加两个回调函数，一个成功调用`succCb`，一个失败调用`errCb`
36

37
```js
38
  function getFileByPath(fpath，succCb, errCb){
39
    fs.readFile(fpath,'utf-8',(err,data) => {
40
      if(err) return errCb
41
      succCb
42
    })
43
  }
44

45
  getFileByPath(path.join(__dirname,'.files/1.txt'),(data)=>{
46
    console.log(data)
47
  },(err)=>{
48
    console.log(err)
49
  })
50
```
51

52
看起来很完美呢，如果这时候再加个需求呢，读取文件1成功后，再读取文件2，读取文件2成功后再读取文件3，那么代码将会是下面的样子
53

54
    getFileByPath(path.join(__dirname,'.files/1.txt'),(data1)=>{
55
      console.log(data1)
56

57
      // 读取文件2
58
      getFileByPath(path.join(__dirname,'files/2.txt'),(data2)=>{
59
        console.log(data2)
60

61
        // 读取文件3
62
        getFileByPath(path.join(__dirname,'files/3.txt'),(data3)=>{
63
          console.log(data3)
64
        })
65
      })
66
    })
67

68
哈哈，层层缩进，如果后面还要读取很多文件呢，那么就陷入了回调地狱，看看下面这张图，很形象有木有
69

70
![回调地狱](./callback_hell.jpg)
71

72
## 用Promise解决回调地狱问题
73

74
如果不想让代码变成酱紫，我们就开始使用Promise，其实Promise的本质就是单纯为了解决回调地狱问题，它会让代码变的优雅，并不会减少代码量
75

76
    > console.log(Promise)
77
      ƒ Promise() { [native code] }
78

79
可以看出来Promise是一个构造函数，我们通过new Promise可以生成一个Promise的实例
80

81
关于Promise更详细的说明 [Promise](http://es6.ruanyifeng.com/?search=fetch&x=0&y=0#docs/promise)
82

83
如果用Promise来实现读取三个文件的需求呢
84

85
首先构建一个方法，返回一个promise
86

87
    function getFileByPath(fpath){
88
      var promise = new Promise(resolve,reject){
89
        fs.readFile(fpath,'utf-8',(err,data)=>{
90
          if(err) return reject(err)
91
          resolve(data)
92
        })
93
      }
94
      return promise
95
    }
96

97
开始读取文件
98

99
    getFileByPath('files1.txt').then((data1)=>{
100
      console.log(data1)
101

102
      getFileByPath('files2.txt').then((data2)=>{
103
        console.log(data2)
104

105
        getFileByPath('files3.txt').then((data3)=>{
106
          console.log(data3)
107
        })
108
      })
109
    })
110

111
咦，写完了，这好像还是回调地狱啊，纳尼？
112

113
    getFileByPath('files1.txt').then( data1 => {
114
      console.log(data1)
115
      return getFileByPath('files2.txt')
116
    }).then( data2 => {
117
      console.log(data2)
118
      return getFileByPath('file3.txt')
119
    }).then( data3 => {
120
      console.log(data3)
121
    })
122

123
emmmmm...，正确打开方式是这样，是不是很优雅
124

125
但是为什么第二个`then`会获取到`getFileByPath('files2.txt')`的结果呢？
126

127
> 上面代码中，第一个then方法指定的回调函数，返回的是另一个Promise对象。这时，第二个then方法指定的回调函数，就会等待这个新的Promise对象状态发生变化。如果变为resolved，就调用第一个回调函数，如果状态变为rejected，就调用第二个回调函数。