<ruby id="bdb3f"></ruby>

    <p id="bdb3f"><cite id="bdb3f"></cite></p>

      <p id="bdb3f"><cite id="bdb3f"><th id="bdb3f"></th></cite></p><p id="bdb3f"></p>
        <p id="bdb3f"><cite id="bdb3f"></cite></p>

          <pre id="bdb3f"></pre>
          <pre id="bdb3f"><del id="bdb3f"><thead id="bdb3f"></thead></del></pre>

          <ruby id="bdb3f"><mark id="bdb3f"></mark></ruby><ruby id="bdb3f"></ruby>
          <pre id="bdb3f"><pre id="bdb3f"><mark id="bdb3f"></mark></pre></pre><output id="bdb3f"></output><p id="bdb3f"></p><p id="bdb3f"></p>

          <pre id="bdb3f"><del id="bdb3f"><progress id="bdb3f"></progress></del></pre>

                <ruby id="bdb3f"></ruby>

                合規國際互聯網加速 OSASE為企業客戶提供高速穩定SD-WAN國際加速解決方案。 廣告
                # 異步操作和Async函數 1. [基本概念](http://es6.ruanyifeng.com/#docs/async#基本概念) 2. [Generator函數](http://es6.ruanyifeng.com/#docs/async#Generator函數) 3. [Thunk函數](http://es6.ruanyifeng.com/#docs/async#Thunk函數) 4. [co模塊](http://es6.ruanyifeng.com/#docs/async#co模塊) 5. [async函數](http://es6.ruanyifeng.com/#docs/async#async函數) 異步編程對JavaScript語言太重要。Javascript語言的執行環境是“單線程”的,如果沒有異步編程,根本沒法用,非卡死不可。 ES6誕生以前,異步編程的方法,大概有下面四種。 * 回調函數 * 事件監聽 * 發布/訂閱 * Promise 對象 ES6將JavaScript異步編程帶入了一個全新的階段,ES7的`Async`函數更是提出了異步編程的終極解決方案。 ## 基本概念 ### 異步 所謂"異步",簡單說就是一個任務分成兩段,先執行第一段,然后轉而執行其他任務,等做好了準備,再回過頭執行第二段。 比如,有一個任務是讀取文件進行處理,任務的第一段是向操作系統發出請求,要求讀取文件。然后,程序執行其他任務,等到操作系統返回文件,再接著執行任務的第二段(處理文件)。這種不連續的執行,就叫做異步。 相應地,連續的執行就叫做同步。由于是連續執行,不能插入其他任務,所以操作系統從硬盤讀取文件的這段時間,程序只能干等著。 ### 回調函數 JavaScript語言對異步編程的實現,就是回調函數。所謂回調函數,就是把任務的第二段單獨寫在一個函數里面,等到重新執行這個任務的時候,就直接調用這個函數。它的英語名字callback,直譯過來就是"重新調用"。 讀取文件進行處理,是這樣寫的。 ~~~ fs.readFile('/etc/passwd', function (err, data) { if (err) throw err; console.log(data); }); ~~~ 上面代碼中,readFile函數的第二個參數,就是回調函數,也就是任務的第二段。等到操作系統返回了`/etc/passwd`這個文件以后,回調函數才會執行。 一個有趣的問題是,為什么Node.js約定,回調函數的第一個參數,必須是錯誤對象err(如果沒有錯誤,該參數就是null)?原因是執行分成兩段,在這兩段之間拋出的錯誤,程序無法捕捉,只能當作參數,傳入第二段。 ### Promise 回調函數本身并沒有問題,它的問題出現在多個回調函數嵌套。假定讀取A文件之后,再讀取B文件,代碼如下。 ~~~ fs.readFile(fileA, function (err, data) { fs.readFile(fileB, function (err, data) { // ... }); }); ~~~ 不難想象,如果依次讀取多個文件,就會出現多重嵌套。代碼不是縱向發展,而是橫向發展,很快就會亂成一團,無法管理。這種情況就稱為"回調函數噩夢"(callback hell)。 Promise就是為了解決這個問題而提出的。它不是新的語法功能,而是一種新的寫法,允許將回調函數的嵌套,改成鏈式調用。采用Promise,連續讀取多個文件,寫法如下。 ~~~ var readFile = require('fs-readfile-promise'); readFile(fileA) .then(function(data){ console.log(data.toString()); }) .then(function(){ return readFile(fileB); }) .then(function(data){ console.log(data.toString()); }) .catch(function(err) { console.log(err); }); ~~~ 上面代碼中,我使用了fs-readfile-promise模塊,它的作用就是返回一個Promise版本的readFile函數。Promise提供then方法加載回調函數,catch方法捕捉執行過程中拋出的錯誤。 可以看到,Promise 的寫法只是回調函數的改進,使用then方法以后,異步任務的兩段執行看得更清楚了,除此以外,并無新意。 Promise 的最大問題是代碼冗余,原來的任務被Promise 包裝了一下,不管什么操作,一眼看去都是一堆 then,原來的語義變得很不清楚。 那么,有沒有更好的寫法呢? ## Generator函數 ### 協程 傳統的編程語言,早有異步編程的解決方案(其實是多任務的解決方案)。其中有一種叫做"協程"(coroutine),意思是多個線程互相協作,完成異步任務。 協程有點像函數,又有點像線程。它的運行流程大致如下。 * 第一步,協程A開始執行。 * 第二步,協程A執行到一半,進入暫停,執行權轉移到協程B。 * 第三步,(一段時間后)協程B交還執行權。 * 第四步,協程A恢復執行。 上面流程的協程A,就是異步任務,因為它分成兩段(或多段)執行。 舉例來說,讀取文件的協程寫法如下。 ~~~ function *asyncJob() { // ...其他代碼 var f = yield readFile(fileA); // ...其他代碼 } ~~~ 上面代碼的函數`asyncJob`是一個協程,它的奧妙就在其中的`yield`命令。它表示執行到此處,執行權將交給其他協程。也就是說,`yield`命令是異步兩個階段的分界線。 協程遇到`yield`命令就暫停,等到執行權返回,再從暫停的地方繼續往后執行。它的最大優點,就是代碼的寫法非常像同步操作,如果去除yield命令,簡直一模一樣。 ### Generator函數的概念 Generator函數是協程在ES6的實現,最大特點就是可以交出函數的執行權(即暫停執行)。 整個Generator函數就是一個封裝的異步任務,或者說是異步任務的容器。異步操作需要暫停的地方,都用`yield`語句注明。Generator函數的執行方法如下。 ~~~ function* gen(x){ var y = yield x + 2; return y; } var g = gen(1); g.next() // { value: 3, done: false } g.next() // { value: undefined, done: true } ~~~ 上面代碼中,調用Generator函數,會返回一個內部指針(即遍歷器)g 。這是Generator函數不同于普通函數的另一個地方,即執行它不會返回結果,返回的是指針對象。調用指針g的next方法,會移動內部指針(即執行異步任務的第一段),指向第一個遇到的yield語句,上例是執行到`x + 2`為止。 換言之,next方法的作用是分階段執行Generator函數。每次調用next方法,會返回一個對象,表示當前階段的信息(value屬性和done屬性)。value屬性是yield語句后面表達式的值,表示當前階段的值;done屬性是一個布爾值,表示Generator函數是否執行完畢,即是否還有下一個階段。 ### Generator函數的數據交換和錯誤處理 Generator函數可以暫停執行和恢復執行,這是它能封裝異步任務的根本原因。除此之外,它還有兩個特性,使它可以作為異步編程的完整解決方案:函數體內外的數據交換和錯誤處理機制。 next方法返回值的value屬性,是Generator函數向外輸出數據;next方法還可以接受參數,這是向Generator函數體內輸入數據。 ~~~ function* gen(x){ var y = yield x + 2; return y; } var g = gen(1); g.next() // { value: 3, done: false } g.next(2) // { value: 2, done: true } ~~~ 上面代碼中,第一個next方法的value屬性,返回表達式`x + 2`的值(3)。第二個next方法帶有參數2,這個參數可以傳入 Generator 函數,作為上個階段異步任務的返回結果,被函數體內的變量y接收。因此,這一步的 value 屬性,返回的就是2(變量y的值)。 Generator 函數內部還可以部署錯誤處理代碼,捕獲函數體外拋出的錯誤。 ~~~ function* gen(x){ try { var y = yield x + 2; } catch (e){ console.log(e); } return y; } var g = gen(1); g.next(); g.throw('出錯了'); // 出錯了 ~~~ 上面代碼的最后一行,Generator函數體外,使用指針對象的throw方法拋出的錯誤,可以被函數體內的try ...catch代碼塊捕獲。這意味著,出錯的代碼與處理錯誤的代碼,實現了時間和空間上的分離,這對于異步編程無疑是很重要的。 ### 異步任務的封裝 下面看看如何使用 Generator 函數,執行一個真實的異步任務。 ~~~ var fetch = require('node-fetch'); function* gen(){ var url = 'https://api.github.com/users/github'; var result = yield fetch(url); console.log(result.bio); } ~~~ 上面代碼中,Generator函數封裝了一個異步操作,該操作先讀取一個遠程接口,然后從JSON格式的數據解析信息。就像前面說過的,這段代碼非常像同步操作,除了加上了yield命令。 執行這段代碼的方法如下。 ~~~ var g = gen(); var result = g.next(); result.value.then(function(data){ return data.json(); }).then(function(data){ g.next(data); }); ~~~ 上面代碼中,首先執行Generator函數,獲取遍歷器對象,然后使用next 方法(第二行),執行異步任務的第一階段。由于Fetch模塊返回的是一個Promise對象,因此要用then方法調用下一個next 方法。 可以看到,雖然 Generator 函數將異步操作表示得很簡潔,但是流程管理卻不方便(即何時執行第一階段、何時執行第二階段)。 ## Thunk函數 ### 參數的求值策略 Thunk函數早在上個世紀60年代就誕生了。 那時,編程語言剛剛起步,計算機學家還在研究,編譯器怎么寫比較好。一個爭論的焦點是"求值策略",即函數的參數到底應該何時求值。 ~~~ var x = 1; function f(m){ return m * 2; } f(x + 5) ~~~ 上面代碼先定義函數f,然后向它傳入表達式`x + 5`。請問,這個表達式應該何時求值? 一種意見是"傳值調用"(call by value),即在進入函數體之前,就計算`x + 5`的值(等于6),再將這個值傳入函數f 。C語言就采用這種策略。 ~~~ f(x + 5) // 傳值調用時,等同于 f(6) ~~~ 另一種意見是"傳名調用"(call by name),即直接將表達式`x + 5`傳入函數體,只在用到它的時候求值。Haskell語言采用這種策略。 ~~~ f(x + 5) // 傳名調用時,等同于 (x + 5) * 2 ~~~ 傳值調用和傳名調用,哪一種比較好?回答是各有利弊。傳值調用比較簡單,但是對參數求值的時候,實際上還沒用到這個參數,有可能造成性能損失。 ~~~ function f(a, b){ return b; } f(3 * x * x - 2 * x - 1, x); ~~~ 上面代碼中,函數f的第一個參數是一個復雜的表達式,但是函數體內根本沒用到。對這個參數求值,實際上是不必要的。因此,有一些計算機學家傾向于"傳名調用",即只在執行時求值。 ### Thunk函數的含義 編譯器的"傳名調用"實現,往往是將參數放到一個臨時函數之中,再將這個臨時函數傳入函數體。這個臨時函數就叫做Thunk函數。 ~~~ function f(m){ return m * 2; } f(x + 5); // 等同于 var thunk = function () { return x + 5; }; function f(thunk){ return thunk() * 2; } ~~~ 上面代碼中,函數f的參數`x + 5`被一個函數替換了。凡是用到原參數的地方,對`Thunk`函數求值即可。 這就是Thunk函數的定義,它是"傳名調用"的一種實現策略,用來替換某個表達式。 ### JavaScript語言的Thunk函數 JavaScript語言是傳值調用,它的Thunk函數含義有所不同。在JavaScript語言中,Thunk函數替換的不是表達式,而是多參數函數,將其替換成單參數的版本,且只接受回調函數作為參數。 ~~~ // 正常版本的readFile(多參數版本) fs.readFile(fileName, callback); // Thunk版本的readFile(單參數版本) var readFileThunk = Thunk(fileName); readFileThunk(callback); var Thunk = function (fileName){ return function (callback){ return fs.readFile(fileName, callback); }; }; ~~~ 上面代碼中,fs模塊的readFile方法是一個多參數函數,兩個參數分別為文件名和回調函數。經過轉換器處理,它變成了一個單參數函數,只接受回調函數作為參數。這個單參數版本,就叫做Thunk函數。 任何函數,只要參數有回調函數,就能寫成Thunk函數的形式。下面是一個簡單的Thunk函數轉換器。 ~~~ // ES5版本 var Thunk = function(fn){ return function (){ var args = Array.prototype.slice.call(arguments); return function (callback){ args.push(callback); return fn.apply(this, args); } }; }; // ES6版本 var Thunk = function(fn) { return function (...args) { return function (callback) { return fn.call(this, ...args, callback); } }; }; ~~~ 使用上面的轉換器,生成`fs.readFile`的Thunk函數。 ~~~ var readFileThunk = Thunk(fs.readFile); readFileThunk(fileA)(callback); ~~~ 下面是另一個完整的例子。 ~~~ function f(a, cb) { cb(a); } let ft = Thunk(f); let log = console.log.bind(console); ft(1)(log) // 1 ~~~ ### Thunkify模塊 生產環境的轉換器,建議使用Thunkify模塊。 首先是安裝。 ~~~ $ npm install thunkify ~~~ 使用方式如下。 ~~~ var thunkify = require('thunkify'); var fs = require('fs'); var read = thunkify(fs.readFile); read('package.json')(function(err, str){ // ... }); ~~~ Thunkify的源碼與上一節那個簡單的轉換器非常像。 ~~~ function thunkify(fn){ return function(){ var args = new Array(arguments.length); var ctx = this; for(var i = 0; i < args.length; ++i) { args[i] = arguments[i]; } return function(done){ var called; args.push(function(){ if (called) return; called = true; done.apply(null, arguments); }); try { fn.apply(ctx, args); } catch (err) { done(err); } } } }; ~~~ 它的源碼主要多了一個檢查機制,變量`called`確保回調函數只運行一次。這樣的設計與下文的Generator函數相關。請看下面的例子。 ~~~ function f(a, b, callback){ var sum = a + b; callback(sum); callback(sum); } var ft = thunkify(f); var print = console.log.bind(console); ft(1, 2)(print); // 3 ~~~ 上面代碼中,由于`thunkify`只允許回調函數執行一次,所以只輸出一行結果。 ### Generator 函數的流程管理 你可能會問, Thunk函數有什么用?回答是以前確實沒什么用,但是ES6有了Generator函數,Thunk函數現在可以用于Generator函數的自動流程管理。 Generator函數可以自動執行。 ~~~ function* gen() { // ... } var g = gen(); var res = g.next(); while(!res.done){ console.log(res.value); res = g.next(); } ~~~ 上面代碼中,Generator函數`gen`會自動執行完所有步驟。 但是,這不適合異步操作。如果必須保證前一步執行完,才能執行后一步,上面的自動執行就不可行。這時,Thunk函數就能派上用處。以讀取文件為例。下面的Generator函數封裝了兩個異步操作。 ~~~ var fs = require('fs'); var thunkify = require('thunkify'); var readFile = thunkify(fs.readFile); var gen = function* (){ var r1 = yield readFile('/etc/fstab'); console.log(r1.toString()); var r2 = yield readFile('/etc/shells'); console.log(r2.toString()); }; ~~~ 上面代碼中,yield命令用于將程序的執行權移出Generator函數,那么就需要一種方法,將執行權再交還給Generator函數。 這種方法就是Thunk函數,因為它可以在回調函數里,將執行權交還給Generator函數。為了便于理解,我們先看如何手動執行上面這個Generator函數。 ~~~ var g = gen(); var r1 = g.next(); r1.value(function(err, data){ if (err) throw err; var r2 = g.next(data); r2.value(function(err, data){ if (err) throw err; g.next(data); }); }); ~~~ 上面代碼中,變量g是Generator函數的內部指針,表示目前執行到哪一步。next方法負責將指針移動到下一步,并返回該步的信息(value屬性和done屬性)。 仔細查看上面的代碼,可以發現Generator函數的執行過程,其實是將同一個回調函數,反復傳入next方法的value屬性。這使得我們可以用遞歸來自動完成這個過程。 ### Thunk函數的自動流程管理 Thunk函數真正的威力,在于可以自動執行Generator函數。下面就是一個基于Thunk函數的Generator執行器。 ~~~ function run(fn) { var gen = fn(); function next(err, data) { var result = gen.next(data); if (result.done) return; result.value(next); } next(); } function* g() { // ... } run(g); ~~~ 上面代碼的`run`函數,就是一個Generator函數的自動執行器。內部的`next`函數就是Thunk的回調函數。`next`函數先將指針移到Generator函數的下一步(`gen.next`方法),然后判斷Generator函數是否結束(`result.done`屬性),如果沒結束,就將`next`函數再傳入Thunk函數(`result.value`屬性),否則就直接退出。 有了這個執行器,執行Generator函數方便多了。不管內部有多少個異步操作,直接把Generator函數傳入`run`函數即可。當然,前提是每一個異步操作,都要是Thunk函數,也就是說,跟在`yield`命令后面的必須是Thunk函數。 ~~~ var g = function* (){ var f1 = yield readFile('fileA'); var f2 = yield readFile('fileB'); // ... var fn = yield readFile('fileN'); }; run(g); ~~~ 上面代碼中,函數`g`封裝了`n`個異步的讀取文件操作,只要執行`run`函數,這些操作就會自動完成。這樣一來,異步操作不僅可以寫得像同步操作,而且一行代碼就可以執行。 Thunk函數并不是Generator函數自動執行的唯一方案。因為自動執行的關鍵是,必須有一種機制,自動控制Generator函數的流程,接收和交還程序的執行權。回調函數可以做到這一點,Promise 對象也可以做到這一點。 ## co模塊 ### 基本用法 [co模塊](https://github.com/tj/co)是著名程序員TJ Holowaychuk于2013年6月發布的一個小工具,用于Generator函數的自動執行。 比如,有一個Generator函數,用于依次讀取兩個文件。 ~~~ var gen = function* (){ var f1 = yield readFile('/etc/fstab'); var f2 = yield readFile('/etc/shells'); console.log(f1.toString()); console.log(f2.toString()); }; ~~~ co模塊可以讓你不用編寫Generator函數的執行器。 ~~~ var co = require('co'); co(gen); ~~~ 上面代碼中,Generator函數只要傳入co函數,就會自動執行。 co函數返回一個Promise對象,因此可以用then方法添加回調函數。 ~~~ co(gen).then(function (){ console.log('Generator 函數執行完成'); }); ~~~ 上面代碼中,等到Generator函數執行結束,就會輸出一行提示。 ### co模塊的原理 為什么co可以自動執行Generator函數? 前面說過,Generator就是一個異步操作的容器。它的自動執行需要一種機制,當異步操作有了結果,能夠自動交回執行權。 兩種方法可以做到這一點。 (1)回調函數。將異步操作包裝成Thunk函數,在回調函數里面交回執行權。 (2)Promise 對象。將異步操作包裝成Promise對象,用then方法交回執行權。 co模塊其實就是將兩種自動執行器(Thunk函數和Promise對象),包裝成一個模塊。使用co的前提條件是,Generator函數的yield命令后面,只能是Thunk函數或Promise對象。 上一節已經介紹了基于Thunk函數的自動執行器。下面來看,基于Promise對象的自動執行器。這是理解co模塊必須的。 ### 基于Promise對象的自動執行 還是沿用上面的例子。首先,把fs模塊的readFile方法包裝成一個Promise對象。 ~~~ var fs = require('fs'); var readFile = function (fileName){ return new Promise(function (resolve, reject){ fs.readFile(fileName, function(error, data){ if (error) return reject(error); resolve(data); }); }); }; var gen = function* (){ var f1 = yield readFile('/etc/fstab'); var f2 = yield readFile('/etc/shells'); console.log(f1.toString()); console.log(f2.toString()); }; ~~~ 然后,手動執行上面的Generator函數。 ~~~ var g = gen(); g.next().value.then(function(data){ g.next(data).value.then(function(data){ g.next(data); }); }); ~~~ 手動執行其實就是用then方法,層層添加回調函數。理解了這一點,就可以寫出一個自動執行器。 ~~~ function run(gen){ var g = gen(); function next(data){ var result = g.next(data); if (result.done) return result.value; result.value.then(function(data){ next(data); }); } next(); } run(gen); ~~~ 上面代碼中,只要Generator函數還沒執行到最后一步,next函數就調用自身,以此實現自動執行。 ### co模塊的源碼 co就是上面那個自動執行器的擴展,它的源碼只有幾十行,非常簡單。 首先,co函數接受Generator函數作為參數,返回一個 Promise 對象。 ~~~ function co(gen) { var ctx = this; return new Promise(function(resolve, reject) { }); } ~~~ 在返回的Promise對象里面,co先檢查參數gen是否為Generator函數。如果是,就執行該函數,得到一個內部指針對象;如果不是就返回,并將Promise對象的狀態改為resolved。 ~~~ function co(gen) { var ctx = this; return new Promise(function(resolve, reject) { if (typeof gen === 'function') gen = gen.call(ctx); if (!gen || typeof gen.next !== 'function') return resolve(gen); }); } ~~~ 接著,co將Generator函數的內部指針對象的next方法,包裝成onFulfilled函數。這主要是為了能夠捕捉拋出的錯誤。 ~~~ function co(gen) { var ctx = this; return new Promise(function(resolve, reject) { if (typeof gen === 'function') gen = gen.call(ctx); if (!gen || typeof gen.next !== 'function') return resolve(gen); onFulfilled(); function onFulfilled(res) { var ret; try { ret = gen.next(res); } catch (e) { return reject(e); } next(ret); } }); } ~~~ 最后,就是關鍵的next函數,它會反復調用自身。 ~~~ function next(ret) { if (ret.done) return resolve(ret.value); var value = toPromise.call(ctx, ret.value); if (value && isPromise(value)) return value.then(onFulfilled, onRejected); return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, ' + 'but the following object was passed: "' + String(ret.value) + '"')); } ~~~ 上面代碼中,next 函數的內部代碼,一共只有四行命令。 第一行,檢查當前是否為 Generator 函數的最后一步,如果是就返回。 第二行,確保每一步的返回值,是 Promise 對象。 第三行,使用 then 方法,為返回值加上回調函數,然后通過 onFulfilled 函數再次調用 next 函數。 第四行,在參數不符合要求的情況下(參數非 Thunk 函數和 Promise 對象),將 Promise 對象的狀態改為 rejected,從而終止執行。 ### 處理并發的異步操作 co支持并發的異步操作,即允許某些操作同時進行,等到它們全部完成,才進行下一步。 這時,要把并發的操作都放在數組或對象里面,跟在yield語句后面。 ~~~ // 數組的寫法 co(function* () { var res = yield [ Promise.resolve(1), Promise.resolve(2) ]; console.log(res); }).catch(onerror); // 對象的寫法 co(function* () { var res = yield { 1: Promise.resolve(1), 2: Promise.resolve(2), }; console.log(res); }).catch(onerror); ~~~ 下面是另一個例子。 ~~~ co(function* () { var values = [n1, n2, n3]; yield values.map(somethingAsync); }); function* somethingAsync(x) { // do something async return y } ~~~ 上面的代碼允許并發三個`somethingAsync`異步操作,等到它們全部完成,才會進行下一步。 ## async函數 ### 含義 ES7提供了`async`函數,使得異步操作變得更加方便。`async`函數是什么?一句話,`async`函數就是Generator函數的語法糖。 前文有一個Generator函數,依次讀取兩個文件。 ~~~ var fs = require('fs'); var readFile = function (fileName) { return new Promise(function (resolve, reject) { fs.readFile(fileName, function(error, data) { if (error) reject(error); resolve(data); }); }); }; var gen = function* (){ var f1 = yield readFile('/etc/fstab'); var f2 = yield readFile('/etc/shells'); console.log(f1.toString()); console.log(f2.toString()); }; ~~~ 寫成`async`函數,就是下面這樣。 ~~~ var asyncReadFile = async function (){ var f1 = await readFile('/etc/fstab'); var f2 = await readFile('/etc/shells'); console.log(f1.toString()); console.log(f2.toString()); }; ~~~ 一比較就會發現,`async`函數就是將Generator函數的星號(`*`)替換成`async`,將`yield`替換成`await`,僅此而已。 `async`函數對 Generator 函數的改進,體現在以下四點。 (1)內置執行器。Generator函數的執行必須靠執行器,所以才有了`co`模塊,而`async`函數自帶執行器。也就是說,`async`函數的執行,與普通函數一模一樣,只要一行。 ~~~ var result = asyncReadFile(); ~~~ 上面的代碼調用了`asyncReadFile`函數,然后它就會自動執行,輸出最后結果。這完全不像Generator函數,需要調用`next`方法,或者用`co`模塊,才能得到真正執行,得到最后結果。 (2)更好的語義。`async`和`await`,比起星號和`yield`,語義更清楚了。`async`表示函數里有異步操作,`await`表示緊跟在后面的表達式需要等待結果。 (3)更廣的適用性。?`co`模塊約定,`yield`命令后面只能是Thunk函數或Promise對象,而`async`函數的`await`命令后面,可以是Promise對象和原始類型的值(數值、字符串和布爾值,但這時等同于同步操作)。 (4)返回值是Promise。`async`函數的返回值是Promise對象,這比Generator函數的返回值是Iterator對象方便多了。你可以用`then`方法指定下一步的操作。 進一步說,`async`函數完全可以看作多個異步操作,包裝成的一個Promise對象,而`await`命令就是內部`then`命令的語法糖。 ### 語法 `async`函數的語法規則總體上比較簡單,難點是錯誤處理機制。 (1)`async`函數返回一個Promise對象。 `async`函數內部`return`語句返回的值,會成為`then`方法回調函數的參數。 ~~~ async function f() { return 'hello world'; } f().then(v => console.log(v)) // "hello world" ~~~ 上面代碼中,函數`f`內部`return`命令返回的值,會被`then`方法回調函數接收到。 `async`函數內部拋出錯誤,會導致返回的Promise對象變為`reject`狀態。拋出的錯誤對象會被`catch`方法回調函數接收到。 ~~~ async function f() { throw new Error('出錯了'); } f().then( v => console.log(v), e => console.log(e) ) // Error: 出錯了 ~~~ (2)`async`函數返回的Promise對象,必須等到內部所有`await`命令的Promise對象執行完,才會發生狀態改變。也就是說,只有`async`函數內部的異步操作執行完,才會執行`then`方法指定的回調函數。 下面是一個例子。 ~~~ async function getTitle(url) { let response = await fetch(url); let html = await response.text(); return html.match(/<title>([\s\S]+)<\/title>/i)[1]; } getTitle('https://tc39.github.io/ecma262/').then(console.log) // "ECMAScript 2017 Language Specification" ~~~ (3)正常情況下,`await`命令后面是一個Promise對象。如果不是,會被轉成一個立即`resolve`的Promise對象。 ~~~ async function f() { return await 123; } f().then(v => console.log(v)) // 123 ~~~ 上面代碼中,`await`命令的參數是數值`123`,它被轉成Promise對象,并立即`resolve`。 `await`命令后面的Promise對象如果變為`reject`狀態,則`reject`的參數會被`catch`方法的回調函數接收到。 ~~~ async function f() { await Promise.reject('出錯了'); } f() .then(v => console.log(v)) .catch(e => console.log(e)) // 出錯了 ~~~ 注意,上面代碼中,`await`語句前面沒有`return`,但是`reject`方法的參數依然傳入了`catch`方法的回調函數。這里如果在`await`前面加上`return`,效果是一樣的。 只要一個`await`語句后面的Promise變為`reject`,那么整個`async`函數都會中斷執行。 ~~~ async function f() { await Promise.reject('出錯了'); await Promise.resolve('hello world'); // 不會執行 } ~~~ 上面代碼中,第二個`await`語句是不會執行的,因為第一個`await`語句狀態變成了`reject`。 為了避免這個問題,可以將第一個`await`放在`try...catch`結構里面,這樣第二個`await`就會執行。 ~~~ async function f() { try { await Promise.reject('出錯了'); } catch(e) { } return await Promise.resolve('hello world'); } f() .then(v => console.log(v)) // hello world ~~~ 另一種方法是`await`后面的Promise對象再跟一個`catch`方面,處理前面可能出現的錯誤。 ~~~ async function f() { await Promise.reject('出錯了') .catch(e => console.log(e)); return await Promise.resolve('hello world'); } f() .then(v => console.log(v)) // 出錯了 // hello world ~~~ 如果有多個`await`命令,可以統一放在`try...catch`結構中。 ~~~ async function main() { try { var val1 = await firstStep(); var val2 = await secondStep(val1); var val3 = await thirdStep(val1, val2); console.log('Final: ', val3); } catch (err) { console.error(err); } } ~~~ (4)如果`await`后面的異步操作出錯,那么等同于`async`函數返回的Promise對象被`reject`。 ~~~ async function f() { await new Promise(function (resolve, reject) { throw new Error('出錯了'); }); } f() .then(v => console.log(v)) .catch(e => console.log(e)) // Error:出錯了 ~~~ 上面代碼中,`async`函數`f`執行后,`await`后面的Promise對象會拋出一個錯誤對象,導致`catch`方法的回調函數被調用,它的參數就是拋出的錯誤對象。具體的執行機制,可以參考后文的“async函數的實現”。 防止出錯的方法,也是將其放在`try...catch`代碼塊之中。 ~~~ async function f() { try { await new Promise(function (resolve, reject) { throw new Error('出錯了'); }); } catch(e) { } return await('hello world'); } ~~~ ### async函數的實現 async 函數的實現,就是將 Generator 函數和自動執行器,包裝在一個函數里。 ~~~ async function fn(args){ // ... } // 等同于 function fn(args){ return spawn(function*() { // ... }); } ~~~ 所有的`async`函數都可以寫成上面的第二種形式,其中的 spawn 函數就是自動執行器。 下面給出`spawn`函數的實現,基本就是前文自動執行器的翻版。 ~~~ function spawn(genF) { return new Promise(function(resolve, reject) { var gen = genF(); function step(nextF) { try { var next = nextF(); } catch(e) { return reject(e); } if(next.done) { return resolve(next.value); } Promise.resolve(next.value).then(function(v) { step(function() { return gen.next(v); }); }, function(e) { step(function() { return gen.throw(e); }); }); } step(function() { return gen.next(undefined); }); }); } ~~~ `async`函數是非常新的語法功能,新到都不屬于 ES6,而是屬于 ES7。目前,它仍處于提案階段,但是轉碼器`Babel`和`regenerator`都已經支持,轉碼后就能使用。 ### async 函數的用法 `async`函數返回一個Promise對象,可以使用`then`方法添加回調函數。當函數執行的時候,一旦遇到`await`就會先返回,等到觸發的異步操作完成,再接著執行函數體內后面的語句。 下面是一個例子。 ~~~ async function getStockPriceByName(name) { var symbol = await getStockSymbol(name); var stockPrice = await getStockPrice(symbol); return stockPrice; } getStockPriceByName('goog').then(function (result) { console.log(result); }); ~~~ 上面代碼是一個獲取股票報價的函數,函數前面的`async`關鍵字,表明該函數內部有異步操作。調用該函數時,會立即返回一個`Promise`對象。 下面的例子,指定多少毫秒后輸出一個值。 ~~~ function timeout(ms) { return new Promise((resolve) => { setTimeout(resolve, ms); }); } async function asyncPrint(value, ms) { await timeout(ms); console.log(value) } asyncPrint('hello world', 50); ~~~ 上面代碼指定50毫秒以后,輸出"hello world"。 Async函數有多種使用形式。 ~~~ // 函數聲明 async function foo() {} // 函數表達式 const foo = async function () {}; // 對象的方法 let obj = { async foo() {} }; // 箭頭函數 const foo = async () => {}; ~~~ ### 注意點 第一點,`await`命令后面的Promise對象,運行結果可能是rejected,所以最好把`await`命令放在`try...catch`代碼塊中。 ~~~ async function myFunction() { try { await somethingThatReturnsAPromise(); } catch (err) { console.log(err); } } // 另一種寫法 async function myFunction() { await somethingThatReturnsAPromise() .catch(function (err) { console.log(err); }; } ~~~ 第二點,多個`await`命令后面的異步操作,如果不存在繼發關系,最好讓它們同時觸發。 ~~~ let foo = await getFoo(); let bar = await getBar(); ~~~ 上面代碼中,`getFoo`和`getBar`是兩個獨立的異步操作(即互不依賴),被寫成繼發關系。這樣比較耗時,因為只有`getFoo`完成以后,才會執行`getBar`,完全可以讓它們同時觸發。 ~~~ // 寫法一 let [foo, bar] = await Promise.all([getFoo(), getBar()]); // 寫法二 let fooPromise = getFoo(); let barPromise = getBar(); let foo = await fooPromise; let bar = await barPromise; ~~~ 上面兩種寫法,`getFoo`和`getBar`都是同時觸發,這樣就會縮短程序的執行時間。 第三點,`await`命令只能用在`async`函數之中,如果用在普通函數,就會報錯。 ~~~ async function dbFuc(db) { let docs = [{}, {}, {}]; // 報錯 docs.forEach(function (doc) { await db.post(doc); }); } ~~~ 上面代碼會報錯,因為await用在普通函數之中了。但是,如果將`forEach`方法的參數改成`async`函數,也有問題。 ~~~ async function dbFuc(db) { let docs = [{}, {}, {}]; // 可能得到錯誤結果 docs.forEach(async function (doc) { await db.post(doc); }); } ~~~ 上面代碼可能不會正常工作,原因是這時三個`db.post`操作將是并發執行,也就是同時執行,而不是繼發執行。正確的寫法是采用`for`循環。 ~~~ async function dbFuc(db) { let docs = [{}, {}, {}]; for (let doc of docs) { await db.post(doc); } } ~~~ 如果確實希望多個請求并發執行,可以使用`Promise.all`方法。 ~~~ async function dbFuc(db) { let docs = [{}, {}, {}]; let promises = docs.map((doc) => db.post(doc)); let results = await Promise.all(promises); console.log(results); } // 或者使用下面的寫法 async function dbFuc(db) { let docs = [{}, {}, {}]; let promises = docs.map((doc) => db.post(doc)); let results = []; for (let promise of promises) { results.push(await promise); } console.log(results); } ~~~ ES6將`await`增加為保留字。使用這個詞作為標識符,在ES5是合法的,在ES6將拋出SyntaxError。 ### 與Promise、Generator的比較 我們通過一個例子,來看Async函數與Promise、Generator函數的區別。 假定某個DOM元素上面,部署了一系列的動畫,前一個動畫結束,才能開始后一個。如果當中有一個動畫出錯,就不再往下執行,返回上一個成功執行的動畫的返回值。 首先是Promise的寫法。 ~~~ function chainAnimationsPromise(elem, animations) { // 變量ret用來保存上一個動畫的返回值 var ret = null; // 新建一個空的Promise var p = Promise.resolve(); // 使用then方法,添加所有動畫 for(var anim of animations) { p = p.then(function(val) { ret = val; return anim(elem); }); } // 返回一個部署了錯誤捕捉機制的Promise return p.catch(function(e) { /* 忽略錯誤,繼續執行 */ }).then(function() { return ret; }); } ~~~ 雖然Promise的寫法比回調函數的寫法大大改進,但是一眼看上去,代碼完全都是Promise的API(then、catch等等),操作本身的語義反而不容易看出來。 接著是Generator函數的寫法。 ~~~ function chainAnimationsGenerator(elem, animations) { return spawn(function*() { var ret = null; try { for(var anim of animations) { ret = yield anim(elem); } } catch(e) { /* 忽略錯誤,繼續執行 */ } return ret; }); } ~~~ 上面代碼使用Generator函數遍歷了每個動畫,語義比Promise寫法更清晰,用戶定義的操作全部都出現在spawn函數的內部。這個寫法的問題在于,必須有一個任務運行器,自動執行Generator函數,上面代碼的spawn函數就是自動執行器,它返回一個Promise對象,而且必須保證yield語句后面的表達式,必須返回一個Promise。 最后是Async函數的寫法。 ~~~ async function chainAnimationsAsync(elem, animations) { var ret = null; try { for(var anim of animations) { ret = await anim(elem); } } catch(e) { /* 忽略錯誤,繼續執行 */ } return ret; } ~~~ 可以看到Async函數的實現最簡潔,最符合語義,幾乎沒有語義不相關的代碼。它將Generator寫法中的自動執行器,改在語言層面提供,不暴露給用戶,因此代碼量最少。如果使用Generator寫法,自動執行器需要用戶自己提供。
                  <ruby id="bdb3f"></ruby>

                  <p id="bdb3f"><cite id="bdb3f"></cite></p>

                    <p id="bdb3f"><cite id="bdb3f"><th id="bdb3f"></th></cite></p><p id="bdb3f"></p>
                      <p id="bdb3f"><cite id="bdb3f"></cite></p>

                        <pre id="bdb3f"></pre>
                        <pre id="bdb3f"><del id="bdb3f"><thead id="bdb3f"></thead></del></pre>

                        <ruby id="bdb3f"><mark id="bdb3f"></mark></ruby><ruby id="bdb3f"></ruby>
                        <pre id="bdb3f"><pre id="bdb3f"><mark id="bdb3f"></mark></pre></pre><output id="bdb3f"></output><p id="bdb3f"></p><p id="bdb3f"></p>

                        <pre id="bdb3f"><del id="bdb3f"><progress id="bdb3f"></progress></del></pre>

                              <ruby id="bdb3f"></ruby>

                              哎呀哎呀视频在线观看