stream.js：一個(gè)新的JavaScript數(shù)據(jù)結(jié)構(gòu)
stream.js 是一個(gè)很小、完全獨(dú)立的Javascript類庫，它為你提供了一個(gè)新的Javascript數(shù)據(jù)結(jié)構(gòu)：streams.
- <script src='stream-min.js'></script>
51CTO推薦專題：JavaScript入門
streams是什么?
Streams 是一個(gè)操作簡單的數(shù)據(jù)結(jié)構(gòu)，很像數(shù)組或鏈接表，但附加了一些非凡的能力。
它們有什么特別之處?
跟數(shù)組不一樣，streams是一個(gè)有魔法的數(shù)據(jù)結(jié)構(gòu)。它可以裝載無窮多的元素。是的，你沒聽錯(cuò)。他的這種魔力來自于具有延后(lazily)執(zhí)行的能力。這簡單的術(shù)語完全能表明它們可以加載無窮多的元素。
入門
如果你愿意花10分鐘的時(shí)間來閱讀這篇文章，你對(duì)編程的認(rèn)識(shí)有可能會(huì)被完全的改變(除非你有函數(shù)式編程的經(jīng)驗(yàn)!)。請(qǐng)稍有耐心，讓我來先介紹一下streams支持的跟數(shù)組或鏈接表很類似的基本功能操作。然后我會(huì)像你介紹一些它具有的非常有趣的特性。
Stream 是一種容器。它能容納元素。你可以使用 Stream.make 來讓一個(gè)stream加載一些元素。只需要把想要的元素當(dāng)成參數(shù)傳進(jìn)去：
- var s = Stream.make( 10, 20, 30 ); // s is now a stream containing 10, 20, and 30
足夠簡單吧，現(xiàn)在 s 是一個(gè)擁有3個(gè)元素的stream： 10, 20, and 30; 有順序的。我們可以使用s.length() 來查看這個(gè)stream的長度，用 s.item( i ) 通過索引取出里面的某個(gè)元素。你還可以通過調(diào)用 s.head() 來獲得這個(gè)stream 的第一個(gè)元素。讓我們實(shí)際操作一下：
- var s = Stream.make( 10, 20, 30 );
- console.log( s.length() ); // outputs 3
- console.log( s.head() ); // outputs 10
- console.log( s.item( 0 ) ); // exactly equivalent to the line above
- console.log( s.item( 1 ) ); // outputs 20
- console.log( s.item( 2 ) ); // outputs 30
本頁面已經(jīng)加載了這個(gè) stream.js 類庫。如果你想運(yùn)行這些例子或自己寫幾句，打開你的瀏覽器的Javascript控制臺(tái)直接運(yùn)行就行了。
我們繼續(xù)，我們也可以使用 new Stream() 或 直接使用 Stream.make() 來構(gòu)造一個(gè)空的stream。你可以使用 s.tail() 方法來獲取stream里除了頭個(gè)元素外的余下所有元素。如果你在一個(gè)空stream上調(diào)用 s.head() 或 s.tail() 方法，會(huì)拋出一個(gè)異常。你可以使用 s.empty() 來檢查一個(gè)stream是否為空，它返回 true 或 false。
- var s = Stream.make( 10, 20, 30 );
- var t = s.tail(); // returns the stream that contains two items: 20 and 30
- console.log( t.head() ); // outputs 20
- var u = t.tail(); // returns the stream that contains one item: 30
- console.log( u.head() ); // outputs 30
- var v = u.tail(); // returns the empty stream
- console.log( v.empty() ); // prints true
這樣做可以打印出一個(gè)stream里的所有元素：
- var s = Stream.make( 10, 20, 30 );
- while ( !s.empty() ) {
- console.log( s.head() );
- s = s.tail();
- }
我們有個(gè)簡單的方法來實(shí)現(xiàn)這個(gè)： s.print() 將會(huì)打印出stream里的所有元素。
用它們還能做什么?
另一個(gè)簡便的功能是 Stream.range( min, max ) 函數(shù)。它會(huì)返回一個(gè)包含有從 min 到 max 的自然數(shù)的stream。
- var s = Stream.range( 10, 20 );
- s.print(); // prints the numbers from 10 to 20
在這個(gè)stream上，你可以使用 map, filter, 和 walk 等功能。 s.map( f ) 接受一個(gè)參數(shù) f，它是一個(gè)函數(shù)， stream里的所有元素都將會(huì)被f處理一遍;它的返回值是經(jīng)過這個(gè)函數(shù)處理過的stream。所以，舉個(gè)例子，你可以用它來完成讓你的 stream 里的數(shù)字翻倍的功能：
- function doubleNumber( x ) {
- return 2 * x;
- }
- var numbers = Stream.range( 10, 15 );
- numbers.print(); // prints 10, 11, 12, 13, 14, 15
- var doubles = numbers.map( doubleNumber );
- doubles.print(); // prints 20, 22, 24, 26, 28, 30
很酷，不是嗎?相似的， s.filter( f ) 也接受一個(gè)參數(shù)f，是一個(gè)函數(shù)，stream里的所有元素都將經(jīng)過這個(gè)函數(shù)處理;它的返回值也是個(gè)stream，但只包含能讓f函數(shù)返回true的元素。所以，你可以用它來過濾到你的stream里某些特定的元素。讓我們來用這個(gè)方法在之前的stream基礎(chǔ)上構(gòu)建一個(gè)只包含奇數(shù)的新stream：
- function checkIfOdd( x ) {
- if ( x % 2 == 0 ) {
- // even number
- return false;
- }
- else {
- // odd number
- return true;
- }
- }
- var numbers = Stream.range( 10, 15 );
- numbers.print(); // prints 10, 11, 12, 13, 14, 15
- var onlyOdds = numbers.filter( checkIfOdd );
- onlyOdds.print(); // prints 11, 13, 15
很有效，不是嗎?最后的一個(gè)s.walk( f )方法，也是接受一個(gè)參數(shù)f，是一個(gè)函數(shù)，stream里的所有元素都要經(jīng)過這個(gè)函數(shù)處理，但它并不會(huì)對(duì)這個(gè)stream做任何的影響。我們打印stream里所有元素的想法有了新的實(shí)現(xiàn)方法：
- function printItem( x ) {
- console.log( 'The element is: ' + x );
- }
- var numbers = Stream.range( 10, 12 );
- // prints:
- // The element is: 10
- // The element is: 11
- // The element is: 12
- numbers.walk( printItem );
還有一個(gè)很有用的函數(shù)： s.take( n )，它返回的stream只包含原始stream里第前n個(gè)元素。當(dāng)用來截取stream時(shí)，這很有用：
- var numbers = Stream.range( 10, 100 ); // numbers 10...100
- var fewerNumbers = numbers.take( 10 ); // numbers 10...19
- fewerNumbers.print();
另外一些有用的東西：s.scale( factor ) 會(huì)用factor(因子)乘以stream里的所有元素; s.add( t ) 會(huì)讓 stream s 每個(gè)元素和stream t里對(duì)應(yīng)的元素相加，返回的是相加后的結(jié)果。讓我們來看幾個(gè)例子：
- var numbers = Stream.range( 1, 3 );
- var multiplesOfTen = numbers.scale( 10 );
- multiplesOfTen.print(); // prints 10, 20, 30
- numbers.add( multiplesOfTen ).print(); // prints 11, 22, 33
盡管我們目前看到的都是對(duì)數(shù)字進(jìn)行操作，但stream里可以裝載任何的東西：字符串，布爾值，函數(shù)，對(duì)象;甚至其它的數(shù)組或stream。然而，請(qǐng)注意一定，stream里不能裝載一些特殊的值：null 和 undefined。
想我展示你的魔力!
現(xiàn)在，讓我們來處理無窮多。你不需要往stream添加無窮多的元素。例如，在 Stream.range( low, high )這個(gè)方法中，你可以忽略掉它的第二個(gè)參數(shù)，寫成 Stream.range( low )， 這種情況下，數(shù)據(jù)沒有了上限，于是這個(gè)stream里就裝載了所有從 low 到無窮大的自然數(shù)。你也可以把low參數(shù)也忽略掉，這個(gè)參數(shù)的缺省值是 1。這種情況中， Stream.range()返回的是所有的自然數(shù)。
這需要用上你無窮多的內(nèi)存/時(shí)間/處理能力嗎?
不，不會(huì)。這是最精彩的部分。你可以運(yùn)行這些代碼，它們跑的非?？?，就像一個(gè)普通的數(shù)組。下面是一個(gè)打印從 1 到 10 的例子：
- var naturalNumbers = Stream.range(); // returns the stream containing all natural numbers from 1 and up
- var oneToTen = naturalNumbers.take( 10 ); // returns the stream containing the numbers 1...10
- oneToTen.print();
你在騙人
是的，我在騙人。關(guān)鍵是你可以把這些結(jié)構(gòu)想成無窮大，這就引入了一種新的編程范式，一種致力于簡潔的代碼，讓你的代碼比通常 的命令式編程更容易理解、更貼近自然數(shù)學(xué)的編程范式。這個(gè)Javascript類庫本身就很短小;它是按照這種編程范式設(shè)計(jì)出來的。讓我們來多用一用它; 我們構(gòu)造兩個(gè)stream，分別裝載所有的奇數(shù)和所有的偶數(shù)。
- var naturalNumbers = Stream.range(); // naturalNumbers is now 1, 2, 3, ...
- var evenNumbers = naturalNumbers.map( function ( x ) {
- return 2 * x;
- } ); // evenNumbers is now 2, 4, 6, ...
- var oddNumbers = naturalNumbers.filter( function ( x ) {
- return x % 2 != 0;
- } ); // oddNumbers is now 1, 3, 5, ...
- evenNumbers.take( 3 ).print(); // prints 2, 4, 6
- oddNumbers.take( 3 ).print(); // prints 1, 3, 5
很酷，不是嗎?我沒說大話，stream比數(shù)組的功能更強(qiáng)大?，F(xiàn)在，請(qǐng)容忍我?guī)追昼?，讓我來多介紹一點(diǎn)關(guān)于stream的事情。你可以使用 new Stream() 來創(chuàng)建一個(gè)空的stream，用 new Stream( head, functionReturningTail ) 來創(chuàng)建一個(gè)非空的stream。對(duì)于這個(gè)非空的stream，你傳入的第一個(gè)參數(shù)成為這個(gè)stream的頭元素，而第二個(gè)參數(shù)是一個(gè)函數(shù)，它返回stream的尾部(一個(gè)包含有余下所有元素的stream)，很可能是一個(gè)空的stream。困惑嗎?讓我們來看一個(gè)例子：
- var s = new Stream( 10, function () {
- return new Stream();
- } );
- // the head of the s stream is 10; the tail of the s stream is the empty stream
- s.print(); // prints 10
- var t = new Stream( 10, function () {
- return new Stream( 20, function () {
- return new Stream( 30, function () {
- return new Stream();
- } );
- } );
- } );
- // the head of the t stream is 10; its tail has a head which is 20 and a tail which
- // has a head which is 30 and a tail which is the empty stream.
- t.print(); // prints 10, 20, 30
沒事找事嗎?直接用Stream.make( 10, 20, 30 )就可以做這個(gè)。但是，請(qǐng)注意，這種方式我們可以輕松的構(gòu)建我們的無窮大stream。讓我們來做一個(gè)能夠無窮無盡的stream：
- function ones() {
- return new Stream(
- // the first element of the stream of ones is 1...
- 1,
- // and the rest of the elements of this stream are given by calling the function ones() (this same function!)
- ones
- );
- }
- var s = ones(); // now s contains 1, 1, 1, 1, ...
- s.take( 3 ).print(); // prints 1, 1, 1
請(qǐng)注意，如果你在一個(gè)無限大的stream上使用 s.print()，它會(huì)無休無止的打印下去，最終耗盡你的內(nèi)存。所以，你最好在使用s.print()前先s.take( n )。在一個(gè)無窮大的stream上使用s.length()也是無意義的，所有，不要做這些操作;它會(huì)導(dǎo)致一個(gè)無盡的循環(huán)(試圖到達(dá)一個(gè)無盡的stream的盡頭)。但是對(duì)于無窮大stream，你可以使用s.map( f ) 和 s.filter( f )。然而，s.walk( f )對(duì)于無窮大stream也是不好用。所有，有些事情你要記住; 對(duì)于無窮大的stream，一定要使用s.take( n )取出有限的部分。
讓我們看看能不能做一些更有趣的事情。還有一個(gè)有趣的能創(chuàng)建包含自然數(shù)的stream方式：
- function ones() {
- return new Stream( 1, ones );
- }
- function naturalNumbers() {
- return new Stream(
- // the natural numbers are the stream whose first element is 1...
- 1,
- function () {
- // and the rest are the natural numbers all incremented by one
- // which is obtained by adding the stream of natural numbers...
- // 1, 2, 3, 4, 5, ...
- // to the infinite stream of ones...
- // 1, 1, 1, 1, 1, ...
- // yielding...
- // 2, 3, 4, 5, 6, ...
- // which indeed are the REST of the natural numbers after one
- return ones().add( naturalNumbers() );
- }
- );
- }
- naturalNumbers().take( 5 ).print(); // prints 1, 2, 3, 4, 5
細(xì)心的讀者會(huì)發(fā)現(xiàn)為什么新構(gòu)造的stream的第二參數(shù)是一個(gè)返回尾部的函數(shù)、而不是尾部本身的原因了。這種方式可以通過延遲尾部截取的操作來防止進(jìn)行進(jìn)入無窮盡的執(zhí)行周期。
讓我們來看一個(gè)更復(fù)雜的例子。下面的是給讀者留下的一個(gè)練習(xí)，請(qǐng)指出下面這段代碼是做什么的?
- function sieve( s ) {
- var h = s.head();
- return new Stream( h, function () {
- return sieve( s.tail().filter( function( x ) {
- return x % h != 0;
- } ) );
- } );
- }
- sieve( Stream.range( 2 ) ).take( 10 ).print();
請(qǐng)一定要花些時(shí)間能清楚這段代碼的用途。除非有函數(shù)式編程經(jīng)驗(yàn)，大多數(shù)的程序員都會(huì)發(fā)現(xiàn)這段代碼很難理解，所以，如果你不能立刻看出來，不要覺 得沮喪。給你一點(diǎn)提示：找出被打印的stream的頭元素是什么。然后找出第二個(gè)元素是什么(余下的元素的頭元素);然后第三個(gè)元素，然后第四個(gè)。這個(gè)函 數(shù)的名稱也能給你一些提示。如果你對(duì)這種難題感興趣，這兒還有一些。
如果你真的想不出這段代碼是做什么的，你就運(yùn)行一下它，自己看一看!這樣你就很容易理解它是怎么做的了。
致敬
Streams 實(shí)際上不是一個(gè)新的想法。很多的函數(shù)式的編程語言都支持這種特征。所謂‘stream’是Scheme語言里的叫法，Scheme是LISP語言的一種方言。Haskell語言也支持無限大列表(list)。這些'take', 'tail', 'head', 'map' 和 'filter' 名字都來自于Haskell語言。Python和其它很多中語言中也存在雖然不同但很相似的這種概念，它們都被稱作"發(fā)生器(generators)"。
這些思想來函數(shù)式編程社區(qū)里已經(jīng)流傳了很久了。然而，對(duì)于大多數(shù)的Javascript程序員來說卻是一個(gè)很新的概念，特別是那些沒有函數(shù)式編程經(jīng)驗(yàn)的人。
這里很多的例子和創(chuàng)意都是來自Structure and Interpretation of Computer Programs這本數(shù)。如果你喜歡這些想法，我高度推薦你讀一讀它;這本書可以在網(wǎng)上免費(fèi)獲得。它也是我開發(fā)這個(gè)Javascript類庫的創(chuàng)意來源。
如果你喜歡其它語法形式的stream，你可以試一下linq.js，或者，如果你使用 node.js， node-lazy 也許更適合你。
如果你要是喜歡 CoffeeScript 的話， Michael Blume 正在把 stream.js 移植到 CoffeeScript 上，創(chuàng)造出 coffeestream。
感謝你的閱讀!
我希望你能有所收獲，并喜歡上 stream.js。這個(gè)類庫是免費(fèi)的，所以，如果你喜歡它，或它能在某方面提供了幫助，你可以考慮替我買一杯熱巧克力飲料 (我不喝咖啡) 或者 寫信給我。如果你打算這樣做，請(qǐng)寫清你是哪里人，做什么的。我很喜歡收集世界各地的圖片，所以，信中請(qǐng)附上你在你的城市里拍的照片!
原文出處：http://www.aqee.net/docs/stream/
【編輯推薦】
