Angular test question 2 Flashcards

Pipe, router, directives, custom elements, observables

1
Q

What is a parameterized pipe?

A

A pipe can accept any number of optional parameters to fine-tune its output. The parameterized pipe can be created by declaring the pipe name with a colon ( : ) and then the parameter value. If the pipe accepts multiple parameters, separate the values with colons. Let’s take a birthday example with a particular format(dd/MM/yyyy):

import { Component } from ‘@angular/core’;

@Component({
  selector: 'app-birthday',
  template: `<p>Birthday is {{ birthday | date:'dd/MM/yyyy'}}</p>` // 18/06/1987
})
export class BirthdayComponent {
  birthday = new Date(1987, 6, 18);
} Note: The parameter value can be any valid template expression, such as a string literal or a component property.
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
2
Q

How do you chain pipes?

A

You can chain pipes together in potentially useful combinations as per the needs. Let’s take a birthday property which uses date pipe(along with parameter) and uppercase pipes as below

import { Component } from ‘@angular/core’;

    @Component({
      selector: 'app-birthday',
      template: `<p>Birthday is {{  birthday | date:'fullDate' | uppercase}} </p>` // THURSDAY, JUNE 18, 1987
    })
    export class BirthdayComponent {
      birthday = new Date(1987, 6, 18);
    }
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
3
Q

What is a custom pipe?

A

Apart from built-in pipes, you can write your own custom pipe with the below key characteristics:
A pipe is a class decorated with pipe metadata @Pipe decorator, which you import from the core Angular library For example,
@Pipe({name: ‘myCustomPipe’})
The pipe class implements the PipeTransform interface’s transform method that accepts an input value followed by optional parameters and returns the transformed value. The structure of PipeTransform would be as below,
interface PipeTransform {
transform(value: any, …args: any[]): any
}
The @Pipe decorator allows you to define the pipe name that you’ll use within template expressions. It must be a valid JavaScript identifier.
template: {{someInputValue | myCustomPipe: someOtherValue}}

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
4
Q

Give an example of custom pipe?

A

You can create custom reusable pipes for the transformation of existing value. For example, let us create a custom pipe for finding file size based on an extension,
import { Pipe, PipeTransform } from ‘@angular/core’;

@Pipe({name: ‘customFileSizePipe’})
export class FileSizePipe implements PipeTransform {
transform(size: number, extension: string = ‘MB’): string {
return (size / (1024 * 1024)).toFixed(2) + extension;
}
}
Now you can use the above pipe in template expression as below,
template: `
<h2>Find the size of a file</h2>
<p>Size: {{288966 | customFileSizePipe: ‘GB’}}</p>
`

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
5
Q

What is the difference between pure and impure pipe?

A

A pure pipe is only called when Angular detects a change in the value or the parameters passed to a pipe. For example, any changes to a primitive input value (String, Number, Boolean, Symbol) or a changed object reference (Date, Array, Function, Object). An impure pipe is called for every change detection cycle no matter whether the value or parameters changes. i.e, An impure pipe is called often, as often as every keystroke or mouse-move.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
6
Q

What is a bootstrapping module?

A

Every application has at least one Angular module, the root module that you bootstrap to launch the application is called as bootstrapping module. It is commonly known as AppModule. The default structure of AppModule generated by AngularCLI would be as follows:

import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { HttpClientModule } from '@angular/common/http';

import { AppComponent } from './app.component';

