Index

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Previous Chapter

Appendix B. Choosing an operator

List of Figures

Index

[SYMBOL][A][B][C][D][E][F][G][H][I][J][K][L][M][N][O][P][R][S][T][U][V][W][X][Z]

SYMBOL

. (dot) notation

A

absolute time abstracting over time Account class accumulator function actions, Redux add() function addEventListener() function addListener() method aggregate data, scanning aggregate operators aggregates, sequencing operator pipelines with performance advantages of sequencing with RxJS referential transparency self-contained pipelines aggregating results with reduce ajax operator AJAX, testing requests ajax() function, 2^nd, 3^rd, 4^th, 5^th allocation allocating objects eager, disadvantages of lazy appendResults() function array extras Array object Array.map() method ArrayList arrow functions AsapScheduler asynchronous code, testing AJAX requests working with Promises asynchronous computing, vs. synchronous computing event emitters issues with blocking code non-blocking code with callback functions understanding time using callbacks asynchronous data sources multi-value single-value asynchronous middleware building with RxJS subjects asynchronous streams asynchronous timing, with JavaScript explicit implicit JavaScript interfaces AsyncScheduler AsyncSubject augmenting virtual reality refactoring search streams for testability with marbles with virtual time scheduler

B

bare observables, creating bindCallback operator Bitly Web API bitly$ stream blocking code, issues with boundary conditions bounded context buffer() function, 2^nd, 3^rd bufferCount() function, 2^nd buffering BufferIterator function bufferTime operator bufferWhen() function, 2^nd, 3^rd bulk data, writing bulkDocs() function business processes, coordinating building reactive database hooking into observable lifecycle joining parallel streams with combineLatest joining parallel streams with forkJoin

C

callbacks delegating errors to non-blocking code with overview using with Promises cancelling streams cancellation mismatch between RxJS and other APIs disadvantages of eager allocation explicitly cancelling subscriptions lazy allocation subscribing to observables subscriptions, explicitly catch block catch() operator, 2^nd, 3^rd, 4^th, 5^th, 6^th Chai.js, installing classes, React clearInterval() function clearResults() function clearTimeout() function clients, WS (WebSockets) closing observable code issues with blocking non-blocking with callback functions code bases functional reactive cold observables making from hot observables making into hot observables cold resubscribe combinatorial operators combineLatest() function, 2^nd, 3^rd, 4^th, 5^th, 6^th complete() function, 2^nd, 3^rd components React, 2^nd user interface, rendering with React composing functions computing, synchronous vs. asynchronous event emitters issues with blocking code non-blocking code with callback functions understanding time using callbacks concat() function, 2^nd concatenating streams overview preserving event order by concatMap operator dragging and dropping with overview ConcurrentLinkedList conformance connect() method, 2^nd ConnectableObservable connecting one observable to many observers publish publish last publish with replay consumers consuming data with observers creating bare observables observable modules Observer API containerizing data continuation coordinating business processes building reactive database hooking into observable lifecycle joining parallel streams with combineLatest joining parallel streams with forkJoin CORS (cross-origin resource sharing), 2^nd, 3^rd CPS (continuation-passing style) create() method, 2^nd createMiddleware() function createStore() method createStreamFromStore CSV (comma-separated value) array custom observables

D

data aggregate, scanning consuming with observers creating bare observables observable modules Observer API generated observable, switching to latest sources of identifying multi-value, asynchronous multi-value, synchronous single-value, asynchronous single-value, synchronous static wrapping sources with Rx.Observable creating RxJS observables identifying different sources of data pull-based semantics push-based semantics when and where to use RxJS data flows data pipelines data streams. See streams. databases joining related operations populating reactively reactive data-driven programming Date.now() function Date() function deallocating objects debounce operator debounce() method debounceTime() function, 2^nd, 3^rd, 4^th debouncing delay operator delay() function delegating errors, to callbacks design document discriminant function dispatch() method DisposableResource object distinctUntilChanged operator, 2^nd distinctUntilKeyChanged operator do operator, 2^nd DONE status flag dot (.) notation DoublyLinkedList downstream compartmentaliz--ation dragging and dropping, with concatMap DSL (domain-specific language) dynamic data sources

