rxjs入门6之兼并数据流

Author：喻城
发布时间：July 1, 2019
1423 views
关闭评论
6754 words
Categories：谈天说地

一 concat，merge，zip，combineLatest等兼并类操纵符

以上操纵符在版本6中已只存在静态要领，不克不及在pipe中应用。

import {concat,merge,zip,combineLatest}

1.concat (obs1,obs2,obs3) 首尾相连

顺次将多个observable首尾兼并，必须在第一个obs1的数据悉数完成，能力举行第二个obs2，若是第一个为interval（1000）,那末obs2 和obs3 也就永久没有时机取得输出。

concat(of(1,2,3),interval).subscribe(console.log);
// 1   2   3    0  1  2  3  ...

2.merge 先到先得疾速经由过程

merge会第⼀时刻定阅一切的上游Observable，然后对上游的数据接纳“先到先得”的战略，任何⼀个Observable只需有数据推下来，就⽴刻转给下流Observable对象。

merge(interval(1000),of(1,2,3)).subscribe(console.log);
merge(of(1,2,3),interval(1000)).subscribe(console.log);
//两种状况的输出效果一样，都是先一次性输出1 2 3  再距离一秒顺次输出0 1 2 ...

const source1$ = Observable.timer(0, 1000).map(x => x+'A');
const source2$ = Observable.timer(500, 1000).map(x => x+'B');
merge(source1$, source2$).subscribe(
console.log,
null,
() => console.log('complete')
);
//0A
//0B
//1A
//1B
//2A
//2B

merge 的应用场景：我们晓得fromEvent能够从⽹页中猎取事宜，只可惜，fromEvent⼀次只能从⼀个DOM元素猎取⼀种范例的事宜。⽐如，我们关⼼某个元素的click事宜，同时也关⼼这个元素上的touchend事宜，由于在挪动装备上touchend事宜涌现得⽐click更早，这两个事宜的处置惩罚是⼀模⼀样的，然则fromEvent不克不及同时取得两个事宜的数据流，这时候刻就要借助merge的⼒量了，代码以下：

const click$ = Rx.Observable.fromEvent(element, 'click');
const touchend$ = Rx.Observable.fromEvent(element, 'touchend');
merge(click$, touchend$).subscribe(eventHandler)

3.zip :拉链式组合

一对一的兼并

zip会把上游的数据转化为数组情势，每⼀个上游Observable孝敬的数据会在对应数组中占⼀席之地.
默许的输出花样为数组花样，可经由过程第二个参数举行参数花样组装
简而言之：不论是同步发生数据照样异步发生的数据，都邑每次顺次从须要兼并的observable中取一个数据兼并成一个数组输出，当某一个observer不再吐出数据了，则停止兼并，实行complete函数

const source1$ = Observable.of(1, 2, 3);
const source2$ = Observable.of('a', 'b', 'c');
zip(source1$, source2$).subscribe(
    console.log,
    null,
    () => console.log('complete')
);
//[ 1, 'a' ]
//[ 2, 'b' ]
//[ 3, 'c' ]
//complete

4.combineLatest:兼并末了一个数据

输出的数组中元素个数与兼并的observable的个数相称。
在兼并的observable中，只要末了一个元素为下流，前面的参数若是有同步的数据，同步数据中只要末了一个数据能进入数据流
默许的输出花样为数组花样，可经由过程第二个参数举行参数花样组装
第一次实行，当上游发生了数据，下流还没来得及发生数据时，就会守候。第二轮时刻，不论是上游或许下流发生一个数据，都邑实行输出，还没来得及发生数据的observable就输出本来发生的数据，以下弹珠图

const source1$ = Observable.timer(500, 1000);
const source2$ = Observable.timer(1000, 1000);
combineLatest(source1$,source2$).subscribe(
    console.log,
    null,
    () => console.log('complete')
);
//[ 0, 0 ]
//[ 1, 0 ]
//[ 1, 1 ]
//[ 2, 1 ]
//[ 2, 2 ]
//[ 3, 2 ]

5.withLatestFrom

withLatestFrom 为管道中应用的要领。默许的输出花样为数组花样，可经由过程第二个参数举行参数花样组装
withLatestFrom只要实例操纵符的情势，⽽且一切输⼊Observable的职位并不相同，调⽤withLatestFrom的谁人Observable对象起到主导数据产⽣节拍的作⽤，作为参数的Observable对象只能孝敬数据，不克不及掌握产⽣数据的机遇。

