Review (Quiz)

This lesson contains all of the recap quizzes from all of the lessons in this module. I have added headers to each group of quizzes so that you know which lesson to go back and study if you get stuck. Good luck!

What is an Observable?

Which of the following is NOT a reasonable description of the observer pattern?

A way to connect a producer of values to observers of those values
A way to notify one or more observers of multiple values emitted over time
A way to break up data and stream it in “chunks” to improve performance

What methods does an Observer implement?

notify, subscribe, delete
next, error, complete
next, subscribe, unsubscribe

How do we pass an Observer to an Observable?

By calling the next method
By passing it to the subscribe method of the observable
By creating a new instance of an observable and passing it through the constructor

Which of the following is NOT the role of an Observable?

To produce values to pass to an observer
To define what to do with values that are produced
To call the next method on an observer when a new value is produced

What is one key difference between cold/unicast and hot/multicast observables?

Cold observables produce values from within the observable, hot observables produce values from outside of the observable stream
Cold observables only produce one value, hot observables can produce multiple values over time
Hot observables are more performant than cold observables

A (standard) Observable is a…

Cold/unicast observable
Hot/multicast observable

A Subject is a…

Cold/unicast observable
Hot/multicast observable

How do we define the value production logic for a cold Observable?

By supplying a function that accepts an observer to the “next” method
By supplying a function that accepts an observer when creating an new instance of an Observable
By calling the next method from outside of the observable

How do we define the value production logic for a hot Observable (e.g. a Subject)?

By calling the next method from outside of the Subject
By supplying a function that accepts an observer when creating an new instance of a Subject
By supplying a function that accepts an observer to the next method

An Introduction to RxJS

What are the two types of operators RxJS provides?

Hot operators and cold operators
Creation operators and pipeable operators
Observable operators and subject operators

What does a creation operator do?

Accepts some input and creates a new observable based on that input
Subscribes to an observable and returns a new observable
Modifies an observable stream in some way

What does a pipeable operator do?

Modifies an existing stream to return new values
Accepts some input and returns a new observable

Which of the following is the correct usage of a pipeable operator?

someStream$.map().tap()
someStream$.pipe(map(), tap())
someStream$.pipe().map().tap()

Commonly Used Operators

Which operator allows us to modify individual stream emissions?

tap()
map()
filter()

Which of the following can NOT prevent some stream emissions?

map()
filter()
distinctUntilChanged()

In relation to combineLatest, which of the following statements are FALSE

It will emit when all of its input streams have emitted at least once
After the first emission, it will emit latest values from all streams whenever any of them change
It will only emit the data for streams whose values have changed

Which of the following most accurately describes catchError

It is used to log error messages from streams
It will catch any errors and can return a new stream to replace the errored stream
It will catch any errors to prevent the stream from breaking

Higher Order Observables

Which of the following best describes a higher-order observable?

An observable that emits functions
An observable that can not use pipeable operators
An observable that emits observables

What types of operators do we use to deal with higher-order observables?

Higher-order operators
Flattening operators
Creation operators

Which operator should you use if you need the results from all inner observables in order?

mergeMap()
concatMap()
exhaustMap()

Which operator should you use if you only need the result from the latest inner observable?

switchMap()
exhaustMap()
mergeMap()

Which operator should you use if you only care about the current inner observable?

exhaustMap()
switchMap()
mergeMap()

Which operator should you use if you want all results as quick as possible, disregarding order?

concatMap()
switchMap()
mergeMap()

Coding Reactively/Declaratively in Angular

What are the two types of reactive systems used in Angular?

Static and dynamic
Transparent and reified
Opaque and concrete

What is the defining characteristic of transparent reactivity?

We only deal with whatever the latest value is
We deal with all values at once
We can see the history of all values

What is the defining characteristic of reified reactivity?

We use the EventEmitter observable stream
We only deal with the latest value
We deal with the object representing the act of observation of value changes

Which of the following is the best description for what makes something declarative?

It can be modified after its declaration
We can understand what it is just by looking at its declaration
It does not have any dependencies

The Importance of the Async Pipe

Which of the following is NOT a good reason to use the async pipe?

So that we do not have to manually unsubscribe from streams
To combine multiple streams together
To keep data in streams for as long as possible

You should NEVER manually subscribe to a stream

True
False

Previous
Handling Manual Subscriptions Next
What is State?