E

eager allocation, disadvantages of effectful computations emitters. See event emitters. endofunctor error handling common techniques delegating errors to callbacks with Promise with try/catch dealing with failure catching errors propagating errors downstream to observers reacting to errors reacting to failed retries retrying failed streams for fixed number of times functional approach imperative techniques error() function errors catching delegating to callbacks Promises and propagating downstream to observers reacting to evaluating streams cancellation mismatch between RxJS and other APIs disadvantages of eager allocation explicitly cancelling subscriptions lazy allocation subscribing to observables event bus event emitters event hooks EventEmitter class, 2^nd, 3^rd events filtering out unwanted interleaving by merging streams preserving order by concatenating streams example projects, installing explicit cancellation, of subscriptions explicit timing

F

factory functions failure catching errors propagating errors downstream to observers reacting to errors reacting to failed retries retrying failed streams for fixed number of times Failure type falsy value fetchDataInterval$ stream fetchResult$ stream filter() function, 2^nd, 3^rd filtering unwanted events finally() operator, 2^nd findRecordById() function first operator flattening data, 2^nd fluent programming forkJoin operator joining parallel streams with overview FP (functional programming) as pillar of RP overview frame() function from operator, 2^nd, 3^rd fromEvent operator fromPromise operator, 2^nd FRP (functional reactive programming) function chaining functional code bases functional programs, testing inherently built into functional sequences of events functor, 2^nd

G

generated data getOrElse() function getState() method, 2^nd Google client APIs, installing

H

handling errors common techniques delegating errors to callbacks with Promise with try/catch dealing with failure catching errors propagating errors downstream to observers reacting to failed retries retrying failed streams for fixed number of times functional approach imperative techniques higher-order observable hooks. See web hooks. hot observables making from cold observables making into cold observables overview, 2^nd, 3^rd hot RxJS, building

I

if operator immutable function imperative error-handling techniques implicit timing IndexedDB input, from users debouncing throttling installing Chai.js example projects Google client APIs Mocha Moment.js PouchDB Ramda.js React.js React-Bootstrap Redux.js RxJS instance methods interfaces, timing JavaScript, 2^nd interleaving events by merging streams interval() operator, 2^nd, 3^rd, 4^th, 5^th inversion of control isEven() function iterator patterns

J

JavaScript asynchronous timing with explicit implicit timing interfaces setInterval setTimeout

K

keyCode property

L

last operator latency lazy allocation lazy data source lazy data types lazy evaluation, 2^nd lifecycle, of observables LinkedList logic of streams, replaying

M

managing state of React components state with Redux manual debouncing map() function, 2^nd, 3^rd mapped observable mapping operations on observables marbles Math.random() function mathReducer merge() function, 2^nd, 3^rd mergeMap operator, 2^nd merging operations merging streams, interleaving events by middleware, asynchronous building with RxJS subjects mismatch, of cancellation between RxJS and other APIs Mocha installing overview modules, observable Moment.js, installing monads mousedown event mousemove event, 2^nd mouseup event, 2^nd mouseUp$ stream, 2^nd multicast() function, 2^nd, 3^rd multicasting operators multiple streams interleaving events by merging preserving event order by concatenating switching to latest observable data multi-value data sources asynchronous synchronous MVC (model-view-controller)

N

nested observables, unwinding next() method, 2^nd, 3^rd, 4^th Node.js, simple WS (WebSocket) servers in non-blocking code, with callback functions notEmpty function

O