const source1$ = Observable.timer(0, 2000).map(x => 100 * x);
const source2$ = Observable.timer(500, 1000);
 source1$.pipe(
    withLatestFrom(source2$, (a,b)=> a+b);
).subscribe(
    console.log,
    null,
    () => console.log('complete')
);

source1$产⽣第⼀个数据0时，withLatestFrom的另⼀个输⼊Observable对象source2$还没有产⽣数据，以是这个0也被忽略了。

处理glitch
例1：

const original$ = Observable.timer(0, 1000);
const source1$ = original$.map(x => x+'a');
const source2$ = original$.map(x => x+'b');
const result$ = source1$.pipe(withLatestFrom(source2$);)
result$.subscribe(
console.log,
null,
() => console.log('complete')
);

例2：

const event$ = Rx.Observable.fromEvent(document.body, 'click');
const x$ = event$.map(e => e.x);
const y$ = event$.map(e => e.y);
const result$ = x$.pipe(combineLatest(y$, (x, y) => `x: ${x}, y: ${y}`)).subscribe(
    (location) => {
        console.log('#render', location);
        document.querySelector('#text').innerText = location;
    }
);

race :胜者通吃

race就是“合作”，多个Observable对象在⼀起，看谁最早产⽣数据，不外这类合作是⼗分严酷的，胜者通吃，败者则落空一切时机。
简而言之，经由过程race兼并多个observable时，最早吐出数据谁人observable会成为数据源，别的的observable会被镌汰。

startWith

startWith只要实例操纵符的情势，其功用是让⼀个Observable对象在被定阅的时刻，老是先吐出指定的若⼲个数据。下⾯是使⽤startWith的⽰例代码

of(0,1,2).pipe(startWith('a','b')).subscribe(console.log);
//先顺次吐出 a b 0 1 2

forkJoin

forkJoin能够接收多个Observable对象作为参数，forkJoin产⽣的Observable对象也很有特性，它只会产⽣⼀个数据，由于它会守候一切参数Observable对象的末了⼀个数据，也就是说，只要当一切Observable对象都结束，肯定不会有新的数据产⽣的时刻，forkJoin就会把一切输⼊Observable对象产⽣的末了⼀个数据兼并成给下流唯⼀的数据。
forkJoin就是RxJS界的Promise.all，Promise.all守候一切输⼊的Promise对象胜利以后把效果兼并，forkJoin守候一切输⼊的Observable对象结束以后把末了⼀个数据兼并。
返回数组情势，数组中元素个数为兼并的observable的个数
js forkJoin(interval(1000).pipe(take(3)),of(1,2,3),timer(2000,1000).pipe(take(3))).subscribe(console.log); // [2,3,2]js

高阶Observable

简言之：⾼阶函数就是产⽣函数的函数；相似，所谓⾼阶Observable，指的是产⽣的数据依然是Observable的Observable

1.concatAll

concatAll只要⼀个上游Observable对象，这个Observable对象预期是⼀个⾼阶Observable对象，concatAll会对个中的内部Observable对象做concat的操纵.

interval(1000).pipe(
    take(2),
    map(x=>interval(1500).pipe(take(2),map(x=> `${x}:x,y:${y}`))),
    concatAll()
).subscribe(console.log);
// 0:a,b:0
// 0:a,b:1
// 1:a,b:0
// 1:a,b:1

concat 现实应用

fromEvent(document.body,'mousedown').pipe(
      map(
        e=>fromEvent(document.body,'mousemove').pipe(map(e=>{return {x:e.clientX,y:e.clientY}}), takeUntil(fromEvent(document.body,'mouseup')))
      ),
      concatAll()
    ).subscribe(console.log);

mergeAll

mergeAll就是处置惩罚⾼阶Observable的merge，只是一切的输⼊Observable来⾃于上游产⽣的内部Observable对象.

interval(1000).pipe(
    take(2),
    map(x => Observable.interval(1500).map(y => x+':'+y).take(2)),
    mergeAll()
)

mergeAll只需
发明上游产⽣⼀个内部Observable就会⽴刻定阅，并从中抽取收条，以是在上图中，第⼆个内部Observable产⽣的数据1：0会涌如今第⼀个内部Observable产⽣的数据0：1之前.

zipAll

