generate<T, S>(initialStateOrOptions: S | GenerateOptions<T, S>, condition?: ConditionFunc<S>, iterate?: IterateFunc<S>, resultSelectorOrObservable?: (ResultFunc<S, T>) | SchedulerLike, scheduler?: SchedulerLike): Observable<T>
Parameters
| initialStateOrOptions |
Type: S | GenerateOptions.
|
| condition |
Optional. Default is undefined.
Type: ConditionFunc.
|
| iterate |
Optional. Default is undefined.
Type: IterateFunc.
|
| resultSelectorOrObservable |
Optional. Default is undefined.
Type: (ResultFunc) | SchedulerLike.
|
| scheduler |
Optional. Default is undefined.
Type: SchedulerLike.
|
Returns
Observable<T>
Overloads
const generated = generate(0, x => x < 3, x => x + 1);generated.subscribe(
value => console.log(value),
err => {},
() => console.log('Yo!')
);
// Logs:
// 0
// 1
// 2
// "Yo!"
@example
const generated = generate(0, x => x < 3, x => x + 1, x => x * 1000);generated.subscribe(
value => console.log(value),
err => {},
() => console.log('Yo!')
);
// Logs:
// 0
// 1000
// 2000
// "Yo!"
@example
const generated = generate({
initialState: 0,
condition(value) { return value < 3; },
iterate(value) { return value + 1; },
resultSelector(value) { return value * 1000; }
});generated.subscribe(
value => console.log(value),
err => {},
() => console.log('Yo!')
);
// Logs:
// 0
// 1000
// 2000
// "Yo!"
@example
const generated = generate({
initialState: 0,
iterate(value) { return value + 1; },
resultSelector(value) { return value * 1000; }
});generated.subscribe(
value => console.log(value),
err => {},
() => console.log('Yo!') // This will never run.
);
// Logs:
// 0
// 1000
// 2000
// 3000
// ...and never stops.
@see from
@see create
@param {S} initialState Initial state.
@param {function (state: S): boolean} condition Condition to terminate generation (upon returning false).
@param {function (state: S): S} iterate Iteration step function.
@param {function (state: S): T} [resultSelector] Selector function for results produced in the sequence.
@param {Scheduler} [scheduler] A Scheduler on which to run the generator loop. If not provided, defaults to emitting immediately.
@return {Observable} The generated sequence.
generate(initialState: S, condition: ConditionFunc<S>, iterate: IterateFunc<S>, resultSelector: ResultFunc<S, T>, scheduler?: SchedulerLike): Observable<T>
Generates an observable sequence by running a state-driven loop
producing the sequence's elements, using the specified scheduler
to send out observer messages.
Parameters
| initialState |
Initial state.
|
| condition |
Condition to terminate generation (upon returning false).
|
| iterate |
Iteration step function.
|
| resultSelector |
Selector function for results produced in the sequence. (deprecated)
|
| scheduler |
Optional. Default is undefined.
A SchedulerLike on which to run the generator loop. If not provided, defaults to emit immediately.
|
Returns
Observable<T>: The generated sequence.
|
generate(initialState: S, condition: ConditionFunc<S>, iterate: IterateFunc<S>, scheduler?: SchedulerLike): Observable<S>
Generates an Observable by running a state-driven loop
that emits an element on each iteration.
Parameters
| initialState |
Type: S.
|
| condition |
Type: ConditionFunc.
|
| iterate |
Type: IterateFunc.
|
| scheduler |
Optional. Default is undefined.
Type: SchedulerLike.
|
Returns
Observable<S>
Use it instead of nexting values in a for loop.
generate allows you to create stream of values generated with a loop very similar to
traditional for loop. First argument of generate is a beginning value. Second argument
is a function that accepts this value and tests if some condition still holds. If it does,
loop continues, if not, it stops. Third value is a function which takes previously defined
value and modifies it in some way on each iteration. Note how these three parameters
are direct equivalents of three expressions in regular for loop: first expression
initializes some state (for example numeric index), second tests if loop can make next
iteration (for example if index is lower than 10) and third states how defined value
will be modified on every step (index will be incremented by one).
Return value of a generate operator is an Observable that on each loop iteration
emits a value. First, condition function is ran. If it returned true, Observable
emits currently stored value (initial value at the first iteration) and then updates
that value with iterate function. If at some point condition returned false, Observable
completes at that moment.
Optionally you can pass fourth parameter to generate - a result selector function which allows you
to immediately map value that would normally be emitted by an Observable.
If you find three anonymous functions in generate call hard to read, you can provide
single object to the operator instead. That object has properties: initialState,
condition, iterate and resultSelector, which should have respective values that you
would normally pass to generate. resultSelector is still optional, but that form
of calling generate allows you to omit condition as well. If you omit it, that means
condition always holds, so output Observable will never complete.
Both forms of generate can optionally accept a scheduler. In case of multi-parameter call,
scheduler simply comes as a last argument (no matter if there is resultSelector
function or not). In case of single-parameter call, you can provide it as a
scheduler property on object passed to the operator. In both cases scheduler decides when
next iteration of the loop will happen and therefore when next value will be emitted
by the Observable. For example to ensure that each value is pushed to the observer
on separate task in event loop, you could use async scheduler. Note that
by default (when no scheduler is passed) values are simply emitted synchronously.
@example |
Use with condition and iterate functions.
Use with condition, iterate and resultSelector functions.
Use with options object.
Use options object without condition function.
generate(options: GenerateBaseOptions<S>): Observable<S>
Generates an observable sequence by running a state-driven loop
producing the sequence's elements, using the specified scheduler
to send out observer messages.
The overload accepts options object that might contain initial state, iterate,
condition and scheduler.
Parameters
| options |
Object that must contain initialState, iterate and might contain condition and scheduler.
|
Returns
Observable<S>: The generated sequence.
|
generate(options: GenerateOptions<T, S>): Observable<T>
Generates an observable sequence by running a state-driven loop
producing the sequence's elements, using the specified scheduler
to send out observer messages.
The overload accepts options object that might contain initial state, iterate,
condition, result selector and scheduler.
Parameters
| options |
Object that must contain initialState, iterate, resultSelector and might contain condition and scheduler.
|
Returns
Observable<T>: The generated sequence.
|
