偷偷摘套内射激情视频,久久精品99国产国产精,中文字幕无线乱码人妻,中文在线中文a,性爽19p

[譯] 快速介紹JavaScript中的CSP

開發(fā) 前端
CSP 是什么? 一般來說, 它是寫并行代碼的一套方案。在 Go 語言里自帶該功能, Clojure 通過基于 Macro 的 core.async 來實現(xiàn),現(xiàn)在 JavaScript 通過 Generator 也能做支持了, 或者說 ES6 的功能。 為什么我要關心 CSP? 因為它強大啊, 而且高效, 而且簡單.

[[171484]]

Communicating Sequential Processes 的 7 個示例

CSP 是什么? 一般來說, 它是寫并行代碼的一套方案.

在 Go 語言里自帶該功能, Clojure 通過基于 Macro 的 core.async 來實現(xiàn),

現(xiàn)在 JavaScript 通過 Generator 也能做支持了, 或者說 ES6 的功能.

為什么我要關心 CSP? 因為它強大啊, 而且高效, 而且簡單. 都這樣了你還想要什么? :)

好吧, 說細節(jié). 怎樣使用呢?我們用 js-csp, 而且需要 generator 支持, ES6 才有.

也就說 Node 4 或者更高的版本才行, 或者瀏覽器代碼用 Babel 編譯一下,

當然能其他的編譯工具可能也行, 但你要確認下是支持 Generator 的.

注: 文章寫得早, 現(xiàn)在翻譯文章, Chrome 應該是支持 Generator 的.

扯多了, 來看例子吧!

例 1: 進程

***個要學的概念是"進程". 進程可以執(zhí)行代碼, 簡單說就是這樣的了. :)

注: 當然不是操作系統(tǒng)原始的進程了, js 里模擬的.

這是啟動進程的語法: generator 函數(shù)作為參數(shù), 傳給 go 函數(shù)執(zhí)行.

  1. import {go} from 'js-csp'
  2.  
  3. go(function* () { 
  4.   console.log('something!'); 
  5. }); 
  6.  
  7. // terminal output
  8. // 
  9. // => something!  

例 2: 進程可以暫停

使用 yield 關鍵字可以暫停一個進程, 把當前進程的占用釋放:

  1. import {go, timeout} from 'js-csp'
  2.  
  3. go(function* () { 
  4.   yield timeout(1000); 
  5.   console.log('something else after 1 second!'); 
  6. }); 
  7.  
  8. console.log('something!'); 
  9.  
  10. // terminal output
  11. // 
  12. // => something! 
  13. // => something else after 1 second 

例 3: 進程等待來自管道的數(shù)據

第二個要學的概念是管道, 也是***一個了. 管道就像是隊列.

一旦進程對管道調用 take, 進程就會暫停, 直到別人往管道放進數(shù)據.

  1. import {go, chan, take, putAsync} from 'js-csp'
  2.  
  3. let ch = chan(); 
  4.  
  5. go(function* () { 
  6.   const received = yield take(ch); 
  7.   console.log('RECEIVED:', received); 
  8. }); 
  9.  
  10. const text = 'something'
  11. console.log('SENDING:', text); 
  12.  
  13. // use putAsync to put a value in a 
  14. // channel from outside a process 
  15. putAsync(ch, text); 
  16.  
  17. // terminal output
  18. // 
  19. // => SENDING: something 
  20. // => RECEIVED: something  

例 4: 進程通過管道來通信

管道的另一邊, 往管道里 put 數(shù)據的那些進程也會暫停, 直到這邊進程調用 take.

下面的例子就復雜一點了, 試著跟隨一下主線, 印證一下終端輸出的內容:

  1. import {go, chan, take, put} from 'js-csp'
  2.  
  3. let chA = chan(); 
  4. let chB = chan(); 
  5.  
  6. // Process A 
  7. go(function* () { 
  8.   const receivedFirst = yield take(chA); 
  9.   console.log('A > RECEIVED:', receivedFirst); 
  10.  
  11.   const sending = 'cat'
  12.   console.log('A > SENDING:', sending); 
  13.   yield put(chB, sending); 
  14.  
  15.   const receivedSecond = yield take(chA); 
  16.   console.log('A > RECEIVED:', receivedSecond); 
  17. }); 
  18.  
  19. // Process B 
  20. go(function* () { 
  21.   const sendingFirst = 'dog'
  22.   console.log('B > SENDING:', sendingFirst); 
  23.   yield put(chA, sendingFirst); 
  24.  
  25.   const received = yield take(chB); 
  26.   console.log('B > RECEIVED:', received); 
  27.  
  28.   const sendingSecond = 'another dog'
  29.   console.log('B > SENDING:', sendingSecond); 
  30.   yield put(chA, sendingSecond); 
  31. }); 
  32.  
  33. // terminal output
  34. // 
  35. // => B > SENDING: dog 
  36. // => A > RECEIVED: dog 
  37. // => A > SENDING: cat 
  38. // => B > RECEIVED: cat 
  39. // => B > SENDING: another dog 
  40. // => A > RECEIVED: another dog  

例5: 管道也是隊列

由于管道是隊列, 當進程從管道取走數(shù)據, 其他進程就拿不到了.所以推數(shù)據的是一個進程, 取數(shù)據的也是一個進程.

下面這個例子可以看到第二個進程永遠不會打印 B > RECEIVED: dog,