interval(1000).pipe(
    take(2),
    map(x => Observable.interval(1500).map(y => x+':'+y).take(2)),
    zipAll()
)
//[ '0:0', '1:0' ]
//[ '0:1', '1:1' ]
//complete

combineAll

combineAll就是处置惩罚⾼阶Observable的combineLatest，能够是由于combine-LatestAll太长了，以是RxJS挑选了combineAll这个名字。

interval(1000).pipe(
    take(2),
    map(x => Observable.interval(1500).map(y => x+':'+y).take(2)),
    combeneAll()
)
//[ '0:0', '1:0' ]
//[ '0:1', '1:0' ]
//[ '0:1', '1:1' ]
//complete

switchAll

switch的寄义就是“切换”，老是切换到最新的内部Observable对象猎取数据。每当switch的上游⾼阶Observable产⽣⼀个内部Observable对象，switch都邑⽴刻定阅最新的内部Observable对象上，若是已定阅了之前的内部Observable对象，就会退订谁人过期的内部Observable对象，这个“⽤上新的，舍弃旧的”行动，就是切换。
应用场景：也就是外层的数据发生快于内层的数据发生的速率形成数据积存，需求又能够舍弃本来的旧的外层的数据不让其旧的外层数据再通报到内层发生数据了。
简而言之，当外层新发生数据时，不管内部数据发生状况如何都取消，从新盘算数据流

interval(1000).pipe(
    take(3),
    map(x => Observable.interval(1500).map(y => x+':'+y).take(2)),
    switchAll()
)
//1:0
//1:1
//complete

第⼀个Observable对象有时机产⽣数据0：0，然则在第⼆个数据0：1产⽣之前，第⼆个内部Observable对象产⽣，这时候发⽣切换，第⼀个内部Observable就退场了。一样，第⼆个内部Observable只要时机产⽣⼀个数据1：0，然后第三个内部Observable对象产⽣，以后没有新的内部Observable对象产⽣，以是第三个Observable对象的两个数据2：0和2：1都进⼊了下流。

exhaust

在耗尽以后内部Observable的数据之前不会切换到下⼀个内部Observable对象
一样是衔接⾼阶Observable产⽣的内部Observable对象，然则exhaust的战略和switch相反，当内部Observable对象在时刻上发⽣堆叠时，情形就是前⼀个内部Observable还没有结束，⽽新的Observable又已产⽣，究竟应当挑选哪⼀个作为数据源？switch挑选新产⽣的内部Observable对象，exhaust则挑选前⼀个内部Observable对象.

interval(1000).pipe(
    take(3),
    map(x => Observable.interval(700).map(y => x+':'+y).take(2)),
    exhaust()
)

Last modification：March 25, 2020

如果觉得我的文章对你有用，请随意赞赏

Comment here is closed

rxjs入门6之兼并数据流

喻城 • 2019 年 07 月 01 日

