Christian-health
commented
6 years ago All / every / jortSort / jortSortUntil
determine whether all items emitted by an Observable meet some criteria
确定Observable发出的所有项目是否符合某些标准
Pass a predicate function to the All operator that accepts an item emitted by the source Observable and returns a boolean value based on an evaluation of that item. All returns an Observable that emits a single boolean value: true if and only if the source Observable terminates normally and every item emitted by the source Observable evaluated as true according to this predicate; false if any item emitted by the source Observable evaluates as false according to this predicate.
将一个谓词函数传递给接受Source Observable发出的一个项目的All运算符，并根据该项目的评估返回一个布尔值。 全部返回一个可发出单个布尔值的Observable：当且仅当源Observable正常终止且源Observable发出的每个项目根据该谓词计算为true时为true。 如果源Observable发出的任何项目根据该谓词计算为false，则为false。
var source = Rx.Observable.of(1,2,3,4,5)
.every(function (x) {
return x < 6;
});
var subscription = source.subscribe(
function (x) { console.log('Next: %s', x); },
function (err) { console.log('Error: %s', err); },
function () { console.log('Completed'); });
Next: true
CompletedThere is also a jortSort operator that performs a test on the entire sequence of items emitted by the source Observable. If those items are emitted in sorted order, upon the successful completion of the source Observable, the Observable returned from jortSort will emit true and then complete. If any of the items emitted by the source Observable is out of sort order, upon the successful completion of the source Observable, the Observable returned from jortSort will emit false and then complete. 还有一个jortSort操作符，对源Observable发出的整个项目序列进行测试。 如果这些项目按排序顺序排列，则在成功完成源Observable后，从jortSort返回的Observable将会发出true，然后完成。 如果源Observable发出的任何项目不符合排序顺序，则在成功完成源Observable后，从jortSort返回的Observable将发出false并完成。 There is also a jortSortUntil operator. It does not wait until the source Observable completes to evaluate its sequence for sortedness, as jortSort does, but waits until a second Observable emits an item to do so.
var source = Rx.Observable.of(1,2,3,4) // already sorted
.jortSort();
var subscription = source.subscribe(
function (x) { console.log('Next: %s', x); },
function (e) { console.log('Error: %s', e); },
function ( ) { console.log('Completed'); });
Next: true
Completedvar source = Rx.Observable.of(3,1,2,4) // not sorted
.jortSort();
var subscription = source.subscribe(
function (x) { console.log('Next: %s', x); },
function (e) { console.log('Error: %s', e); },
function ( ) { console.log('Completed'); });
Next: false
Completedvar just = Rx.helpers.just;
var source = Rx.Observable.of(1,2,3,4) // already sorted //这段代码根本直接跑不起来，没看懂
.flatmap(function (x) {
return Rx.Observable.timer(1000).map(just(x));
}).jortSortUntil(Rx.Observable.timer(3000);
var subscription = source.subscribe(
function (x) { console.log('Next: %s', x); },
function (e) { console.log('Error: %s', e); },
function ( ) { console.log('Completed'); });
Next: true
Completedvar just = Rx.helpers.just; //这段代码根本直接跑不起来，没看懂
var source = Rx.Observable.of(3,1,2,4) // not sorted
.flatmap(function (x) {
return Rx.Observable.timer(1000).map(just(x));
}).jortSortUntil(Rx.Observable.timer(3000);
var subscription = source.subscribe(
function (x) { console.log('Next: %s', x); },
function (e) { console.log('Error: %s', e); },
function ( ) { console.log('Completed'); });
Next: false
Completed
RxJS implements this operator as amb. It takes a variable number of parameters, which may be either Observables or Promises (or combinations of the two).
RxJS将此运算符实现为amb。 它需要可变数量的参数，它们可以是Observables或Promises（或两者的组合）。
You can use the generateWithRelativeTime operator to create simple Observables that can generate their next emissions, and can determine when to terminate, based on the value of the previous emission. The basic form of generateWithRelativeTime takes five parameters:
您可以使用generateWithRelativeTime运算符创建简单的可观测值，可以生成其下一个排放，并可根据先前排放的值确定何时终止。 generateWithRelativeTime的基本形式有五个参数：
Normally, an Observable that emits multiple items will do so by invoking its observer’s onNext method for each such item. You can change this behavior, instructing the Observable to compose an array of these multiple items and then to invoke the observer’s onNext method only once, passing it the entire array, by applying the toArray operator to the Observable.
通常，发出多个项目的Observable将通过为每个这样的项目调用其观察者的onNext方法来实现。 您可以更改此行为，指示Observable组合这些多个项目的数组，然后仅将观察者的onNext方法调用一次，传递整个数组，方法是将toArray运算符应用于Observable。
(这段话的意思就是，原来的时候一个Observable，一个一个的发出数据，然后我们可以使用take(5)这样的运算符号，取出其中的若干个，然后通过toArray运算符这样的符号把发出的这若干个item数据整合成为一个数组，然后把这个数组整体作为一个item发射出去)
The toMap operator collects the items emitted by the source Observable into a Map and then emits that map. You supply a function that generates the key for each emitted item. You may also optionally supply a function that converts an emitted item into the value to be stored in the map (by default, the item itself is this value).
In RxJS, the from operator converts an array-like or iterable object into an Observable that emits the items in that array or iterable. A String, in this context, is treated as an array of characters.
原理就是，javascript使用鸭子类型，当你想调用一个Object中的foo方法的时候，如果这个Object是bar类型。也就是说typeof Object = bar 。它并不检查这个Object到底是否真是一个bar类型，javascript只检测这个Object中是否有这个foo方法。
The of operator accepts a number of items as parameters, and returns an Observable that emits each of these parameters, in order, as its emitted sequence.
运算符接受多个项目作为参数，并返回一个Observable，按照排列顺序发射这些东西。
Pass SequenceEqual two Observables, and it will compare the items emitted by each Observable, and the Observable it returns will emit true only if both sequences are the same (the same items, in the same order, with the same termination state).
传递给 SequenceEqual操作符两个Observables，它将比较每个Observable发出的项目，只有两个序列相同（相同的项目，相同的顺序，具有相同的终止状态），它才返回的Observable将发送true。
Aggregate (reduce)
apply a function to each item emitted by an Observable, sequentially, and emit the final value 对Observable发出的每个项目顺序应用一个函数，并发出最终的值
The Reduce operator applies a function to the first item emitted by the source Observable and then feeds the result of the function back into the function along with the second item emitted by the source Observable, continuing this process until the source Observable emits its final item and completes, whereupon the Observable returned from Reduce emits the final value returned from the function. Reduce操作符对源Observable发出的第一个项目应用一个函数，然后将该函数的结果与源Observable发出的第二个项目一起反馈到该函数中，继续此过程，直到源Observable发出其最终项目， 完成，然后从Reduce返回的Observable发出从函数返回的最终值。
This sort of operation is sometimes called “accumulate,” “aggregate,” “compress,” “fold,” or “inject” in other contexts. 这种操作有时在其他上下文中被称为“累加”，“聚合”，“压缩”，“折叠”或“注入”。
RxJS implements the reduce operator. Pass it an accumulator function, and, optionally, a seed value to pass into the accumulator function with the first item emitted by the source Observable. RxJS实现了reduce操作符。 传递一个累加器函数，以及可选的种子值，以便通过源Observable发出的第一个项目传入累加器函数。