/* the AppModule class with the @NgModule decorator */
@NgModule({
  declarations: [
    AppComponent
  ],
  imports: [
    BrowserModule,
    FormsModule,
    HttpClientModule
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule { }
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
7
Q

What are observables?

A

Observables are declarative which provide support for passing messages between publishers and subscribers in your application. They are mainly used for event handling, asynchronous programming, and handling multiple values. In this case, you define a function for publishing values, but it is not executed until a consumer subscribes to it. The subscribed consumer then receives notifications until the function completes, or until they unsubscribe.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
8
Q

What is HttpClient and its benefits?

A

Most of the Front-end applications communicate with backend services over HTTP protocol using either XMLHttpRequest interface or the fetch() API. Angular provides a simplified client HTTP API known as HttpClient which is based on top of XMLHttpRequest interface. This client is available from @angular/common/http package. You can import in your root module as below:

import { HttpClientModule } from ‘@angular/common/http’;
The major advantages of HttpClient can be listed as below,

Contains testability features
Provides typed request and response objects
Intercept request and response
Supports Observalbe APIs
Supports streamlined error handling

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
9
Q

Explain on how to use HttpClient with an example?

A

Below are the steps need to be followed for the usage of HttpClient.
Import HttpClient into root module:
import { HttpClientModule } from ‘@angular/common/http’;
@NgModule({
imports: [
BrowserModule,
// import HttpClientModule after BrowserModule.
HttpClientModule,
],
……
})
export class AppModule {}
Inject the HttpClient into the application: Let’s create a userProfileService(userprofile.service.ts) as an example. It also defines get method of HttpClient:
import { Injectable } from ‘@angular/core’;
import { HttpClient } from ‘@angular/common/http’;

const userProfileUrl: string = ‘assets/data/profile.json’;

@Injectable()
export class UserProfileService {
constructor(private http: HttpClient) { }

getUserProfile() {
return this.http.get(this.userProfileUrl);
}
}
Create a component for subscribing service: Let’s create a component called UserProfileComponent(userprofile.component.ts), which injects UserProfileService and invokes the service method:
fetchUserProfile() {
this.userProfileService.getUserProfile()
.subscribe((data: User) => this.user = {
id: data[‘userId’],
name: data[‘firstName’],
city: data[‘city’]
});
}
Since the above service method returns an Observable which needs to be subscribed in the component.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
10
Q

How can you read full response?

A

The response body doesn’t or may not return full response data because sometimes servers also return special headers or status code, which are important for the application workflow. In order to get the full response, you should use observe option from HttpClient:

getUserResponse(): Observable<HttpResponse<User>> {
return this.http.get<User>(
this.userUrl, { observe: 'response' });
}
Now HttpClient.get() method returns an Observable of typed HttpResponse rather than just the JSON data.</User></User>

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
11
Q

How do you perform Error handling?

A

If the request fails on the server or fails to reach the server due to network issues, then HttpClient will return an error object instead of a successful reponse. In this case, you need to handle in the component by passing error object as a second callback to subscribe() method.

Let’s see how it can be handled in the component with an example,

fetchUser() {
this.userService.getProfile()
.subscribe(
(data: User) => this.userProfile = { …data }, // success path
error => this.error = error // error path
);
}
It is always a good idea to give the user some meaningful feedback instead of displaying the raw error object returned from HttpClient.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
12
Q

What is subscribing?

A

An Observable instance begins publishing values only when someone subscribes to it. So you need to subscribe by calling the subscribe() method of the instance, passing an observer object to receive the notifications.

Let’s take an example of creating and subscribing to a simple observable, with an observer that logs the received message to the console.

// Creates an observable sequence of 5 integers, starting from 1
const source = range(1, 5);

// Create observer object
const myObserver = {
next: x => console.log(‘Observer got a next value: ‘ + x),
error: err => console.error(‘Observer got an error: ‘ + err),
complete: () => console.log(‘Observer got a complete notification’),
};

// Execute with the observer object and Prints out each item
source.subscribe(myObserver);
// => Observer got a next value: 1
// => Observer got a next value: 2
// => Observer got a next value: 3
// => Observer got a next value: 4
// => Observer got a next value: 5
// => Observer got a complete notification

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
13
Q

What is an observable?

A

An Observable is a unique Object similar to a Promise that can help manage async code. Observables are not part of the JavaScript language so we need to rely on a popular Observable library called RxJS. The observables are created using new keyword.

Let see the simple example of observable,

import { Observable } from ‘rxjs’;

const observable = new Observable(observer => {
setTimeout(() => {
observer.next(‘Hello from a Observable!’);
}, 2000);
});

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
14
Q

What is an observer?

A

Observer is an interface for a consumer of push-based notifications delivered by an Observable. It has below structure,

interface Observer<T> {
closed?: boolean;
next: (value: T) => void;
error: (err: any) => void;
complete: () => void;
}
A handler that implements the Observer interface for receiving observable notifications will be passed as a parameter for observable as below,</T>

myObservable.subscribe(myObserver);
Note: If you don’t supply a handler for a notification type, the observer ignores notifications of that type.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
15
Q

What is the difference between promise and observable?

A

Below are the list of differences between promise and observable:

Observable Promise
Declarative: Computation does not start until subscription, so they can run whenever you need the result Executes immediately on creation
Provides multiple values over time Provides only one
Subscribe method is used for error handling that facilitates centralized and predictable error handling Push errors to the child promises
Provides chaining and subscription to handle complex applications Uses only .then() clause

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
16
Q

What is multicasting?

A

Multi-casting is the practice of broadcasting to a list of multiple subscribers in a single execution.

Let’s demonstrate the multi-casting feature:

var source = Rx.Observable.from([1, 2, 3]);
var subject = new Rx.Subject();
var multicasted = source.multicast(subject);

// These are, under the hood, subject.subscribe({...}):
multicasted.subscribe({
next: (v) => console.log(‘observerA: ‘ + v)
});
multicasted.subscribe({
next: (v) => console.log(‘observerB: ‘ + v)
});

// This is, under the hood, `s

17
Q

How do you perform error handling in observables?

A

You can handle errors by specifying an error callback on the observer instead of relying on try/catch, which are ineffective in asynchronous environment.

For example, you can define error callback as below,

myObservable.subscribe({
next(num) { console.log(‘Next num: ‘ + num)},
error(err) { console.log(‘Received an errror: ‘ + err)}
});

18
Q

What is the shorthand notation for subscribe method?

A

The subscribe() method can accept callback function definitions in line, for next, error, and complete handlers. It is known as shorthand notation or Subscribe method with positional arguments.

For example, you can define subscribe method as below,

myObservable.subscribe(
x => console.log(‘Observer got a next value: ‘ + x),
err => console.error(‘Observer got an error: ‘ + err),
() => console.log(‘Observer got a complete notification’)
);

19
Q

What will happen if you do not supply handler for the observer?

A

Usually, an observer object can define any combination of next, error, and complete notification type handlers. If you don’t supply a handler for a notification type, the observer just ignores notifications of that type.

20
Q

What are Angular elements?

A

Angular elements are Angular components packaged as custom elements (a web standard for defining new HTML elements in a framework-agnostic way). Angular Elements host an Angular component, providing a bridge between the data and the logic defined in the component and the standard DOM APIs, thus, providing a way to use Angular components in non-Angular environments.

21
Q

Explain how custom elements works internally?

A

App registers custom element with browser: Use the createCustomElement() function to convert a component into a class that can be registered with the browser as a custom element.
App adds custom element to DOM: Add custom element just like a built-in HTML element directly into the DOM.
Browser instantiate component based class: Browser creates an instance of the registered class and adds it to the DOM.
Instance provides content with data binding and change detection: The content with in template is rendered using the component and DOM data. The flow chart of the custom elements functionality would be as follows,

22
Q

How to transfer components to custom elements?

A

Transforming components to custom elements involves two major steps,

Build custom element class: Angular provides the createCustomElement() function for converting an Angular component (along with its dependencies) to a custom element. The conversion process implements NgElementConstructor interface, and creates a constructor class which is used to produce a self-bootstrapping instance of Angular component.
Register element class with browser: It uses customElements.define() JS function, to register the configured constructor and its associated custom-element tag with the browser’s CustomElementRegistry. When the browser encounters the tag for the registered element, it uses the constructor to create a custom-element instance.

23
Q

What are the mapping rules between Angular component and custom element?

A

The Component properties and logic maps directly into HTML attributes and the browser’s event system. Let us describe them in two steps,
The createCustomElement() API parses the component input properties with corresponding attributes for the custom element. For example, component @Input(‘myInputProp’) converted as custom element attribute my-input-prop.
The Component outputs are dispatched as HTML Custom Events, with the name of the custom event matching the output name. For example, component @Output() valueChanged = new EventEmitter() converted as custom element with dispatch event as “valueChanged”.

24
Q

How do you define typings for custom elements?

A

You can use the NgElement and WithProperties types exported from @angular/elements.

Let’s see how it can be applied by comparing with Angular component.

The simple container with input property would be as below,
@Component(…)
class MyContainer {
@Input() message: string;
}
After applying types typescript validates input value and their types,
const container = document.createElement(‘my-container’) as NgElement & WithProperties<{message: string}>;
container.message = ‘Welcome to Angular elements!’;
container.message = true; // <– ERROR: TypeScript knows this should be a string.
container.greet = ‘News’; // <– ERROR: TypeScript knows there is no greet property on container.

25
Q

What are dynamic components?

A

Dynamic components are the components in which the component’s location in the application is not defined at build time i.e. they are not used in any angular template. Instead, the component is instantiated and placed in the application at runtime.

26
Q

What are the various kinds of directives?

A

There are mainly three kinds of directives:
Components — These are directives with a template.
Structural directives — These directives change the DOM layout by adding and removing DOM elements.
Attribute directives — These directives change the appearance or behavior of an element, component, or another directive.

27
Q

Give an example for attribute directives?

A

Let’s take simple highlighter behavior as a example directive for DOM element. You can create and apply the attribute directive using below step:

Create HighlightDirective class with the file name src/app/highlight.directive.ts. In this file, we need to import Directive from core library to apply the metadata and ElementRef in the directive’s constructor to inject a reference to the host DOM element ,
import { Directive, ElementRef } from ‘@angular/core’;

@Directive({
selector: ‘[appHighlight]’
})
export class HighlightDirective {
constructor(el: ElementRef) {
el.nativeElement.style.backgroundColor = ‘red’;
}
}
Apply the attribute directive as an attribute to the host element(for example,
)

<p>Highlight me!</p>

Run the application to see the highlight behavior on paragraph element
ng serve

28
Q

What is Angular Router?

A

Angular Router is a mechanism in which navigation happens from one view to the next as users perform application tasks. It borrows the concepts or model of browser’s application navigation. It enables developers to build Single Page Applications with multiple views and allow navigation between these views.

29
Q

What is the purpose of base href tag?

A

The routing application should add element to the index.html as the first child in the tag in order to indicate how to compose navigation URLs. If app folder is the application root then you can set the href value as below

<base></base>

30
Q

What are the router imports?

A

What are the router imports?

The Angular Router which represents a particular component view for a given URL is not part of Angular Core. It is available in library named @angular/router to import required router components. For example, we import them in app module as below,

import { RouterModule, Routes } from ‘@angular/router’;