<p><img src="/usr/uploads/2019/6/FVbuuu.png" class="aligncenter"></p><h3>一 concat，merge，zip，combineLatest等兼并类操纵符</h3><p>以上操纵符在版本6中已只存在静态要领，不克不及在pipe中应用。</p><pre><code>import {concat,merge,zip,combineLatest}</code></pre><h5>1.concat (obs1,obs2,obs3) <em>首尾相连</em></h5><p>顺次将多个observable首尾兼并，必须在第一个obs1的数据悉数完成，能力举行第二个obs2，若是第一个为interval（1000）,那末obs2 和obs3 也就永久没有时机取得输出。</p><pre><code>concat(of(1,2,3),interval).subscribe(console.log);
// 1   2   3    0  1  2  3  ...</code></pre><h5>2.merge <em>先到先得疾速经由过程</em></h5><p>merge会第⼀时刻定阅一切的上游Observable，然后对上游的数据接纳“先到先得”的战略，任何⼀个Observable只需有数据推下来，就⽴刻转给下流Observable对象。</p><pre><code>merge(interval(1000),of(1,2,3)).subscribe(console.log);
merge(of(1,2,3),interval(1000)).subscribe(console.log);
//两种状况的输出效果一样，都是先一次性输出1 2 3  再距离一秒顺次输出0 1 2 ...</code></pre><pre><code>const source1$ = Observable.timer(0, 1000).map(x =&gt; x+'A');
const source2$ = Observable.timer(500, 1000).map(x =&gt; x+'B');
merge(source1$, source2$).subscribe(
console.log,
null,
() =&gt; console.log('complete')
);
//0A
//0B
//1A
//1B
//2A
//2B</code></pre><p><img src="/usr/uploads/2019/6/zqimee.png" class="aligncenter"></p><p>merge 的应用场景：我们晓得fromEvent能够从⽹页中猎取事宜，只可惜，fromEvent⼀次只能从⼀个DOM元素猎取⼀种范例的事宜。⽐如，我们关⼼某个元素的click事宜，同时也关⼼这个元素上的touchend事宜，由于在挪动装备上touchend事宜涌现得⽐click更早，这两个事宜的处置惩罚是⼀模⼀样的，然则fromEvent不克不及同时取得两个事宜的数据流，这时候刻就要借助merge的⼒量了，代码以下：</p><pre><code>const click$ = Rx.Observable.fromEvent(element, 'click');
const touchend$ = Rx.Observable.fromEvent(element, 'touchend');
merge(click$, touchend$).subscribe(eventHandler)</code></pre><h5>3.zip :拉链式组合</h5><p><em>一对一的兼并</em></p><ul> 
 <li>zip会把上游的数据转化为数组情势，每⼀个上游Observable孝敬的数据会在对应数组中占⼀席之地.</li> 
 <li>默许的输出花样为数组花样，可经由过程第二个参数举行参数花样组装</li> 
 <li>简而言之：不论是同步发生数据照样异步发生的数据，都邑每次顺次从须要兼并的observable中取一个数据兼并成一个数组输出，当某一个observer不再吐出数据了，则停止兼并，实行complete函数</li> 
</ul><pre><code>const source1$ = Observable.of(1, 2, 3);
const source2$ = Observable.of('a', 'b', 'c');
zip(source1$, source2$).subscribe(
    console.log,
    null,
    () =&gt; console.log('complete')
);
//[ 1, 'a' ]
//[ 2, 'b' ]
//[ 3, 'c' ]
//complete</code></pre><p><img src="/usr/uploads/2019/6/AjYrqa.png" class="aligncenter"></p><h5>4.combineLatest:兼并末了一个数据</h5><ul> 
 <li>输出的数组中元素个数与兼并的observable的个数相称。</li> 
 <li>在兼并的observable中，只要末了一个元素为下流，前面的参数若是有同步的数据，同步数据中只要末了一个数据能进入数据流</li> 
 <li>默许的输出花样为数组花样，可经由过程第二个参数举行参数花样组装</li> 
 <li>第一次实行，当上游发生了数据，下流还没来得及发生数据时，就会守候。第二轮时刻，不论是上游或许下流发生一个数据，都邑实行输出，还没来得及发生数据的observable就输出本来发生的数据，以下弹珠图</li> 
</ul><pre><code>const source1$ = Observable.timer(500, 1000);
const source2$ = Observable.timer(1000, 1000);
combineLatest(source1$,source2$).subscribe(
    console.log,
    null,
    () =&gt; console.log('complete')
);
//[ 0, 0 ]
//[ 1, 0 ]
//[ 1, 1 ]
//[ 2, 1 ]
//[ 2, 2 ]
//[ 3, 2 ]</code></pre><p><img src="/usr/uploads/2019/6/jqYVFr.png" class="aligncenter"></p><h5>5.withLatestFrom</h5><ul> 
 <li>withLatestFrom 为管道中应用的要领。默许的输出花样为数组花样，可经由过程第二个参数举行参数花样组装</li> 
 <li>withLatestFrom只要实例操纵符的情势，⽽且一切输⼊Observable的职位并不相同，调⽤withLatestFrom的谁人Observable对象起到主导数据产⽣节拍的作⽤，作为参数的Observable对象只能孝敬数据，不克不及掌握产⽣数据的机遇。</li> 
