Angular Interview Question for Fresher & Experienced UI/UX Developer
104. What are a service worker and its role in Angular?
A service worker is a script that runs in the
web browser and manages caching for an application. Starting from 5.0.0
version, Angular ships with a service worker implementation. The angular service
worker is designed to optimize the end-user experience of using an application
over a slow or unreliable network connection, while also minimizing the risks
of serving outdated content.
105. What are the design goals of service workers?
Below is the list of design goals of
Angular's service workers,
iii.
It caches an application
just like installing a native application
iv.
A running application
continues to run with the same version of all files without any incompatible
files
v.
When you refresh the
application, it loads the latest fully cached version
vi.
When changes are
published then it immediately updates in the background
vii.
Service workers save
the bandwidth by downloading the resources only when they changed.
106. What
are the differences between AngularJS and Angular with respect to dependency injection?
Dependency injection is a common component in
both AngularJS and Angular, but there are some key differences between the two
frameworks in how it actually works. | AngularJS | Angular | |---- | ---------
| Dependency injection tokens are always strings | Tokens can have different
types. They are often classes and sometimes can be strings. | | There is
exactly one injector even though it is a multi-module applications | There is a
tree hierarchy of injectors, with a root injector and an additional injector
for each component. |
107. What
is Angular Ivy?
Angular Ivy is a new rendering engine for
Angular. You can choose to opt in a preview version of Ivy from Angular version
8.
.
You can enable ivy in
a new project by using the --enable-ivy flag with the ng new command
ng new ivy-demo-app --enable-ivy
ii.
You can add it to an
existing project by adding enableIvy option in the angularCompilerOptions in your project's tsconfig.app.json.
{
"compilerOptions": { ... },
"angularCompilerOptions": {
"enableIvy": true
}
}
108. What are the features included in ivy preview?
You can expect below features with Ivy
preview,
ii.
Generated code that is
easier to read and debug at runtime
iii.
Faster re-build time
iv.
Improved payload size
v.
Improved template type
checking
109. Can
I use AOT compilation with Ivy?
Yes, it is a recommended configuration. Also,
AOT compilation with Ivy is faster. So you need set the default build
options(with in angular.json) for your project to always use AOT compilation.
{
"projects": {
"my-project": {
"architect": {
"build": {
"options": {
...
"aot": true,
}
}
}
}
}
}
110. What
is Angular Language Service?
The Angular Language Service is a way to get
completions, errors, hints, and navigation inside your Angular templates
whether they are external in an HTML file or embedded in annotations/decorators
in a string. It has the ability to autodetect that you are opening an Angular
file, reads your tsconfig.json file, finds all the templates you have
in your application, and then provides all the language services.
111. How
do you install angular language service in the project?
You can install Angular Language Service in
your project with the following npm command
npm install --save-dev @angular/language-service
After that add the following to the
"compilerOptions" section of your project's tsconfig.json
"plugins": [
{"name": "@angular/language-service"}
]
Note: The completion and diagnostic services
works for .ts files only. You need to use custom plugins for supporting HTML
files.
112. Is
there any editor support for Angular Language Service?
Yes, Angular Language Service is currently
available for Visual Studio Code and WebStorm IDEs. You need to install angular
language service using an extension and devDependency respectively. In sublime
editor, you need to install typescript which has has a language service plugin
model.
Explain
the features provided by Angular Language Service?
Basically there are 3 main features provided
by Angular Language Service,
.
Autocompletion: Autocompletion can speed up your development time by
providing you with contextual possibilities and hints as you type with in an
interpolation and elements.
ii.
Error checking: It can also warn you of mistakes in your code.
iii.
Navigation: Navigation
allows you to hover a component, directive, module and then click and press F12
to go directly to its definition.
113. How do you add web workers in your
application?
You can add web worker anywhere in your
application. For example, If the file that contains your expensive computation
is src/app/app.component.ts, you can add a Web Worker using ng generate web-worker app command which will create src/app/app.worker.ts web worker file. This command will perform below actions,
iii.
Configure your project
to use Web Workers
iv.
Adds app.worker.ts to
receive messages
addEventListener('message', ({ data }) => {
const response = `worker response to ${data}`;
postMessage(response);
});
iii.
The component app.component.ts file
updated with web worker file
if (typeof Worker !== 'undefined') {
// Create a new
const worker = new Worker('./app.worker', { type: 'module' });
worker.onmessage = ({ data }) => {
console.log('page got message: $\{data\}');
};
worker.postMessage('hello');
} else {
// Web Workers are not supported in this environment.
}
Note: You may need to refactor your initial
scaffolding web worker code for sending messages to and from.
114. What are the limitations with web workers?
You need to remember two important things when
using Web Workers in Angular projects,
iii.
Some environments or
platforms(like @angular/platform-server) used in Server-side Rendering, don't
support Web Workers. In this case you need to provide a fallback mechanism to
perform the computations to work in this environments.
iv.
Running Angular in web
worker using @angular/platform-webworker is not yet supported in Angular CLI.
115. What
is Angular CLI Builder?
In Angular8, the CLI Builder API is stable and
available to developers who want to customize the Angular CLI by
adding or modifying commands. For example, you could supply a builder to
perform an entirely new task, or to change which third-party tool is used by an
existing command.
116. What
is a builder?
A builder function ia a function that uses
the Architect API to perform a complex process such as "build" or
"test". The builder code is defined in an npm package. For example,
BrowserBuilder runs a webpack build for a browser target and KarmaBuilder
starts the Karma server and runs a webpack build for unit tests.
117. How
do you invoke a builder?
The Angular CLI command ng run is used to
invoke a builder with a specific target configuration. The workspace
configuration file, angular.json, contains default configurations for built-in
builders.
118. How
do you create app shell in Angular?
An App shell is a way to render a portion of
your application via a route at build time. This is useful to first paint of
your application that appears quickly because the browser can render static
HTML and CSS without the need to initialize JavaScript. You can achieve this
using Angular CLI which generates an app shell for running server-side of your
app.
ng generate appShell [options] (or)
ng g appShell [options]
119. What
are the case types in Angular?
Angular uses capitalization conventions to
distinguish the names of various types. Angular follows the list of the below
case types.
.
camelCase : Symbols,
properties, methods, pipe names, non-component directive selectors, constants
uses lowercase on the first letter of the item. For example,
"selectedUser"
i.
UpperCamelCase (or PascalCase): Class names, including classes that
define components, interfaces, NgModules, directives, and pipes uses uppercase
on the first letter of the item.
ii.
dash-case (or "kebab-case"): The descriptive part of file names,
component selectors uses dashes between the words. For example,
"app-user-list".
iii.
UPPER_UNDERSCORE_CASE: All constants uses capital letters connected with
underscores. For example, "NUMBER_OF_USERS".
120. What
are the class decorators in Angular?
A class decorator is a decorator that appears
immediately before a class definition, which declares the class to be of the
given type, and provides metadata suitable to the type The following list of
decorators comes under class decorators,
.
@Component()
i.
@Directive()
ii.
@Pipe()
iii.
@Injectable()
iv.
@NgModule()
121. What
are class field decorators?
The class field decorators are the statements
declared immediately before a field in a class definition that defines the type
of that field. Some of the examples are: @input and @output,
@Input() myProperty;
@Output() myEvent = new EventEmitter();
122. What
is declarable in Angular?
Declarable is a class type that you can add to
the declarations list of an NgModule. The class types such as components,
directives, and pipes comes can be declared in the module.
123. What
are the restrictions on declarable classes?
Below classes shouldn't be declared,
.
A class that's already
declared in another NgModule
i.
Ngmodule classes
ii.
Service classes
iii.
Helper classes
124. What
is a DI token?
A DI token is a lookup token associated with a
dependency provider in dependency injection system. The injector maintains an
internal token-provider map that it references when asked for a dependency and
the DI token is the key to the map. Let's take example of DI Token usage,
const BASE_URL = new InjectionToken<string>('BaseUrl');
const injector =
Injector.create({providers: [{provide: BASE_URL, useValue: 'http://some-domain.com'}]});
const url = injector.get(BASE_URL);
125. What
is Angular DSL?
A domain-specific language (DSL) is a computer
language specialized to a particular application domain. Angular has its own
Domain Specific Language (DSL) which allows us to write Angular specific
html-like syntax on top of normal html. It has its own compiler that compiles
this syntax to html that the browser can understand. This DSL is defined in
NgModules such as animations, forms, and routing and navigation. Basically you
will see 3 main syntax in Angular DSL.
.
(): Used for Output and DOM events.
i.
[]: Used for Input and specific DOM element attributes.
ii.
*: Structural directives(*ngFor or *ngIf) will affect/change the
DOM structure.
126. what
is an rxjs subject in Angular
An RxJS Subject is a special type of
Observable that allows values to be multicasted to many Observers. While plain
Observables are unicast (each subscribed Observer owns an independent execution
of the Observable), Subjects are multicast.
A Subject is like an Observable, but can
multicast to many Observers. Subjects are like EventEmitters: they maintain a
registry of many listeners.
import { Subject } from 'rxjs';
const subject = new Subject<number>();
subject.subscribe({
next: (v) => console.log(`observerA: ${v}`)
});
subject.subscribe({
next: (v) => console.log(`observerB: ${v}`)
});
subject.next(1);
subject.next(2);
127. What
is Bazel tool?
Bazel is a powerful build tool developed and
massively used by Google and it can keep track of the dependencies between
different packages and build targets. In Angular8, you can build your CLI
application with Bazel. Note: The Angular framework itself is built with Bazel.
128. What
are the advantages of Bazel tool?
Below are the list of key advantages of Bazel
tool,
.
It creates the
possibility of building your back-ends and front-ends with the same tool
i.
The incremental build
and tests
ii.
It creates the
possibility to have remote builds and cache on a build farm.
129. How
do you use Bazel with Angular CLI?
The @angular/bazel package provides a builder
that allows Angular CLI to use Bazel as the build tool.
.
Use in an existing applciation: Add @angular/bazel using CLI
ng add @angular/bazel
ii.
Use in a new application: Install the package and create the application with
collection option
npm install -g @angular/bazel
ng new --collection=@angular/bazel
When you use ng build and ng serve commands,
Bazel is used behind the scenes and outputs the results in dist/bin folder.
130. How do you run Bazel directly?
Sometimes you may want to bypass the Angular
CLI builder and run Bazel directly using Bazel CLI. You can install it globally
using @bazel/bazel npm package. i.e, Bazel CLI is available under @bazel/bazel
package. After you can apply the below common commands,
bazel build [targets] // Compile the default output
artifacts of the given targets.
bazel test [targets] // Run the tests with *_test
targets found in the pattern.
bazel run [target]: Compile the program represented by
target and then run it.
131. What is platform in Angular?
A platform is the context in which an Angular
application runs. The most common platform for Angular applications is a web
browser, but it can also be an operating system for a mobile device, or a web
server. The runtime-platform is provided by the @angular/platform-* packages
and these packages allow applications that make use of @angular/core and @angular/common to
execute in different environments. i.e, Angular can be used as
platform-independent framework in different environments, For example,
ii.
While running in the
browser, it uses platform-browser package.
iii.
When SSR(server-side
rendering ) is used, it uses platform-server package for providing web server
implementation.
132. What
happens if I import the same module twice?
If multiple modules import the same module
then angular evaluates it only once (When it encounters the module first time).
It follows this condition even the module appears at any level in a hierarchy
of imported NgModules.
133. How
do you select an element with in a component template?
You can use @ViewChild directive to
access elements in the view directly. Let's take input element with a
reference,
<input #uname>
and define view child directive and access it
in ngAfterViewInit lifecycle hook
@ViewChild('uname') input;
ngAfterViewInit() {
console.log(this.input.nativeElement.value);
}
134. How
do you detect route change in Angular?
In Angular7, you can subscribe to router to
detect the changes. The subscription for router events would be as below,
this.router.events.subscribe((event: Event) => {})
Let's take a simple component to detect router
changes
import { Component } from '@angular/core';
import { Router, Event, NavigationStart, NavigationEnd, NavigationError } from '@angular/router';
@Component({
selector: 'app-root',
template: `<router-outlet></router-outlet>`
})
export class AppComponent {
constructor(private router: Router) {
this.router.events.subscribe((event: Event) => {
if (event instanceof NavigationStart) {
// Show loading indicator and perform an action
}
if (event instanceof NavigationEnd) {
// Hide loading indicator and perform an action
}
if (event instanceof NavigationError) {
// Hide loading indicator and perform an action
console.log(event.error); // It logs an error for debugging
}
});
}
}
135. How
do you pass headers for HTTP client?
You can directly pass object map for http
client or create HttpHeaders class to supply the headers.
constructor(private _http: HttpClient) {}
this._http.get('someUrl',{
headers: {'header1':'value1','header2':'value2'}
});
(or)
let headers = new HttpHeaders().set('header1', headerValue1); // create header object
headers = headers.append('header2', headerValue2); // add a new header, creating a new object
headers = headers.append('header3', headerValue3); // add another header
let params = new HttpParams().set('param1', value1); // create params object
params = params.append('param2', value2); // add a new param, creating a new object
params = params.append('param3', value3); // add another param
return this._http.get<any[]>('someUrl', { headers: headers, params: params })
136. What
is the purpose of differential loading in CLI?
From Angular8 release onwards, the
applications are built using differential loading strategy from CLI to build
two separate bundles as part of your deployed application.
.
The first build
contains ES2015 syntax which takes the advantage of built-in support in modern
browsers, ships less polyfills, and results in a smaller bundle size.
i.
The second build
contains old ES5 syntax to support older browsers with all necessary polyfills.
But this results in a larger bundle size.
Note: This strategy is used to support
multiple browsers but it only load the code that the browser needs.
137. Is
Angular supports dynamic imports?
Yes, Angular 8 supports dynamic imports in the router configuration. i.e, You can use the import statement for lazy loading
the module using loadChildren method and it will be understood by the
IDEs(VSCode and WebStorm), webpack, etc. Previously, you have been written as
below to lazily load the feature module. By mistake, if you have typo in the
module name it still accepts the string and throws an error during build time.
{path: ‘user’, loadChildren: ‘./users/user.module#UserModulee’},
This problem is resolved by using dynamic
imports and IDEs are able to find it during compile time itself.
{path: ‘user’, loadChildren: () => import(‘./users/user.module’).then(m => m.UserModule)};
138. What
is lazy loading?
Lazy loading is one of the most useful
concepts of Angular Routing. It helps us to download the web pages in chunks
instead of downloading everything in a big bundle. It is used for lazy loading
by asynchronously loading the feature module for routing whenever required
using the property loadChildren. Let's load both Customer and Orderfeature modules lazily
as below,
const routes: Routes = [
{
path: 'customers',
loadChildren: () => import('./customers/customers.module').then(module => module.CustomersModule)
},
{
path: 'orders',
loadChildren: () => import('./orders/orders.module').then(module => module.OrdersModule)
},
{
path: '',
redirectTo: '',
pathMatch: 'full'
}
];
139. What
are workspace APIs?
Angular 8.0 release introduces Workspace APIs
to make it easier for developers to read and modify the angular.json file
instead of manually modifying it. Currently, the only supported storage3 format
is the JSON-based format used by the Angular CLI. You can enable or add
optimization option for build target as below,
import { NodeJsSyncHost } from '@angular-devkit/core/node';
import { workspaces } from '@angular-devkit/core';
async function addBuildTargetOption() {
const host = workspaces.createWorkspaceHost(new NodeJsSyncHost());
const workspace = await workspaces.readWorkspace('path/to/workspace/directory/', host);
const project = workspace.projects.get('my-app');
if (!project) {
throw new Error('my-app does not exist');
}
const buildTarget = project.targets.get('build');
if (!buildTarget) {
throw new Error('build target does not exist');
}
buildTarget.options.optimization = true;
await workspaces.writeWorkspace(workspace, host);
}
addBuildTargetOption();
140. How
do you upgrade angular version?
The Angular upgrade is quite easier using
Angular CLI ng update command as mentioned below. For example, if you upgrade
from Angular 7 to 8 then your lazy loaded route imports will be migrated to the
new import syntax automatically.
$ ng update @angular/cli @angular/core
141. What
is Angular Material?
Angular Material is a collection of Material
Design components for Angular framework following the Material Design spec. You
can apply Material Design very easily using Angular Material. The installation
can be done through npm or yarn,
npm install --save @angular/material @angular/cdk
@angular/animations
(OR)
yarn add @angular/material @angular/cdk @angular/animations
It supports the most recent two versions of
all major browsers. The latest version of Angular material is 8.1.1
142. How
do you upgrade location service of angularjs?
If you are using $location service in your
old AngularJS application, now you can use LocationUpgradeModule(unified location service) which puts the
responsibilities of $location service to Location service in
Angular. Let's add this module to AppModule as below,
// Other imports ...
import { LocationUpgradeModule } from '@angular/common/upgrade';
@NgModule({
imports: [
// Other NgModule imports...
LocationUpgradeModule.config()
]
})
export class AppModule {}
143. What
is NgUpgrade?
NgUpgrade is a library put together by the
Angular team, which you can use in your applications to mix and match AngularJS
and Angular components and bridge the AngularJS and Angular dependency
injection systems.
How
do you test Angular application using CLI?
Angular CLI downloads and install everything
needed with the Jasmine Test framework. You just need to run ng testto see the test
results. By default this command builds the app in watch mode, and launches
the Karma test runner. The output of test results would be as below,
10% building modules 1/1 modules 0 active
...INFO [karma]: Karma v1.7.1 server started at
http://0.0.0.0:9876/
...INFO [launcher]: Launching browser Chrome ...
...INFO [launcher]: Starting browser Chrome
...INFO [Chrome ...]: Connected on socket ...
Chrome ...: Executed 3 of 3 SUCCESS (0.135 secs / 0.205 secs)
Note: A chrome browser also opens and displays
the test output in the "Jasmine HTML Reporter".
144. How
to use polyfills in Angular application?
The Angular CLI provides support for polyfills
officially. When you create a new project with the ng new command, a src/polyfills.ts configuration
file is created as part of your project folder. This file includes the
mandatory and many of the optional polyfills as JavaScript import statements.
Let's categorize the polyfills,
.
Mandatory polyfills: These are installed automatically when you create your
project with ng new command and the respective import statements enabled in
'src/polyfills.ts' file.
i.
Optional polyfills: You need to install its npm package and then create import
statement in 'src/polyfills.ts' file. For example, first you need to install
below npm package for adding web animations (optional) polyfill.
npm install --save
web-animations-js
and
create import statement in polyfill file.
import 'web-animations-js';
145. What
are the ways to trigger change detection in Angular?
You can inject either ApplicationRef or
NgZone, or ChangeDetectorRef into your component and apply below specific
methods to trigger change detection in Angular. i.e, There are 3 possible ways,
.
ApplicationRef.tick():
Invoke this method to explicitly process change detection and its side-effects.
It check the full component tree.
i.
NgZone.run(callback):
It evaluate the callback function inside the Angular zone.
ii.
ChangeDetectorRef.detectChanges():
It detects only the components and it's children.
146. What
are the differences of various versions of Angular?
.
Angular 1 • Angular 1
(AngularJS) is the first angular framework released in the year 2010. •
AngularJS is not built for mobile devices. • It is based on controllers with
MVC architecture.
i.
Angular 2 • Angular 2
was released in the year 2016. Angular 2 is a complete rewrite of Angular1
version. • The performance issues that Angular 1 version had have been addressed
in Angular 2 version. • Angular 2 is built from scratch for mobile devices , unlike Angular 1 version. • Angular 2 is components based.
ii.
Angular 3 The
following are the different package versions in Angular 2. • @angular/core
v2.3.0 • @angular/compiler v2.3.0 • @angular/http v2.3.0 • @angular/router
v3.3.0 The router package is already versioned 3 so to avoid confusion switched
to Angular 4 version and skipped 3 version.
iii.
Angular 4 • The
compiler generated code file size in AOT mode is very much reduced. • With
Angular 4 the production bundles size is reduced by hundreds of KB’s. •
Animation features are removed from angular/core and formed as a separate
package. • Supports Typescript 2.1 and 2.2.
iv.
Angular 5 • Angular 5
makes angular faster. It improved the loading time and execution time. •
Shipped with new build optimizer. • Supports Typescript 2.5.
v.
Angular 6 • It is
released in May 2018. • Includes Angular Command Line Interface (CLI),
Component Development KIT (CDK), Angular Material Package.
vi.
Angular 7 • It is
released in October 2018. • TypeScript 3.1 • RxJS 6.3 • New Angular CLI • CLI
Prompts capability provide an ability to ask questions to the user before they
run. It is like interactive dialog between the user and the CLI • With the improved
CLI Prompts capability, it helps developers to make the decision. New ng
commands ask users for routing and CSS styles types(SCSS) and ng add
@angular/material asks for themes and gestures or animations.
0 Comments