因為***個進程已經把數(shù)據取走了.

  1. import {go, chan, take, put} from 'js-csp'
  2.  
  3. let ch = chan(); 
  4.  
  5. go(function* () { 
  6.   const text = yield take(ch); 
  7.   console.log('A > RECEIVED:', text); 
  8. }); 
  9.  
  10. go(function* () { 
  11.   const text = yield take(ch); 
  12.   console.log('B > RECEIVED:', text); 
  13. }); 
  14.  
  15. go(function* () { 
  16.   const text = 'dog' 
  17.   console.log('C > SENDING:', text); 
  18.   yield put(ch, text); 
  19. }); 
  20.  
  21. // terminal output
  22. // 
  23. // => C > SENDING: dog 
  24. // => A > RECEIVED: dog  

例 6: 帶緩沖的管道不會在 put 操作時阻塞

管道可以帶緩沖, 也就是, 一定數(shù)量之內的數(shù)據, 執(zhí)行 put 操作可以避開阻塞.

這個例子里, 即便沒有其他進程調用 take, 前兩個寫操作也不會阻塞進程.

不過管道的緩存數(shù)量是 2, 所以第三個數(shù)據就阻塞進程了, 直到其他進程取走數(shù)據.

  1. import {go, chan, put, buffers} from 'js-csp'
  2.  
  3. let ch = chan(buffers.fixed(2)); 
  4.  
  5. go(function* () { 
  6.   yield put(ch, 'value A'); 
  7.   yield put(ch, 'value B'); 
  8.   console.log('I should print!'); 
  9.   yield put(ch, 'value C'); 
  10.   console.log('I should not print!'); 
  11. }); 
  12.  
  13. // terminal output
  14. // 
  15. // => I should print!  

例 7: Dropping And Sliding Buffers

固定大小的緩沖在 N 個數(shù)據之后會阻塞, 初次之外, 還有對緩沖的 dropping 和 sliding 控制.

緩沖的 dropping 以為著管道可以持有 N 個數(shù)據.再增加額外的數(shù)據放進管道, 管道就會將其丟棄.

緩沖的 sliding 也可以持有 N 個數(shù)據. 不過相對于直接丟棄新數(shù)據,sliding 緩沖原先的***個推的數(shù)據會被丟棄, buffer 里會留下新的這個數(shù)據.

下面這個例子, value B 和 value C 在 dropping 緩沖里被丟棄, 因為已經有 value A 了.

第二個進程里, 當 value B 被放進管道, value A 就被丟棄了.

然后 value C 放進管道, value B 就被丟棄.

根據它們的工作原理, dropping 和 sliding 的緩沖永遠不會阻塞!

  1. let droppingCh = chan(buffers.dropping(1)); 
  2. let slidingCh  = chan(buffers.sliding(1)); 
  3.  
  4. go(function* () { 
  5.   yield put(droppingCh, 'value A'); 
  6.   yield put(droppingCh, 'value B'); 
  7.   yield put(droppingCh, 'value C'); 
  8.   console.log('DROPPING:', yield take(droppingCh)); 
  9. }); 
  10.  
  11. go(function* () { 
  12.   yield put(slidingCh, 'value A'); 
  13.   yield put(slidingCh, 'value B'); 
  14.   yield put(slidingCh, 'value C'); 
  15.   console.log('SLIDING:', yield take(slidingCh)); 
  16. }); 
  17.  
  18. // terminal output
  19. // 
  20. // => DROPPING: value A 
  21. // => SLIDING: value C  

結論

CSP 用了一段時間之后, 用回調或者 Promise 寫代碼就像是侏羅紀的技術.

我希望 ES6 的 Generator 能幫助 CSP 成為 JavaScript 的一個標準,

就像是 Go 已經是的那樣, 以及 Clojure 里正在成為的那樣.

下一步

另外有兩個模型也還有意思, 大概可以認為是比 CSP 層級更高一點的:

函數(shù)式也是響應式編程(Rx)跟 Actors, 分別在 Rx 和 Erlang 里用到.

我當然后面也會寫博客來挖掘一下.

我同時相信 CSP 對于前端框架來說非常棒.

責任編輯:龐桂玉 來源: segmentfault
相關推薦

2011-06-21 14:25:44

JavaScriptcookie

2009-06-17 16:01:28

2021-09-02 15:24:25

Prisma JavaScript 類型安全

2020-07-12 15:34:48

JavaScript開發(fā)技術

2021-11-22 22:14:46

JavaScript開發(fā)模塊

2023-04-26 15:19:36

JavaScripMap數(shù)組

2011-05-25 11:25:23

快速排序Javascript

2020-12-29 08:09:25

JavaScript內存管理

2016-10-12 11:08:16

JavaScriptarguments數(shù)組

2012-08-03 10:30:22

JavaScript

2022-02-25 23:46:54

JavaScript網站開發(fā)

2017-04-10 10:35:02

JavaScript框架

2014-01-03 09:13:39

JavaScriptthis

2013-05-08 10:36:07

JavaScriptJS詳解JavaScrip

2009-07-14 01:00:43

WebWorkActionConte

2011-01-21 17:28:37

Zimbra

2017-01-23 09:10:06

2011-07-04 17:53:48

快速測試

2023-02-13 09:01:29

Linux驅動實例

2017-07-18 15:26:20

微服務化DevOps容器化
點贊
收藏

51CTO技術棧公眾號