摘要：臆想的針對讀取到的內(nèi)容進(jìn)行操作，比如打印文件內(nèi)容臆想中，讀取文件是有返回值的，將返回值，即文件內(nèi)容，賦給一個變量，然后決定對讀取到的內(nèi)容進(jìn)行相應(yīng)的操作，例如打印文件中的內(nèi)容。

let fs = require("fs")

function readFile(filename){
    ...
}

let content = readFile("config.js")
// 針對讀取到的內(nèi)容進(jìn)行操作，比如打印文件內(nèi)容
console.log(content)

臆想中，讀取文件是有返回值的，將返回值，即文件內(nèi)容，賦給一個變量，然后決定對讀取到的內(nèi)容進(jìn)行相應(yīng)的操作，例如打印文件中的內(nèi)容。

簡而言之，臆想中，讀取文件，打印文件是相互分開的。

let fs = require("fs")

function readFile(filename, callback){
    fs.readFile(filename, "utf8", (err, data) => {
        if(err){
            throw new err
        }
        callback(data)
    })
}

readFile("config.js", data => {
    console.log(data)
})

實際上，在經(jīng)常使用的回調(diào)中，讀取文件和針對文件內(nèi)容相應(yīng)的操作是在一起的，

你在要求讀取文件的同時，還要說明獲取文件內(nèi)容后干嘛

這和習(xí)慣性思維，你先把文件內(nèi)容給我，至于我怎么處理，稍后再說

let fs = require("fs")

function readFile(filename) {
    return new Promise(function (resolve) { // 這里的callback，是在run函數(shù)中傳遞的
        fs.readFile(filename, "utf8", (err, data) => {
            if (err) {
                reject(err)
            }
            resolve(data)
        })
    })
}

let content = readFile("config.js")
content.then(res => {
    console.log(res)
})
// 對比臆想中的
let content = readFile("config.js")
// 針對讀取到的內(nèi)容進(jìn)行操作，比如打印文件內(nèi)容
console.log(content)

使用Promise后，整個書寫邏輯開始和臆想中的很接近了，讀取文件和對文件內(nèi)容的操作分開了

即通過使用Promise，可以將異步的操作和對異步結(jié)果的處理，分開

let fs = require("fs")

function resolve(value) {
    let _self = this
    setTimeout(function () {
        _self.callbacks.forEach(function (callback) {
            callback(value);
        })
    }, 0)
    // 保證在resolve執(zhí)行之前，then方法都已經(jīng)注冊
}

class FakePromise {

    constructor(fn) {
        // fn是個函數(shù)，里面包含異步，異步成功
        // Promise在new的過程中就已經(jīng)開始執(zhí)行異步代碼
        // 異步代碼執(zhí)行完觸發(fā)resolve，resolve作為異步代碼的參數(shù)，它早已經(jīng)實現(xiàn)好
        this.value = null
        this.callbacks = []
        fn(resolve.bind(this))
    }

    then(onFulfilled) {
        this.callbacks.push(onFulfilled)
        return this
    }
}

function readFile(filename) {
    return new FakePromise(function (resolve) {
        fs.readFile(filename, "utf8", (err, data) => {
            if (err) {
                return
            }
            resolve(data)
        })
    })
}

let content = readFile("config.js")
content.then(res => {
    console.log(res)
})

這樣看來，Promise和發(fā)布-訂閱模式有些相像。promise內(nèi)部也有個事件隊列，通過then注冊事件，通過resolve觸發(fā)。每個promise在創(chuàng)建的時候，就開始執(zhí)行傳遞給它的函數(shù)，函數(shù)中會觸發(fā)resolve，這個resolve就是去執(zhí)行所有注冊的事件。

當(dāng)然，實際上promise比這強大的多，首先resolve執(zhí)行所有注冊的事件會保證滯后執(zhí)行，避免還沒通過then注冊完事件，resolve就執(zhí)行了

其次，在異步操作成功之后，通過then注冊事件，可以立馬執(zhí)行，這就需要給promise添加狀態(tài)機制