</ul><pre><code>const source1$ = Observable.timer(0, 2000).map(x =&gt; 100 * x);
const source2$ = Observable.timer(500, 1000);
 source1$.pipe(
    withLatestFrom(source2$, (a,b)=&gt; a+b);
).subscribe(
    console.log,
    null,
    () =&gt; console.log('complete')
);</code></pre><p><img src="/usr/uploads/2019/6/FZFBba.png" class="aligncenter"><br />source1$产⽣第⼀个数据0时，withLatestFrom的另⼀个输⼊Observable对象source2$还没有产⽣数据，以是这个0也被忽略了。</p><p><em>处理glitch</em><br />例1：</p><pre><code>const original$ = Observable.timer(0, 1000);
const source1$ = original$.map(x =&gt; x+'a');
const source2$ = original$.map(x =&gt; x+'b');
const result$ = source1$.pipe(withLatestFrom(source2$);)
result$.subscribe(
console.log,
null,
() =&gt; console.log('complete')
);</code></pre><p>例2：</p><pre><code>const event$ = Rx.Observable.fromEvent(document.body, 'click');
const x$ = event$.map(e =&gt; e.x);
const y$ = event$.map(e =&gt; e.y);
const result$ = x$.pipe(combineLatest(y$, (x, y) =&gt; `x: ${x}, y: ${y}`)).subscribe(
    (location) =&gt; {
        console.log('#render', location);
        document.querySelector('#text').innerText = location;
    }
);</code></pre><h5>race :胜者通吃</h5><p>race就是“合作”，多个Observable对象在⼀起，看谁最早产⽣数据，不外这类合作是⼗分严酷的，胜者通吃，败者则落空一切时机。<br />简而言之，经由过程race兼并多个observable时，最早吐出数据谁人observable会成为数据源，别的的observable会被镌汰。</p><h5>startWith</h5><p>startWith只要实例操纵符的情势，其功用是让⼀个Observable对象在被定阅的时刻，老是先吐出指定的若⼲个数据。下⾯是使⽤startWith的⽰例代码</p><pre><code>of(0,1,2).pipe(startWith('a','b')).subscribe(console.log);
//先顺次吐出 a b 0 1 2</code></pre><h5>forkJoin</h5><ul> 
 <li>forkJoin能够接收多个Observable对象作为参数，forkJoin产⽣的Observable对象也很有特性，它只会产⽣⼀个数据，由于它会守候一切参数Observable对象的末了⼀个数据，也就是说，只要当一切Observable对象都结束，肯定不会有新的数据产⽣的时刻，forkJoin就会把一切输⼊Observable对象产⽣的末了⼀个数据兼并成给下流唯⼀的数据。</li> 
 <li>forkJoin就是RxJS界的Promise.all，Promise.all守候一切输⼊的Promise对象胜利以后把效果兼并，forkJoin守候一切输⼊的Observable对象结束以后把末了⼀个数据兼并。</li> 
 <li>返回数组情势，数组中元素个数为兼并的observable的个数<br /><code>js forkJoin(interval(1000).pipe(take(3)),of(1,2,3),timer(2000,1000).pipe(take(3))).subscribe(console.log); // [2,3,2]</code>js</li> 
</ul><h3>高阶Observable</h3><p>简言之：⾼阶函数就是产⽣函数的函数；相似，所谓⾼阶Observable，指的是产⽣的数据依然是Observable的Observable</p><h5>1.concatAll</h5><p>concatAll只要⼀个上游Observable对象，这个Observable对象预期是⼀个⾼阶Observable对象，concatAll会对个中的内部Observable对象做concat的操纵.</p><pre><code>interval(1000).pipe(
    take(2),
    map(x=&gt;interval(1500).pipe(take(2),map(x=&gt; `${x}:x,y:${y}`))),
    concatAll()
).subscribe(console.log);
// 0:a,b:0
// 0:a,b:1
// 1:a,b:0
// 1:a,b:1</code></pre><p><img src="/usr/uploads/2019/6/Qry22y.png" class="aligncenter"></p><p>concat 现实应用</p><pre><code>fromEvent(document.body,'mousedown').pipe(
      map(
        e=&gt;fromEvent(document.body,'mousemove').pipe(map(e=&gt;{return {x:e.clientX,y:e.clientY}}), takeUntil(fromEvent(document.body,'mouseup')))
      ),
      concatAll()
    ).subscribe(console.log);</code></pre><h5>mergeAll</h5><p>mergeAll就是处置惩罚⾼阶Observable的merge，只是一切的输⼊Observable来⾃于上游产⽣的内部Observable对象.</p><pre><code>interval(1000).pipe(
    take(2),
    map(x =&gt; Observable.interval(1500).map(y =&gt; x+':'+y).take(2)),
    mergeAll()
)</code></pre><p><img src="/usr/uploads/2019/6/iem2Un.png" class="aligncenter"><br />mergeAll只需<br />发明上游产⽣⼀个内部Observable就会⽴刻定阅，并从中抽取收条，以是在上图中，第⼆个内部Observable产⽣的数据1：0会涌如今第⼀个内部Observable产⽣的数据0：1之前.</p><h5>zipAll</h5><pre><code>interval(1000).pipe(
    take(2),
    map(x =&gt; Observable.interval(1500).map(y =&gt; x+':'+y).take(2)),
    zipAll()
)
//[ '0:0', '1:0' ]
//[ '0:1', '1:1' ]
//complete</code></pre><h5>combineAll</h5><p>combineAll就是处置惩罚⾼阶Observable的combineLatest，能够是由于combine-LatestAll太长了，以是RxJS挑选了combineAll这个名字。</p><pre><code>interval(1000).pipe(
    take(2),
    map(x =&gt; Observable.interval(1500).map(y =&gt; x+':'+y).take(2)),
    combeneAll()
)
//[ '0:0', '1:0' ]
//[ '0:1', '1:0' ]
//[ '0:1', '1:1' ]
//complete</code></pre><h5>switchAll</h5><ul> 
 <li>switch的寄义就是“切换”，老是切换到最新的内部Observable对象猎取数据。每当switch的上游⾼阶Observable产⽣⼀个内部Observable对象，switch都邑⽴刻定阅最新的内部Observable对象上，若是已定阅了之前的内部Observable对象，就会退订谁人过期的内部Observable对象，这个“⽤上新的，舍弃旧的”行动，就是切换。</li> 
 <li>应用场景：也就是外层的数据发生快于内层的数据发生的速率形成数据积存，需求又能够舍弃本来的旧的外层的数据不让其旧的外层数据再通报到内层发生数据了。<br />简而言之，当外层新发生数据时，不管内部数据发生状况如何都取消，从新盘算数据流</li> 
