Angular RxJS

Question 1

RxJS is Reactive Extension for Javascript is a library …

Answer 1

for composing asynchronous and event-based programs by using observable sequences

Question 2

RxJs is so useful that angular implemented it in its features

Answer 2

Routing,
Reactive Forms,
HttpClient

Question 3

Observer is an object that monitors a stream. Observer response to notifications:

Answer 3

• next() - handle next item emitted in the steam
• error() - handle errors
• complete() - perform final processing or cleanup when stream is complete

Question 4

Observer is

Answer 4

a collection of callbacks that knows how to listen to values delivered by the observable

Question 5

An observer is a

Answer 5

javascript object that defines the handlers for the notificatoins you receive

Question 6

In RxJS an Observer is

Answer 6

also defined as an interface with next, error and complete methods

Question 7

Var vs let vs const

Answer 7

var declarations are globally scoped or function scoped while let and const are block scoped.
var variables can be updated and re-declared within its scope; let variables can be updated but not re-declared; const variables can neither be updated nor re-declared.
They are all hoisted to the top of their scope. But while var variables are initialized with undefined, let and const variables are not initialized.
While var and let can be declared without being initialized, const must be initialized during declaration.

Question 8

Observables are lazy and they

Answer 8

don’t execute when defined. Only when subscribed

Question 9

Observer is

Answer 9

set of callbacks to observe handling next, error and complete

Question 10

Observable is (or stream)

Answer 10

sequence of emitted items

Question 11

In how main ways an observer can be stopped

Answer 11

• Call complete method
• Using completing operator (of, for, take)
• Throw an error, does not call complete
• Unsubscribe, does not call complete

Question 12

Unsubscribing from observable that does not complete on it’s own helps us with

Answer 12

avoiding memory leaks in the application

Question 13

In angular we often work with observables that angular create for us

Question 14

Creating an observable (recommendet technique) is to use

Answer 14

a built-in creating function

Question 15

Funciton of(‘Apple1’, ‘Apple2’) is

Answer 15

is creating an observable using a set of items emitting each value and then completing the stream

Question 16

from([‘ads’, ‘we’]) does

Answer 16

creates an observable from an array or other data structure, emitting each individual value from that structure and then completing the stream

Question 17

of and from are static functions

Question 18

of vs from
const apples = ['Apple1', 'Apple2'];

Answer 18

of(apples) // [Apple1, Apple2]
of(…apples) // Apple1, Apple2
from(apples) // Apple1, Apple2

Question 19

few ways for Creating an observable

Answer 19

• fromEvent - creates an observable from any document, object model or or DOM event
• inverval(1000) - emits sequential number at a defined interval

Question 20

Observable is

Answer 20

any stream of data

Question 21

Observer is

Answer 21

Observers the stream

Methods to process notifications from the stream are next, error, complete

Question 22

Subscriber is

Answer 22

an observer that can unsebscribe

Question 23

Subscription is

Answer 23

represents the execution of an observable.

subscribe() returns a subscription and we then can ubsubscribe

Question 24

Creating an observable can be done through

Answer 24

• Constructor - bad technique
• Creating functions - of, from ,from event, interval ….
• Create an observable form anything
• Returned from an angular feature
  - Forms - valuechanges
  - Routing: paramMap
  - Http: get
  - …….

Question 25

To avoid memory leaks we should

Answer 25

always stop our observables.
Call complete()
of, from ... automatically unsubscribe  and execute complete().
Throwing an error also unsubscribed
sub.unsubscribe()

Question 26

RxJS operator is a function that

Answer 26

transforms and manipulates items in an observable stream.

They are applied by using the observable pipe method

Question 27

async pipe

Answer 27

Automatically subscribes to the observable when the component is initialized.
Returns each emitted value.
When a new item is emitted, component is marked to be checked for changes.
Unsubscribes automatically when component is destroyed

Question 28

What is the difference between an Observable and a function?

Answer 28

Observables can “return” multiple values over time, something which functions cannot.