object-oriented programming. See OOP. object-oriented. See OO. Observable class Observable data type observable instance methods Observable interface observable methods observable operators aggregating results with reduce filtering out unwanted events mapping operations on observables scanning aggregate data observable pipeline observables, 2^nd, 3^rd bare, creating changing temperature of creating hot-by-operator streams making cold observable hot making hot observable cold producers as thermometers cold making from hot making into hot connecting to many observers publish publish last publish with replay creating hot, 2^nd making from cold making into cold impact of side effects on replay replay vs. resubscribe replaying logic of stream impact of side effects on resubscribe replay vs. resubscribe resubscribing to stream lifecycle hooked on observer patterns web hooks mapping operations on modules subscribing to switching to latest data unwinding nested, with mergeMap operator WS (WebSockets) clients overview simple servers in Node.js observeOn() operator Observer API Observer interface observer patterns, 2^nd observers connecting one observable to many publish publish last publish with replay consuming data with creating bare observables observable modules Observer API observers, propagating errors downstream to of operator offset time ofType()operator OO (object-oriented) OOP (object-oriented programming) operations database, joining related mapping on observables operator chaining operators, 2^nd cancelling streams cancellation mismatch between RxJS and other APIs disadvantages of eager allocation explicitly cancelling subscriptions lazy allocation subscribing to observables choosing evaluating streams cancellation mismatch between RxJS and other APIs disadvantages of eager allocation explicitly cancelling subscriptions lazy allocation subscribing to observables observable aggregating results with reduce filtering out unwanted events mapping operations on observables scanning aggregate data pipelines, sequencing with aggregates propagation sequential time, 2^nd opinionated framework

P

paradigms, programming parallel streams joining with combineLatest joining with forkJoin passive resources patterns iterator observer pipelines operator, sequencing with aggregates self-contained pluck operator pointerup event populating databases, reactively post() method PouchDB installing overview, 2^nd, 3^rd predicate function processes. See business processes. producers as thermometers overview programming data-driven functional reactive, functional programming as pillar of without loops programming paradigms progressive loading projected observable Promise data type, 2^nd Promise.catch() operator Promises errors and improving callbacks with limitations of testing, 2^nd propagating errors, downstream to observers propagation props attribute publish last with replay publish operator, 2^nd publishBehavior() method publishLast operator publishReplay operator pull-based semantics pure functions, 2^nd pure observables push-based collections push-based semantics

R

Ramda.js, installing range operator range() function, 2^nd React classes components, 2^nd rendering UI components with overview state management with Redux React.createElement() function React.js, installing React-Bootstrap, installing reactive code bases reactive databases, building joining related database operations populating database reactively writing bulk data Reactive Extensions for Java-Script. See RxJS. Reactive Manifesto reactive programming. See RP. reactive programs, testing asynchronous code augmenting virtual reality inherently built into functional programs making streams testable Promises reactive streams scheduling values in RxJS reactive streams asynchronous dragging and dropping with concatMap multiple interleaving events by merging preserving event order by concatenating switching to latest observable data testing unwinding nested observables, with mergeMap operator reduce operator aggregating results with overview, 2^nd reducers overview Redux reduction operation Redux actions reducers state management with store store adapter Redux.js, installing refactoring search streams for testability refCount() method reference counting referential transparency relative time render() method, 2^nd rendering UI components with React managing state of React components overview React classes React components state management with Redux resubscribing impact of side effects on replay vs. resubscribe resubscribing to stream to streams versus replaying results, aggregating with reduce retry() operator, 2^nd retrying failed streams for fixed number of times reacting to failure when retryWhen() operator, 2^nd RP (reactive programming), functional programming as pillar of runInterval() function Rx.Observable, wrapping data sources with creating RxJS observables identifying different sources of data pull-based semantics push-based semantics when and where to use RxJS Rx.Observable.ajax() operator Rx.Observable.create() method Rx.Observable.fromEvent() operator Rx.TestScheduler class RxJS (Reactive Extensions for JavaScript) abstracting over time advantages of using creating observables data flows installing introduction to other APIs and propagation scheduling values in sequencing with streams, 2^nd subjects when and where to use multi-value, asynchronous data sources multi-value, synchronous data sources single-value, asynchronous data sources single-value, synchronous data sources

