{"id":2984,"date":"2019-02-01T03:56:43","date_gmt":"2019-02-01T03:56:43","guid":{"rendered":"http:\/\/codethataint.com\/blog\/?p=2984"},"modified":"2020-05-04T14:07:58","modified_gmt":"2020-05-04T14:07:58","slug":"angular-interview-questions","status":"publish","type":"post","link":"https:\/\/codethataint.com\/blog\/angular-interview-questions\/","title":{"rendered":"Angular Interview Questions"},"content":{"rendered":"

1.What Is an Angular Component?<\/strong>
\nAn Angular application is a tree of Angular components<\/em>.The component contains the data & user interaction logic that defines how the View looks and behaves. A view in Angular refers to a template (HTML).Components are like the basic building block in an Angular application.Components are defined using the @component decorator. A component has a selector, template, style and other properties, using which it specifies the metadata required to process the component. Angular components are a subset of directives. Unlike directives, components always have a template and only one component can be instantiated per an element in a template.<\/p>\n

Components consist of three main building block<\/p>\n

    \n
  1. Template<\/li>\n
  2. Class<\/li>\n
  3. MetaData<\/li>\n<\/ol>\n

    2.Angularjs vs Angular<\/strong>
    \nAngularjs and Angular should be treated as two different frameworks. Here are few comparisons as below<\/p>\n\n\n\n\n\n\n\n\n\n\n\n
    AngularJS<\/th>\nAngular<\/th>\n<\/tr>\n
    Controllers<\/td>\nWebComponents<\/td>\n<\/tr>\n
    AngularJS is written in JavaScript. <\/p>\n<\/td>\nAngular uses Microsoft\u2019s TypeScript language, which is a superset of ECMAScript 6 (ES6). This has the combined advantages of the TypeScript features, like type declarations, and the benefits of ES6, like iterators and lambdas.<\/td>\n<\/tr>\n
    AngularJS is based on model-view-controller(MVC) Design and MVVM(Model-view-view-model) by two way data binding .In AngularJS the MVC pattern is implemented in JavaScript and HTML. The view is defined in HTML, while the model and controller are implemented in JavaScript. The controller accepts input, converts it into commands and sends the commands to the model and the view<\/td>\n\nAngular 2 is more of component based architecture. You can assume everything as component like directives, services and so on. While directives and services are actually for the support of base components, they are also defined in similar fashion. A base component contains of dependencies, a view details and class declaration which may be considered as controller. So a well defined component consist of individual set of MVC architecture.Angular 2, controllers and $scope were replaced by components and directives. Components are directives with a template. They deal with a view of the application and logic on the page. <\/td>\n<\/tr>\n
    HTML markup is the View, Controller is the Controller & the Service (when it used to retrieve data) is the model.<\/td>\ntemplate is the View, class is the Controller & the Service (when it used to retrieve data) is the model.<\/td>\n<\/tr>\n
    To bind an image\/property or an event with AngularJS, you have to remember the right ng directive.<\/td>\nAngular focuses on \u201c( )\u201d for event binding and \u201c[ ]\u201d for property binding.\n<\/td>\n<\/tr>\n
    No Mobile Support<\/td>\nAngular 2 and 4 both feature mobile support.<\/td>\n<\/tr>\n

    > <\/p>\n

    		2-way binding, AngularJS reduced the development effort and time. However, by creating more processing on the client side, page load was taking considerable time.\n<\/td>\nAngular implements unidirectional tree-based change detection and uses Hierarchical Dependency Injection system. This significantly boosts performance for the framework.
    \ntwo-way data binding in Angular 2 is supported using the event and the property binding. We can use ngModel <\/strong>directive to use two-way data binding. <\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    3.What are Directives<\/strong>
    \nDirectives are something that introduce new syntax \/ markup. They are markers on the DOM element which provides some special behavior to DOM elements and tells AngularJS’s HTML compiler to attach.<\/p>\n

    There are three kinds of directives in an Angular 2 application.
    \nComponents<\/strong>
    \nAngular Component also refers to a directive with a template which deals with View of the Application and also contains the business logic. It is very useful to divide your Application into smaller parts. In other words, we can say that Components are directives that are always associated with the template directly.<\/p>\n

    Structural directives<\/strong>
    \nStructural directives are able to change the behavior of DOM by adding and removing DOM elements. The directive NgFor, NgSwitch, and NgIf is the best example of structural directives.<\/p>\n

    Attribute directives<\/strong>
    \nAttribute directives are able to change the behavior of DOM. The directive NgStyle is an example of Attribute directives which are used to change styles elements at the same time.<\/p>\n

    4.Difference between Component and Directive<\/strong>
    \nDirectives <\/strong>
    \nDirectives add behaviour to an existing DOM element or an existing component instance. One example use case for a directive would be to log a click on an element.<\/p>\n

    \r\nimport {Directive} from '@angular\/core';\r\n\r\n@Directive({\r\n    selector: "[logOnClick]",\r\n    hostListeners: {\r\n        'click': 'onClick()',\r\n    },\r\n})\r\nclass LogOnClick {\r\n    constructor() {}\r\n    onClick() { console.log('Element clicked!'); }\r\n}\r\n<\/pre>\n
    \r\n<button logOnClick>I log when clicked!<\/button>\r\n<\/pre>\n
    Components<\/strong>
    \nA component, rather than adding\/modifying behaviour, actually creates its own view (hierarchy of DOM elements) with attached behaviour. An example use case for this might be a contact card component:<\/p>\n
    \r\nimport {Component, View} from '@angular\/core';\r\n\r\n@Component({\r\n  selector: 'contact-card',\r\n  template: `\r\n    <div>\r\n      <h1>{{name}}<\/h1>\r\n      <p>{{city}}<\/p>\r\n    <\/div>\r\n  `\r\n})\r\nclass ContactCard {\r\n  @Input() name: string\r\n  @Input() city: string\r\n  constructor() {}\r\n}\r\n<\/pre>\n
    \r\n<contact-card [name]="'foo'" [city]="'bar'"><\/contact-card>\r\n<\/pre>\n\n\n\n\n\n\n\n\n\n\n
    Directive<\/th>\nComponent<\/th>\n<\/tr>\n
    They are used to create behavior to an existing DOM element.<\/td>\nA component is a directive with a template and the @Component decorator is actually a @Directive decorator extended with template-oriented features. It used to shadow DOM to create encapsulates visual behavior. It is used to create UI widgets.<\/td>\n<\/tr>\n
    They help us to create re-usable components<\/td>\nIt helps us to break up our application in smaller component<\/td>\n<\/tr>\n
    We cannot create pipes using Attribute \/ Structural directive<\/td>\nPipes can be defined by component<\/td>\n<\/tr>\n
    We can define many directive per DOM element<\/td>\nWe can present only one component per DOM element<\/td>\n<\/tr>\n
    @directive keyword is used to define metadata<\/td>\n@component keyword is used to define metadata<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    5.Directive Lifecycle<\/strong><\/p>\n
    <\/p>\n
    For the Directives there are three hooks provided for different event based on which we can take actions upon
    \nngOnChanges<\/strong> – It occurs when Angular sets data bound property. Here, we can get current and previous value of changed object. It is raised before the initialization event for directive.<\/p>\n
    ngOnInit<\/strong> – It occurs after Angular initializes the data-bound input properties.<\/p>\n
    ngDoCheck<\/strong> – It is raised every time when Angular detects any change.<\/p>\n
    ngOnDestroy<\/strong> – It is used for cleanup purposes and it is raised just before Angular destroys the directive. It is very much important in memory leak issues by un-subscribing observables and detaching event handlers.<\/p>\n
    6.What are Types of Databinding in Angular<\/strong><\/p>\n
      \n
    1. Interpolation \/ String Interpolation (one-way data binding)<\/li>\n
    2. Property Binding (one-way data binding)<\/li>\n
    3. Event Binding (one-way data binding)<\/li>\n
    4. Two-Way Binding<\/li>\n<\/ol>\n
      7.What is Interpolation?<\/strong>
      \nInterpolation(one-way data binding) allows you to define properties in a component class, and communicate these properties to and from the template.
      \nnterpolation is a technique that allows the user to bind a value to a UI element.Interpolation binds the data one-way. This means that when value of the field bound using interpolation changes, it is updated in the page as well. It cannot change the value of the field. An object of the component class is used as data context for the template of the component. So the value to be bound on the view has to be assigned to a field in the component class.String Interpolation uses template expressions in double curly {{ }} braces to display data from the component, the special syntax {{ }}, also known as moustache syntax. The {{ }} contains JavaScript expression which can be run by Angular and the output will be inserted into the HTML.<\/p>\n
      \r\n          {{value}}  \r\nComponent----------->DOM\r\n<\/pre>\n
      app.component.ts<\/strong><\/p>\n
      \r\nimport { Component } from '@angular\/core';\r\n\r\n@Component({\r\n  selector: 'app-root',\r\n  templateUrl: '.\/app.component.html',\r\n  styleUrls: ['.\/app.component.css']\r\n})\r\nexport class AppComponent {\r\n  title = 'stockMarket';\r\n}\r\n<\/pre>\n
      app.component.html<\/strong><\/p>\n
      \r\n<h1>\r\n    Welcome to {{ title }}!\r\n<\/h1>\r\n<\/pre>\n
      8.What is Property Binding (one-way data binding)?<\/strong>
      \nProperty binding is used to bind values to the DOM properties of the HTML elements. Like interpolation, property binding is a one-way binding technique. Property bindings are evaluated on every browser event and any changes made to the objects in the event, are applied to the properties.There are 3 types of Property Binding<\/p>\n
      app.component.ts<\/strong><\/p>\n
      \r\nimport {Component} from '@angular\/core';\r\n\r\n@Component({\r\nselector: 'my-app',\r\ntemplate:'\r\n<h1>My First Angular App<\/h1>\r\n<img [src]="imageUrl">\r\n<img bind-src="imageUrl">'\r\n})\r\n\r\nexport class AppComponent { \r\nimageUrl = 'http:\/\/codethataint.com\/images\/sample.jpg';\r\n}\r\n<\/pre>\n
        \n
      1. Component property binding<\/strong> works within component element to bind parent component property into child component property. In the diagram the arrows and rectangles in red color are displaying the functionality related to component property binding.\n<\/li>\n
      2. Element property binding<\/strong> works within HTML element and it binds a component property to a DOM property. In the diagram the arrows and rectangle in green color are displaying the functionality related to element property binding.<\/li>\n
      3. Directive property binding<\/strong> works within HTML element with angular directives such as NgClass and NgStyle. In directive property binding a component property or any angular expression is bound to angular directive. In the diagram the arrows and rectangles in light blue color are displaying the functionality related to directive property binding. <\/li>\n<\/ol>\n
        9.What is Event Binding(one-way data binding)?<\/strong>
        \nEvent binding allows us to work in reverse from property binding. We can send information from the view, to the component class. Such information usually involves a click, hover or typing. <\/p>\n
        \r\nimport {Component} from '@angular\/core';\r\n\r\n@Component({\r\nselector: 'my-app',\r\ntemplate:'\r\n<h1>My First Angular App<\/h1>\r\n<img [src]="imageUrl" (click)='myMethod()'>\r\n<img [src]="imageUrl" on-click='myMethod()'>'\r\n})\r\n\r\nmyMethod() {\r\n   console.log('Hey!');\r\n}\r\n<\/pre>\n
        10.What is Two way Binding?<\/strong>
        \nTwo-way data binding really just boils down to event binding and property binding.<\/p>\n
        \r\n<input [(ngModel)]="username">\r\n<p>Hello {{username}}!<\/p>\r\n<\/pre>\n
        The above code turns out to be<\/p>\n
        \r\n<input [value]="username" (input)="username = $event.target.value">\r\n<p>Hello {{username}}!<\/p>\r\n<\/pre>\n
          \n
        1. [value]=\u201dusername\u201d – Binds the expression username to the input element\u2019s value property<\/li>\n
        2. (input)=\u201dexpression\u201d – Is a declarative way of binding an expression to the input element\u2019s input event (yes there\u2019s such event)<\/li>\n
        3. username = $event.target.value – The expression that gets executed when the input event is fired<\/li>\n
        4. $event – Is an expression exposed in event bindings by Angular, which has the value of the event\u2019s payload<\/li>\n<\/ol>\n
          11.What is the Difference between One way Data Binding and Two Way Data Binding<\/strong><\/p>\n\n\n\n\n\n
          One Way Data Binding<\/th>\nTwo Way Data Binding<\/th>\n<\/tr>\n
          In one-way data binding, the value of the Model is inserted into an HTML (DOM)  element and there is no way to update the Model from the View.<\/td>\n In two-way binding automatic synchronization of data happens between the Model and the View (whenever the Model changes it will be reflected in the View and vice-versa)<\/td>\n<\/tr>\n
          One way data Binding flow would be
          \n(Model($scope) –> View)<\/td>\n          		Two way data Binding flow would be
          \n(Model($scope) –> View and View –> Model($scope))<\/td>\n<\/tr>\n
          \nAngular 1 and Angular 2:<\/p>\n
          \r\n<h2 ng-bind="student.name"><\/h2>\r\n<h2 [innerText]="student.name"><\/h2><\/pre>\r\n<\/pre>\n<\/td>\n
          		\nAngular 1 and Angular 2:<\/p>\n
          \r\n<input ngModel="student.name"\/>\r\n<input [(ngModel)]="student.name"\/><\/pre>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/table>\n
          12.What is Dirty Checking?<\/strong>
          \nAngular checks whether a value has changed in view and not yet synchronized across the app.Our Angular app keeps track of the values of the current watches. Angular walks down the $watch list, and, if the updated value has not changed from the old value, it continues down the list. If the value has changed, the app records the new value and continues down the $watch list.<\/p>\n
          Angular has a concept of \u2018digest cycle\u2019<\/strong>. You can consider it as a loop. In which Angular checks if there are any changes to all the variables watched by all the $scopes(internally $watch() and $apply() functions are getting bonded with each variable defined under $scope).So if you have $scope.myVar defined in your controller (that means this variable \u2018myVar\u2019 was marked for being watched) then you are explicitly telling Angular to monitor the changes on \u2018myVar\u2019 in each iteration of the loop. So when the value of \u2018myVar\u2019 changes, every time $watch() notices and execute $apply() to apply the changes in DOM.<\/p>\n
          How it Works<\/Strong>
          \nFirst Cycle<\/em><\/p>\n
            \n
          1. Get a watch from list<\/li>\n
          2. Check whether item has been changed<\/li>\n
          3. If there is no change in item then<\/li>\n
          4. No Action taken, move to next item in watch list<\/li>\n<\/ol>\n
            Second Cycle<\/em><\/p>\n
              \n
            1. Get a watch from list<\/li>\n
            2. Check whether item has been changed<\/li>\n
            3. If there is Change in an item<\/li>\n
            4. DOM needs to be updated, return to digest loop<\/li>\n<\/ol>\n
              <\/p>\n
              14.What is difference between [ngClass] and [class]?<\/strong>
              \nWhen multiple classes should potentially be added, the NgClass  prefer NgClass. NgClass should receive an object with class names as keys and expressions that evaluate to true or false as values<\/p>\n
              \r\n<div [ngClass]="myClasses">\r\n  ...\r\n<\/div>\r\n<\/pre>\n
              \r\nmyClasses = {\r\n  important: this.isImportant,\r\n  inactive: !this.isActive,\r\n  saved: this.isSaved,\r\n  long: this.name.length > 6\r\n}\r\n<\/pre>\n
              If you want to apply a single class to DOM element rather than multiple classes go for [Class]<\/p>\n
              \r\n<div [class]="isGreen?'green':'cyan'">\r\n  ...\r\n<\/div>\r\n<\/pre>\n
              The Other way of applying class is using Singular Version of Class Binding<\/strong>
              \n.In this method either class style would be applied or it would be left without anystyle<\/p>\n
              \r\n<div [class.green]="expression()">\r\n  ...\r\n<\/div>\r\n<\/pre>\n
              The expression is a function which returns true or false value.If true then green style would be applied or no style would be applied <\/p>\n
              15.What is difference between ngStyle and ngClass?<\/strong>
              \nng-style <\/strong>is used to interpolate javascript object into style attribute, not css class and And ng-class<\/strong> directive translates your object into class attribute.<\/p>\n
              \r\n[ngStyle]="{'font-size':24}"\r\n[ngClass]="{'text-success':true}"\r\n<\/pre>\n
              15.What is Service?<\/strong><\/p>\n
              16.What is Provider?<\/strong><\/p>\n
              17.What is difference between Factory vs Service vs Provider?<\/strong><\/p>\n
              18.Difference between @Inject vs @Injectable<\/strong><\/p>\n
              19.What are Reactive Forms<\/strong><\/p>\n
              20.How Dependency Injection is done in Angular?<\/strong><\/p>\n
              21.Difference between Subscribe, Transform, Map and Filter?<\/strong><\/p>\n
              22.Navigator vs Router<\/strong><\/p>\n
              23.What is Lazy Loading in Angular<\/strong><\/p>\n
              24.What is Difference between Subscribe and Promise?<\/strong><\/p>\n
              25.Lifecycle of Angular App<\/strong><\/p>\n
              26.How to Create Custom Event in Angular?<\/strong><\/p>\n
              27.What are different style Encapsulation in Angular?<\/strong>
              \nViewEncapsulation.Emulated <\/strong> – This is default, keep styles scoped to the components where they are added even though the styles are all added collected in the head of the page when components are loaded.
              \nViewEncapsulation.None <\/strong> – Uses global CSS without any encapsulation,When this value is specified, Angular simply adds the unmodified CSS styles to the head section of the HTML document and lets the browser figure out how to apply the styles using the normal CSS precedence rules.
              \nViewEncapsulation.Native<\/strong> –  the browsers native implementation ensures the style scoping.If the browser doesn’t support shadow DOM natively, the web-components polyfills are required to shim the behavior.Check for browser support before enabling it. This is similar to ViewEncapsulation.Emulated but the polyfills are more expensive because of they polyfill lots of browser APIs even when most of them are never used. <\/p>\n
              The Native and None values should be used with caution. Browser support for the shadow DOM feature is so limited that using the Native option is sensible only if you are using a polyfill library that provides compatibility for other browsers.
              \n
              \nThe None option adds all the styles defined by components to the head section of the HTML document and lets the browser figure out how to apply them. This has the benefit of working in all browsers, but the results are unpredictable, and there is no isolation between the styles defined by different components.<\/p>\n
              28.What is View Projection?<\/strong>
              \nProjection is useful when we want the user to decide the input of the Component something like carousel where the inputs could be image, text or page which doesnot have much to do with component logic.
              \nLets say we have a button text which needs to be decided by the parent component dynamically.In such case we will pass the text of button as parameter to selector of child component like one below<\/p>\n
              parent.component.ts<\/strong><\/p>\n
              \r\n<app-parentcounter>Increment Counter From Parent<\/app-parentcounter>\r\n<\/pre>\n
              child.component.ts<\/strong><\/p>\n
              \r\n<button (click)="increaseCounter()">\r\n  <ng-content><\/ng-content>\r\n <\/button>\r\n<\/pre>\n
              ng-content in child tells its a argument which should be passed from parent component. There are two advantages of using ng-content.<\/p>\n
                \n
              1. The value could be decided at runtime by passing as paremeter<\/li>\n
              2. The Button could be used multiple times with different text<\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"
                1.What Is an Angular Component? An Angular application is a tree of Angular components.The component contains the data & user interaction logic that defines how the View looks and behaves. A view in Angular refers to a template (HTML).Components are like the basic building block in an Angular application.Components are defined using the @component decorator.… Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[257],"tags":[],"class_list":["post-2984","post","type-post","status-publish","format-standard","hentry","category-interview-questions-angular"],"_links":{"self":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts\/2984","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/comments?post=2984"}],"version-history":[{"count":5,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts\/2984\/revisions"}],"predecessor-version":[{"id":3708,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts\/2984\/revisions\/3708"}],"wp:attachment":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/media?parent=2984"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/categories?post=2984"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/tags?post=2984"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}