Muutke küpsiste eelistusi

E-raamat: RxJS in Action

4.04/5 (100 hinnangut Goodreads-ist)
,
  • Formaat: 352 pages
  • Ilmumisaeg: 20-Jul-2017
  • Kirjastus: Manning Publications
  • Keel: eng
  • ISBN-13: 9781638351702
Teised raamatud teemal:
  • Formaat - EPUB+DRM
  • Hind: 45,77 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.
RxJS in ActionSuurem pilt
  • Formaat: 352 pages
  • Ilmumisaeg: 20-Jul-2017
  • Kirjastus: Manning Publications
  • Keel: eng
  • ISBN-13: 9781638351702
Teised raamatud teemal:

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

DESCRIPTION

A growing flood of data is aimed at JavaScript applications, and they

need be ready for it. As more and more data is received, applications

must scale to stay operational. Theres also the problem of latency

when data has to be fetched from remote locations. RxJS, or Reactive

Extensions for JavaScript, is a library for transforming, composing,

and consuming streams of data. RxJS combines reactive and functional

programming to give an extensible, asynchronous event handling

system for JavaScript.





RxJS in Action gives readers the development skills they need to create reactive applications with RxJS. This book is full of theory and

practical examples that build on each other and help readers begin

thinking in a reactive manner. The book begins by teaching the

fundamentals of functional programming, and dives in to the basics of

RxJS and what it means to be reactive. Next, it teaches how to build

real-world applications with RxJS. The last part of the book tackles the

advanced topics to take the readers reactive programming skills to the

next level, as they will learn how to deal with error handling, unit

testing, and the role of RxJS when combined with frameworks such as

Angular.js or Cycle.js. Examples in the book use RxJS 5, the latest

version of RxJS built with an eye on performance and simplicity.





KEY FEATURES

Full of practical examples using real-world applications

Creating readable, easy-to-understand event processing pipelines

Introduces the fundamentals of functional and reactive programming

Transforms bulky, untestable code into modular, testable expressions

Uses the latest version of RxJS AUDIENCE

This book is for readers who are comfortable writing and building

applications in JavaScript.

ABOUT THE TECHNOLOGY

RxJS combines reactive and functional programming to give programmers

an extensible, asynchronous event handling system for JavaScript. RxJS is

ideal for applications with features that have continuous data flows that have

to fetch and combine multiple pieces of remote data, auto-complete text