S

scalability scan() function, 2^nd, 3^rd scanning aggregate data scheduler scheduling values in RxJS search streams, refactoring for testability search$ stream self-contained pipelines semantics pull-based push-based sendRequest() function, 2^nd sequencing, operator pipelines with aggregates performance advantages of sequencing with RxJS referential transparency self-contained pipelines sequential time, 2^nd servers, WS (WebSockets) SessionDisposable object setInterval() function, 2^nd setState() method setTimeout() function, 2^nd shadow DOM share() operator, 2^nd, 3^rd shareReplay() operator side effects, 2^nd, 3^rd impact on replaying replay vs. resubscribe replaying logic of stream impact on resubscribing replay vs. resubscribe resubscribing to stream sinceLast variable single-value data sources asynchronous synchronous skip operator slice() method sources of data identifying multi-value, asynchronous multi-value, synchronous single-value, asynchronous single-value, synchronous wrapping with Rx.Observable square() function startWith operator, 2^nd state managing with Redux of React components state attribute stateful functions static data static methods stock ticker streams, 2^nd asynchronous cancelling cancellation mismatch between RxJS and other APIs disadvantages of eager allocation explicitly cancelling subscriptions lazy allocation subscribing to observables components of consumers data pipelines producers time creating hot-by-operator evaluating cancellation mismatch between RxJS and other APIs disadvantages of eager allocation explicitly cancelling subscriptions lazy allocation subscribing to observables failed, retrying for fixed number of times interleaving events by merging joining parallel with combineLatest making testable multiple preserving event order by concatenating reactive asynchronous streams dragging and dropping with concatMap multiple testing unwinding nested observables replaying logic of resubscribing to search Streams data type sub.unsubscribe() function subactions subflows subjects, RxJS subscribe() function, 2^nd, 3^rd, 4^th, 5^th subscriptions explicitly cancelling to observables Success type switch blocks switch() function, 2^nd switchMap operator synchronizing streams synchronous computing, vs. asynchronous computing event emitters issues with blocking code non-blocking code with callback functions understanding time using callbacks synchronous data sources multi-value single-value

T

take operator takeUntil() function, 2^nd temperature, of observables temporal dependency testing AJAX requests asynchronous code testing AJAX requests working with Promises Promises testing AJAX requests working with reactive programs augmenting virtual reality inherently built into functional programs making streams testable scheduling values in RxJS reactive streams refactoring search streams for thenable function this keyword, 2^nd throttleTime operator throttling, 2^nd throw operator tick$ observable, 2^nd time abstracting over understanding virtual scheduler time coupling timeInterval operator, 2^nd timer operator timestamping events timing asynchronous with JavaScript explicit implicit interfaces buffering explicit handling user input debouncing throttling implicit importance of JavaScript interfaces setInterval setTimeout operators propagation sequential time touchend event touchEnd$ stream touchmove event touchstart event transactionLogEpic() function transformational operations transient transparency, referential truthy value try block try/catch, error handling with

U

UI (user interface), rendering components with React managing state of React components overview React classes React components state management with Redux unicast transmission unopinionated framework, 2^nd, 3^rd unsubscribe operator, 2^nd, 3^rd, 4^th unwinding nested observables, with mergeMap operator upstream compartmentaliz-ation user input debouncing throttling user interface. See UI. using operator, 2^nd UX (user experience), 2^nd

V

value object values, scheduling values in RxJS virtual reality, augmenting refactoring search streams for testability with marbles with virtual time scheduler virtual time scheduler

W

web hooks withdraw function withLatestFrom operator wrapping data sources with Rx.Observable creating RxJS observables identifying different sources of data pull-based semantics push-based semantics when and where to use RxJS WS (WebSockets) clients overview simple servers in Node.js

X

XmlHttpRequest object, 2^nd

Z

zip() operator, 2^nd, 3^rd

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.