</ul><pre><code>interval(1000).pipe(
    take(3),
    map(x =&gt; Observable.interval(1500).map(y =&gt; x+':'+y).take(2)),
    switchAll()
)
//1:0
//1:1
//complete</code></pre><p><img src="/usr/uploads/2019/6/E7z2Yn.png" class="aligncenter"><br />第⼀个Observable对象有时机产⽣数据0：0，然则在第⼆个数据0：1产⽣之前，第⼆个内部Observable对象产⽣，这时候发⽣切换，第⼀个内部Observable就退场了。一样，第⼆个内部Observable只要时机产⽣⼀个数据1：0，然后第三个内部Observable对象产⽣，以后没有新的内部Observable对象产⽣，以是第三个Observable对象的两个数据2：0和2：1都进⼊了下流。</p><h5>exhaust</h5><ul> 
 <li>在耗尽以后内部Observable的数据之前不会切换到下⼀个内部Observable对象</li> 
 <li>一样是衔接⾼阶Observable产⽣的内部Observable对象，然则exhaust的战略和switch相反，当内部Observable对象在时刻上发⽣堆叠时，情形就是前⼀个内部Observable还没有结束，⽽新的Observable又已产⽣，究竟应当挑选哪⼀个作为数据源？switch挑选新产⽣的内部Observable对象，exhaust则挑选前⼀个内部Observable对象.</li> 
</ul><pre><code>interval(1000).pipe(
    take(3),
    map(x =&gt; Observable.interval(700).map(y =&gt; x+':'+y).take(2)),
    exhaust()
)</code></pre><p><img src="/usr/uploads/2019/6/JbYRr2.png" class="aligncenter"></p>

rxjs入门6之兼并数据流

一 concat，merge，zip，combineLatest等兼并类操纵符

1.concat (obs1,obs2,obs3) 首尾相连

2.merge 先到先得疾速经由过程

3.zip :拉链式组合

4.combineLatest:兼并末了一个数据

5.withLatestFrom

race :胜者通吃

startWith

forkJoin

高阶Observable

1.concatAll

mergeAll

zipAll

combineAll

switchAll

exhaust

彩虹授权站v2.0源码

苹果cms模板—aikan

免费可用的授权站源码

苹果cms模板—Joeleo

最新可用彩虹代刷破解版源码

中文情绪剖析——snownlp类库源码解释及运用

Python爬虫-博客园首页引荐博客排行(整合词云+邮件发送)

重构：你能够不知道的重构场景

Q版CS1.6鬼子进村中文版

可用的彩虹代挂破解版源码

rxjs入门6之兼并数据流