boxes, drag and drop, process user input, and more.
Foreword xiii
Preface xv
Acknowledgments xvii
About This Book xix
About The Authors xxiv
About The Cover xxv
Part 1: Understanding Streams
1 Thinking reactively
3(25)
1.1 Synchronous vs. asynchronous computing
5(7)
Issues with blocking code
5(1)
Non-blocking code with callback functions
6(1)
Understanding time and space
7(2)
Are callbacks out of the picture?
9(2)
Event emitters
11(1)
1.2 Better callbacks with Promises
12(2)
1.3 The need for a different paradigm
14(3)
1.4 The Reactive Extensions for JavaScript
17(9)
Thinking in streams: data flows and propagation
17(1)
Introducing the RxJS project
18(1)
Everything is a stream
19(2)
Abstracting the notion of time from your programs
21(2)
Components of an Rx stream
23(3)
1.5 Reactive and other programming paradigms
26(1)
1.6 Summary
27(1)
2 Reacting with RxJS
28(33)
2.1 Functional programming as the pillar of reactive programming
29(12)
Functional programming
30(8)
The iterator pattern
38(3)
2.2 Stream's data-driven approach
41(2)
2.3 Wrapping data sources with Rx.Observable
43(10)
Identifying different sources of data
43(1)
Creating RxJS observables
44(2)
When and where to use RxJS
46(3)
To push or not to push
49(4)
2.4 Consuming data with observers
53(7)
The Observer API
53(2)
Creating bare observables
55(2)
Observable modules
57(3)
2.5 Summary
60(1)
3 Core operators
61(24)
3.1 Evaluating and cancelling streams
62(7)
Downside of eager allocation
62(2)
Lazy allocation and subscribing to observables
64(1)
Disposing of subscriptions: explicit cancellation
65(2)
Cancellation mismatch between RXJS and other APIs
67(2)
3.2 Popular RxJS observable operators
69(8)
Introducing the core operators
70(7)
3.3 Sequencing operator pipelines with aggregates
77(6)
Self-contained pipelines and referential transparency
77(3)
Performance advantages of sequencing with RxJS
80(3)
3.4 Summary
83(2)
4 It's about time you used RxJS
85(34)
4.1 Why worry about time?
87(1)
4.2 Understanding asynchronous timing with JavaScript
88(6)
Implicit timing
88(1)
Explicit timing
88(2)
The JavaScript timing interfaces
90(4)
4.3 Back to the future with RxJS
94(7)
Propagation
98(1)
Sequential time
99(2)
4.4 Handling user input
101(10)
Debouncing
101(7)
Throttling
108(3)
4.5 Buffering in RxJS
111(5)
4.6 Summary
116(3)
Part 2: Observables In Practice 119(90)
5 Applied reactive streams
121(30)
5.1 One for all, and all for one!
122(13)
Interleave events by merging streams
124(6)
Preserve order of events by concatenating streams
130(3)
Switch to the latest observable data
133(2)
5.2 Unwinding nested observables: the case of mergeMap
135(6)
5.3 Mastering asynchronous streams
141(5)
5.4 Drag and drop with concatMap
146(4)
5.5 Summary
150(1)
6 Coordinating business processes
151(31)
6.1 Hooking into the observable lifecycle
152(7)
Web hooks and the observer pattern
153(1)
Hooked on observables
154(5)
6.2 Joining parallel streams with combineLatest and forkJoin
159(11)
Limitations of using Promises
162(1)
Combining parallel streams
163(5)
More coordination with forkJoin
168(2)
6.3 Building a reactive database
170(11)
Populating a database reactively
172(3)
Writing bulk data
175(2)
Joining related database operations
177(3)
Reactive databases
180(1)
6.4 Summary
181(1)
7 Error handling with RxJS
182(27)
7.1 Common error-handling techniques
183(5)
Error handling with try/catch
183(1)
Delegating errors to callbacks
184(2)
Errors and Promises
186(2)
7.2 Incompatibilities between imperative error-handling techniques and functional and reactive code bases
188(1)
7.3 Understanding the functional error-handling approach
189(4)
7.4 The RxJS way of dealing with failure
193(15)
Errors propagated downstream to observers
193(2)
Catching and reacting to errors
195(2)
Retrying failed streams for a fixed number of times
197(2)
Reacting to failed retries
199(9)
7.5 Summary
208(1)
Part 3: Mastering RxJS 209(96)
8 Heating up observables
211(34)
8.1 Introducing hot and cold observables
212(5)
Cold observables
212(3)
Hot observables
215(2)
8.2 A new type of data source: WebSockets
217(4)
A brief look at WebSocket
218(1)
A simple WebSocket server in Node.js
219(1)
WebSocket client
220(1)
8.3 The impact of side effects on a resubscribe or a replay
221(5)
Replay vs. resubscribe
222(1)
Replaying the logic of a stream
222(2)
Resubscribing to a stream
224(2)
8.4 Changing the temperature of an observable
226(11)
Producers as thermometers
227(1)
Making a hot observable cold
228(2)
Making a cold observable hot
230(2)
Creating hot-by-operator streams
232(5)
8.5 Connecting one observable to many observers
237(6)
Publish
237(3)
Publish with replay
240(2)
Publish last
242(1)
8.6 Summary
243(2)
9 Toward testable, reactive programs
245(26)
9.1 Testing is inherently built into functional programs
246(4)
9.2 Testing asynchronous code and promises
250(5)
Testing AJAX requests
250(3)
Working with Promises
253(2)
9.3 Testing reactive streams
255(3)
9.4 Making streams testable
258(2)
9.5 Scheduling values in RxJS
260(3)
9.6 Augmenting virtual reality
263(7)
Playing with marbles
264(2)
Fake it 'til you make it
266(1)
Refactoring your search stream for testability
267(3)
9.7 Summary
270(1)
10 RxJS in the wild
271(34)
10.1 Building a basic banking application
273(1)
10.2 Introduction to React and Redux
274(12)
Rendering UI components with React
274(10)
State management with Redux
284(2)
10.3 Redux-ing application state
286(4)
Actions and reducers
286(1)
Redux store
287(3)
10.4 Building a hot RxJS and Redux store adapter
290(1)
10.5 Asynchronous middleware with RxJS Subject
291(11)
RxJS subjects
294(2)
Building epic, reactive middleware
296(6)
10.6 Bringing it all home
302(2)
10.7 Parting words
304(1)
10.8 Summary
304(1)
Appendix A: Installation Of Libraries Used In This Book 305(5)
Appendix B Choosing An Operator 310(5)
Index 315
AUTHOR BIO





Paul P. Daniels is a professional Software Engineer with a B.S.E in

Computer Science and over 5 years of experience in software engineering,

developing applications in .Net, Java, and JavaScript. A regular user of

RxJS, he is active as a member and a contributor in the RxJS community.





Luis Atencio is a Staff Software Engineer for Citrix Systems. He has a B.S.

and an M.S. in Computer Science and works full-time developing and

architecting web applications using Java, PHP, and JavaScript platforms.

Luis is also the author of Functional Programming in JavaScript.
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97816383517026e.html
Märksõnad: