Mastering reactive JavaScript create applications empowered with real-time data without compromising performance

Expand your boundaries by creating applications empowered with real-time data using RxJs without compromising performance About This Book Handle an infinite stream of incoming data using RxJs without going crazy Explore important RxJs operators that can help you improve your code readability Get acq...

Descripción completa

Detalles Bibliográficos
Otros Autores:	Oliveira, Erich de Souza, author (author)
Formato:	Libro electrónico
Idioma:	Inglés
Publicado:	Birmingham, England ; Mumbai, [India] : Packt Publishing 2017.
Edición:	1st edition
Materias:	JavaScript (Computer program language) Application software > Development.
Ver en Biblioteca Universitat Ramon Llull:	https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009630189306719

Tabla de Contenidos:

Cover
Copyright
Credits
About the Author
About the Reviewer
www.PacktPub.com
Customer Feedback
Table of Contents
Preface
Chapter 1: What Does Being Reactive Mean?
The reactive paradigm
Why do I need it?
Installation of tools
Node.js
bacon.js
RxJS
Your first code using reactive programming
Summary
Chapter 2: Reacting for the First Time
The bacon.js observables
Creating our first observable
Observables from DOM events (asEventStream)
Observables from promises (fromPromise)
Observable node event emitter (fromEvent)
Observables from an array (fromArray)
Observables from an array (sequentially)
Observables from an interval (interval)
Observables from other sources
Properties
Changes in an observable
Reacting to changes
Subscribing
Subscribing using the onValue() method
Subscribing using the log method
Subscribing using the assign method
Acting when an error occurs
Reading how an operator works
Transforming events using bacon.js
Reusing observables
Observables' lazy evaluation
Summary
Chapter 3: A World Full of Changes - Reactive Extensions to the Rescue
RxJS observables
Difference between bacon.js and RxJS observables
Hot and cold observables
Installing RxJS
Creating an observable
Creating an observable from iterable objects
Creating an observable from a sequence factory
Creating an observable using range ()
Creating an observable using period of time
Creating an observable from callbacks
Creating an observable from a promise
Creating empty observables
Creating an observable from a single value
Creating an observable from a factory function
Creating an observable from arbitrary arguments
Creating an observable from an error
Creating observables from DOM events (or EventEmitter).
Creating an observable from an arbitrary source
Subscribing to changes (Observer)
RxJS Subjects
RxJS Disposable
RxJS Schedulers
Summary
Chapter 4: Transforming Data - Map, Filter, and Reduce
Adding operators to observables
The map() operator
The flatMap() operator
The filter() operator
The reduce() operator
Summary
Chapter 5: The World Changes Too Fast - Operators to Deal with Backpressure
What is backpressure?
Common strategies to deal with backpressure
Lossy strategies to deal with backpressure
The throttle() operator
The sample() operator
The debounce() operator
The pausable() observables
Loss-less operators to deal with backpressure
Buffering
The bufferWithCount() operator
The bufferWithTime() operator
The bufferWithTimeOrCount() operator
Pausable observables (with buffer)
Controlled observables
More ways to filter data
The first() operator
The take() operator
The takeLast() operator
The takeWhile() operator
The skip() operator
The skipWhile() operator
Summary
Chapter 6: Too Many Sources - Combining Observables
When do I need to combine observables?
Running observables
Concatenating observables
Using the concat() operator
Using the merge() operator
Using the concatAll() operator
Using the mergeAll() operator
Combining observables
Using the forkJoin() operator
Using the zip() operator
Using the zipIterable() operator
Summary
Chapter 7: Something is Wrong - Testing and Dealing with Errors
Dealing with errors
Acting when an error occurs
Treating an error
The catch() operator
The onErrorResumeNext() operator
The retry() operator
The mergeDelayError() operator
Testing our application
Testing in the server
Testing in the browser
Testing applications using RxJS
Summary.
Chapter 8: More about Operators
The road so far
The fundamentals of RxJS
The map() operator versus the flatMap() operator
Challenge - Creating a function to filter elements using only the flatMap() operator
Filtering data
Aggregating data
Going beyond the basics
Dealing with backpressure
Combining observables
Other important operators
The flatMapLatest() operator
The flatMapFirst() operator
The finally() operator
The groupBy() operator
The do() operator
Summary
Chapter 9: Composition
What is a transducer?
Available transducer implementations for JavaScript
The transducers-js API
Using transducers
Using transducers with RxJS
Testing transducers
A performance comparison for JavaScript code using transducers
Summary
Chapter 10: A Real-Time Server
The web chat server
Creating the project
The architecture of the server
Implementing the server
DataSource
Service to send messages
Test implementation
Service implementation
Service to listen to new messages
Test implementation
Service implementation
Service to block messages from a given user
Test implementation
Service implementation
Service to send a command
Test implementation
Service implementation
Handling WebSocket connections
Scaling the server
Connecting to Redis
Using Redis as the DataSource for messages
Summary
Chapter 11: A Real-Time Client
Installing dependencies
The structure of our client
Building the application for the first time
Connecting to the server application
Using RxJS to manage user input
Connecting user interactions and server communication
Improving interaction with RxJS
Batching changes to the DOM
Testing the application
Summary
Index.

Mastering reactive JavaScript create applications empowered with real-time data without compromising performance

Ejemplares similares