stream js

時間 2019-11-06

標籤 stream 欄目 Apache 简体版

原文原文鏈接

stream.js 是一個很小、徹底獨立的Javascript類庫，它爲你提供了一個新的Javascript數據結構：streams. 程序員

<script src='stream-min.js'></script>

streams是什麼？

Streams 是一個操做簡單的數據結構，很像數組或連接表，但附加了一些非凡的能力。編程

它們有什麼特別之處？

跟數組不同，streams是一個有魔法的數據結構。它能夠裝載無窮多的元素。是的，你沒聽錯。他的這種魔力來自於具備延後(lazily)執行的能力。這簡單的術語徹底能代表它們能夠加載無窮多的元素。數組

入門

若是你願意花10分鐘的時間來閱讀這篇文章，你對編程的認識有可能會被徹底的改變(除非你有函數式編程的經驗！)。請稍有耐心，讓我來先介紹一下streams支持的跟數組或連接表很相似的基本功能操做。而後我會像你介紹一些它具備的很是有趣的特性。瀏覽器

Stream 是一種容器。它能容納元素。你可使用 Stream.make 來讓一個stream加載一些元素。只須要把想要的元素當成參數傳進去：數據結構

var s = Stream.make( 10, 20, 30 ); // s is now a stream containing 10, 20, and 30

足夠簡單吧，如今 s 是一個擁有3個元素的stream： 10, 20, and 30; 有順序的。咱們可使用 s.length() 來查看這個stream的長度，用 s.item( i ) 經過索引取出裏面的某個元素。你還能夠經過調用 s.head() 來得到這個stream 的第一個元素。讓咱們實際操做一下：函數式編程

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

本頁面已經加載了這個 stream.js 類庫。若是你想運行這些例子或本身寫幾句，打開你的瀏覽器的Javascript控制檯直接運行就好了。函數

咱們繼續，咱們也可使用 new Stream() 或直接使用 Stream.make() 來構造一個空的stream。你可使用 s.tail() 方法來獲取stream裏除了頭個元素外的餘下全部元素。若是你在一個空stream上調用 s.head() 或 s.tail() 方法，會拋出一個異常。你可使用 s.empty() 來檢查一個stream是否爲空，它返回 true 或 false。 ui

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

這樣作能夠打印出一個stream裏的全部元素： this

var s = Stream.make( 10, 20, 30 );
while ( !s.empty() ) {
console.log( s.head() );
s = s.tail();
}

咱們有個簡單的方法來實現這個： s.print() 將會打印出stream裏的全部元素。 spa

用它們還能作什麼？

另外一個簡便的功能是 Stream.range( min, max ) 函數。它會返回一個包含有從 min 到 max 的天然數的stream。

var s = Stream.range( 10, 20 );
s.print(); // prints the numbers from 10 to 20

在這個stream上，你可使用 map, filter, 和 walk 等功能。 s.map( f ) 接受一個參數 f，它是一個函數， stream裏的全部元素都將會被f處理一遍；它的返回值是通過這個函數處理過的stream。因此，舉個例子，你能夠用它來完成讓你的 stream 裏的數字翻倍的功能：

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 ) 也接受一個參數f，是一個函數，stream裏的全部元素都將通過這個函數處理；它的返回值也是個stream，但只包含能讓f函數返回true的元素。因此，你能夠用它來過濾到你的stream裏某些特定的元素。讓咱們來用這個方法在以前的stream基礎上構建一個只包含奇數的新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

頗有效，不是嗎？最後的一個s.walk( f )方法，也是接受一個參數f，是一個函數，stream裏的全部元素都要通過這個函數處理，但它並不會對這個stream作任何的影響。咱們打印stream裏全部元素的想法有了新的實現方法：

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 );

還有一個頗有用的函數： s.take( n )，它返回的stream只包含原始stream裏第前n個元素。當用來截取stream時，這頗有用：

var numbers = Stream.range( 10, 100 ); // numbers 10...100
var fewerNumbers = numbers.take( 10 ); // numbers 10...19
fewerNumbers.print();

