Angular test question 2 Flashcards
Pipe, router, directives, custom elements, observables
What is a parameterized pipe?
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 do you chain pipes?
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);
}
What is a custom pipe?
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}}
Give an example of custom pipe?
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>
`
What is the difference between pure and impure pipe?
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.
What is a bootstrapping module?
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 { }
What are observables?
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.
What is HttpClient and its benefits?
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
Explain on how to use HttpClient with an example?
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 can you read full response?
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 do you perform Error handling?
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.
What is subscribing?
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
What is an observable?
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);
});
What is an observer?
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.
What is the difference between promise and observable?
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
What is multicasting?
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
How do you perform error handling in observables?
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)}
});
What is the shorthand notation for subscribe method?
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’)
);
What will happen if you do not supply handler for the observer?
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.
What are Angular elements?
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.
Explain how custom elements works internally?
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,
How to transfer components to custom elements?
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.
What are the mapping rules between Angular component and custom element?
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”.
How do you define typings for custom elements?
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.
Highlight me!
Run the application to see the highlight behavior on paragraph element ng serve
