Gain insights into reactive programming with RxJS 7, explore data streams, error handling, and multicasting to build a recipe app, and learn to test and optimize reactive applications.

angular.tar.gz

angular04

angular05

angular06

coderun

angular04-copy

test

angular07

angular09

angular10

angular11

angular12

angular13

angular13-test

The reactive programming paradigm is designed to make working with asynchronous events and data streams convenient. 

This course teaches you about the reactive programming paradigm and when to choose it over others. You’ll learn to use new RxJS 7 features to create a recipe book web application that lets users browse and share recipes. In this context, you’ll learn about data streams, error handling, and how to combine streams and transform one data stream into another. You’ll develop an understanding of multicasting and caching streams, how to share data between components, perform bulk operations such as file uploads, and perform real-time updates. Finally, you’ll learn how to test a reactive application. To assess your knowledge, there’s a project, coding challenges, and assessments.

After this course, you’ll be able to determine the utility of the reactive paradigm for any application and have mastery over new RxJS 7 features to create robust reactive applications.

Reactive Programming with Angular and RxJS 7

What are the two final statuses of an observable's life cycle?

What are the two final statuses of an observable’s life cycle?

What are the three callbacks associated with the `subscribe()` method in RxJS?

What are the three callbacks associated with the <code>subscribe()</code> method in RxJS?

Replace the errored-out observable with a fallback observable.

Handle errors locally within the observable chain.

Propagate the caught error to the subscribers of the output observable.

Retry the observable a specific number of times.

What is the purpose of a rethrow strategy in error handling using RxJS?

What is the purpose of a rethrow strategy in error handling using RxJS?

Delay the emission of values from the source observable.

Transform emitted values using a specified callback.

Retry the source observable a specific number of times.

What is the purpose of the `retry` operator in RxJS?

What is the purpose of the <code>retry</code> operator in RxJS?

Our code subscribes to an observable. The error-handling function returns a new observable. Which strategy could this possibly be?

Our code subscribes to an observable. The error-handling function returns a new observable. Which strategy could this possibly be?

Which strategy does the following code use?
```
const { from, of } = require('rxjs');
const { catchError, map } = require('rxjs/operators');

const stream$ = from([1, 2, 3, "Hi", 5, "Hello", 6]);

stream$
  .pipe(
    map((value) => {
      if (isNaN(value)) {
        throw new Error("This is not a valid number");
      }
      return value * 2; // Double the valid numbers
    }),
    catchError((error) => {
      console.log("Caught Error:", error.message);
      return of(); // Replace the error with an empty observable
    })
  )
  .subscribe({
    next: (res) => console.log("Doubled Value:", res),
    error: (err) => console.log("Error Occurred:", err),
    complete: () => console.log("Stream Completed"),
  });
```

Which strategy does the following code use?
<pre><code>const { from, of } = require('rxjs');
const { catchError, map } = require('rxjs/operators');

const stream$ = from([1, 2, 3, &quot;Hi&quot;, 5, &quot;Hello&quot;, 6]);

stream$
 .pipe(
 map((value) =&gt; {
 if (isNaN(value)) {
 throw new Error(&quot;This is not a valid number&quot;);
 }
 return value * 2; // Double the valid numbers
 }),
 catchError((error) =&gt; {
 console.log(&quot;Caught Error:&quot;, error.message);
 return of(); // Replace the error with an empty observable
 })
 )
 .subscribe({
 next: (res) =&gt; console.log(&quot;Doubled Value:&quot;, res),
 error: (err) =&gt; console.log(&quot;Error Occurred:&quot;, err),
 complete: () =&gt; console.log(&quot;Stream Completed&quot;),
 });
</code></pre>

Getting Started

The Power of the Reactive Paradigm

RxJS 7—The Major Features

A Walk-Through of the Application

Fetching Data as Streams

Error Handling

Combining Streams

Assessment 1

Transforming Streams

Multicasting Essentials

Caching Streams

Sharing Data between Components

Bulk Operations

Processing Real-Time Updates

Testing RxJS Observables

Assessment 2

Conclusion

Quiz: Error Handling