另一些有用的東西：s.scale( factor ) 會用factor(因子)乘以stream裏的全部元素； s.add( t ) 會讓 stream s 每一個元素和stream t裏對應的元素相加，返回的是相加後的結果。讓咱們來看幾個例子：

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

儘管咱們目前看到的都是對數字進行操做，但stream裏能夠裝載任何的東西：字符串，布爾值，函數，對象；甚至其它的數組或stream。然而，請注意必定，stream裏不能裝載一些特殊的值：null 和 undefined。

想我展現你的魔力！

如今，讓咱們來處理無窮多。你不須要往stream添加無窮多的元素。例如，在Stream.range( low, high ) 這個方法中，你能夠忽略掉它的第二個參數，寫成 Stream.range( low ) ，這種狀況下，數據沒有了上限，因而這個stream裏就裝載了全部從 low 到無窮大的天然數。你也能夠把low 參數也忽略掉，這個參數的缺省值是1 。這種狀況中，Stream.range() 返回的是全部的天然數。

這須要用上你無窮多的內存/時間/處理能力嗎？

不，不會。這是最精彩的部分。你能夠運行這些代碼，它們跑的很是快，就像一個普通的數組。下面是一個打印從 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();

你在騙人

是的，我在騙人。關鍵是你能夠把這些結構想成無窮大，這就引入了一種新的編程範式，一種致力於簡潔的代碼，讓你的代碼比一般的命令式編程更容易理解、更貼近天然數學的編程範式。這個Javascript類庫自己就很短小；它是按照這種編程範式設計出來的。讓咱們來多用一用它；咱們構造兩個stream，分別裝載全部的奇數和全部的偶數。

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比數組的功能更強大。如今，請容忍我幾分鐘，讓我來多介紹一點關於stream的事情。你可使用 new Stream() 來建立一個空的stream，用 new Stream( head, functionReturningTail ) 來建立一個非空的stream。對於這個非空的stream，你傳入的第一個參數成爲這個stream的頭元素，而第二個參數是一個函數，它返回stream的尾部(一個包含有餘下全部元素的stream)，極可能是一個空的stream。困惑嗎？讓咱們來看一個例子：

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 )就能夠作這個。可是，請注意，這種方式咱們能夠輕鬆的構建咱們的無窮大stream。讓咱們來作一個可以無窮無盡的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

請注意，若是你在一個無限大的stream上使用 s.print()，它會無休無止的打印下去，最終耗盡你的內存。因此，你最好在使用s.print()前先s.take( n )。在一個無窮大的stream上使用s.length()也是無心義的，全部，不要作這些操做；它會致使一個無盡的循環(試圖到達一個無盡的stream的盡頭)。可是對於無窮大stream，你可使用s.map( f ) 和 s.filter( f )。然而，s.walk( f )對於無窮大stream也是很差用。全部，有些事情你要記住; 對於無窮大的stream，必定要使用s.take( n )取出有限的部分。

讓咱們看看能不能作一些更有趣的事情。還有一個有趣的能建立包含天然數的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

細心的讀者會發現爲何新構造的stream的第二參數是一個返回尾部的函數、而不是尾部自己的緣由了。這種方式能夠經過延遲尾部截取的操做來防止進行進入無窮盡的執行週期。

讓咱們來看一個更復雜的例子。下面的是給讀者留下的一個練習，請指出下面這段代碼是作什麼的？

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();

請必定要花些時間能清楚這段代碼的用途。除非有函數式編程經驗，大多數的程序員都會發現這段代碼很難理解，因此，若是你不能馬上看出來，不要以爲沮喪。給你一點提示：找出被打印的stream的頭元素是什麼。而後找出第二個元素是什麼(餘下的元素的頭元素)；而後第三個元素，而後第四個。這個函數的名稱也能給你一些提示。若是你對這種難題感興趣，這兒還有一些。

若是你真的想不出這段代碼是作什麼的，你就運行一下它，本身看一看！這樣你就很容易理解它是怎麼作的了。