RxJS: Reactive Programming in JavaScript

Doe praktijkgerichte kennis op van reactive programming met RxJS

Beschrijving

We verwachten dat onze applicaties responsive, resilient en robuust zijn. Maar hoe bereiken we dit? Door gebruik te maken van reactive programming!

RxJS is de library voor reactive programming in JavaScript. In deze training leer je wat het is en hoe je het moet gebruiken, allemaal met behulp van meest recente RxJS-release en TypeScript als programmeertaal.

Je leert eerst over het probleem dat RxJS voor je oplost. Vervolgens zullen we meer te weten komen over observables, de kern van RxJS.

Met die kennis ben je klaar om streams samen te stellen met behulp van operators. We richten ons niet op het uit het hoofd leren van de eindeloze lijst van operators, maar in plaats daarvan leer je hoe je de juiste operator voor jouw use case kunt vinden. Je leert ook je eigen custom operator te implementeren.

Daarna zullen we onze focus richten op resiliency: hoe kunnen we onze applicatie fault-tolerant maken?-- Je leert de verschillende strategieën voor het afhandelen van errors en retry mechanismen.

Ten slotte leer je het begrip subjects en welk probleem ze proberen op te lossen. We zullen hier de verschillende varianten bekijken, met de nadruk op het BehaviourSubject, omdat we dat zullen gebruiken om een typisch reactive design pattern te implementeren: een centralized store.

Onderwerpen

1. Context
2. Observables
3. Operators
4. Error handling
5. Subjects

In this chapter, you will learn what where RxJS came from and what problem it is trying to solve.

• Learn the origin of Reactive Programming
• Know who is behind RxJS at the moment
• Understand which desing patterns relate to reactive programming.
• Learn the differences between a Promise and an Observable

In this chapter, you will learn what an Observable is and how it relates to "streams". We will be creating our own Observables and learn about creation operators.

• Learn what streams are and how to recognize them in your JS application.
• Learn how a stream relates to an Observable
• Know how to create our own Observables using the contructor.
• Learn some of the creation operators, like from and fromEvent, and use them to create Observables
• Know what the "Observable contract" is and what guarantees it brings.
• Know what an arrow function is and why we use them instead of methods.
• Implement HTTP calls using your own observables.

In this chapter you will learn what operators are and how to select the right operator for the job.

• Know why we use operators
• Learn to implement a reactive design.
• Learn what an operator is exactly.
• Learn some common operators like map, filter, switchMap, mergeMap and combineWithLatest
• Learn the different ways of implementing our own custom operators.
• Implement a search-as-you-type use case in an application where you combine everything you've learned.

In this chapter you will learn the different kinds of error handling strategies.

• Know what happens when we don't handle error.
• Learn 3 error handling strategies and how to implement them
• Implement your own retry mechanism.

In this chapter you will earn what a Subject is and when it is useful. You will end by learning a very common reactive pattern: the store pattern.

• Know what problem RxJS subjects solve.
• Learn what the different variants of subjects are.
• Focus on the BehaviorSubject as a way to hold our application's state
• Learn what a "Store pattern" is and how to implement it in a JS application.
• Implement your own store in a JS application using subjects.
• Implement a Router using RxJS observables and subjects.