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.
ScreenShot
                         ii.          Error checking: It can also warn you of mistakes in your code.
ScreenShot
                        iii.          Navigation: Navigation allows you to hover a component, directive, module and then click and press F12 to go directly to its definition.
ScreenShot

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.