...
then(onFulfilled) {
        if (this.state === "pending") {
            this.callbacks.push(onFulfilled)
            return this
        }
        onFulfilled(value)
        return this
}
...

判斷不是"pending"，就立刻執(zhí)行注冊的函數(shù)

另外就是每個then()方法，都會返回一個新的promise

大概長這樣

then(onFulfilled) {
    return new Promise(...)
}

30分鐘，讓你徹底明白Promise原理

let fs = require("fs")

function run(taskDef){
    // 傳入的taskDef是個生成器函數(shù)，執(zhí)行后返回迭代器
    let task = taskDef()
    // 調(diào)用迭代器的next()方法，開始taskDef函數(shù)中的代碼，直至遇到y(tǒng)ield，并將yield的值賦予result
    let result = task.next()
    function step(){
      if(!result.done){
        if(typeof result.value === "function"){
          result.value((err, data)=>{
            if(err){
              result = task.throw(err)
              return
            }
            result = task.next(data)
            step()
          })
          // 這里的result.value(...){...}
          // 調(diào)用的是function(callback){fs.readFile(filename, "utf8", callback)}
        }else{
          result = task.next(data)
          step() // 判斷任務(wù)是否執(zhí)行完
        }
      }
    }
    step()
    // task.next(data) 繼續(xù)執(zhí)行生成器中的代碼，并將值傳回給觸發(fā)這次next()的yield的等號左邊的變量
}

function readFile(filename){
  return function (callback){ // 這里的callback，是在run函數(shù)中傳遞的
    fs.readFile(filename, "utf8", callback)
  }
}

run(function*(){
  let content = yield readFile("config.js") // 傳遞函數(shù)至run函數(shù)中，并由run傳遞參數(shù)調(diào)用
  // 對文件內(nèi)容進(jìn)行處理
  console.log(content)
})
// 對比臆想中的
let content = readFile("config.js")
// 針對讀取到的內(nèi)容進(jìn)行操作，比如打印文件內(nèi)容
console.log(content)

生成器函數(shù)可以停止函數(shù)執(zhí)行，代碼在yield readFile("copy.js")處暫停

異步任務(wù)的回調(diào)中調(diào)用迭代器的next()方法，使生成器函數(shù)中的代碼繼續(xù)執(zhí)行，并通過next()方法傳遞參數(shù)回至生成器函數(shù)中，異步任務(wù)完成，返回值已經(jīng)賦值給了content

let fs = require("fs")

function run(taskDef){
    // 傳入的taskDef是個生成器函數(shù)，執(zhí)行后返回迭代器
    let task = taskDef()
    // 調(diào)用迭代器的next()方法，開始taskDef函數(shù)中的代碼，直至遇到y(tǒng)ield，并將yield的值賦予result
    let result = task.next()
    function step(){
      if(!result.done){
        let promise = Promise.resolve(result.value)
        promise.then(value => {
            result = task.next(value)
            step()
        }).catch(err => {
            result = task.throw(err)
            step()
        })
          
      }
    }
    step()
    // task.next(data) 繼續(xù)執(zhí)行生成器中的代碼，并將值傳回給觸發(fā)這次next()的yield的等號左邊的變量
}

function readFile(filename){
  return new Promise(function (resolve, reject){ // 這里的callback，是在run函數(shù)中傳遞的
    fs.readFile(filename, "utf8", (err, data) => {
        if(err){
            reject(err)
        }
        resolve(data)
    })
  })
}

run(function*(){
  let content = yield readFile("config.js") // 傳遞函數(shù)至run函數(shù)中，并由run傳遞參數(shù)調(diào)用
  // 對文件內(nèi)容進(jìn)行處理
  console.log(content)
})

console.log("先執(zhí)行")

是不是和promise+generator很像

let fs = require("fs")

function readFile(filename) {
    return new Promise(function (resolve) { // 這里的callback，是在run函數(shù)中傳遞的
        fs.readFile(filename, "utf8", (err, data) => {
            if (err) {
                reject(err)
            }
            resolve(data)
        })
    })
}
(async function test() {
    let content = await readFile("copy.js")
    console.log(content)
})()

深入理解ES6