Frontend Developer

When a function is called with the new keyword, couple of things happen behind the scenes:
A new empty object is created
The context object this is bound to the new empty object
The new object is linked to the function’s prototype property
this is automatically returned unless another value is returned explicitly from the function
This is the mechanism provided by JavaScript to link objects with prototype objects.

To import all exported members of an object, one can use:
import * as object name from ‘./file.js.’
The exported methods or variables can be easily accessed by using the dot (.) operator.

The JavaScript this keyword refers to the object it belongs to. This has different values depending on where it is used. In a method, this refers to the owner object and in a function, this refers to the global object.

ES6 arrow functions provide you with an alternative way to write a shorter syntax compared to the function expression.

The following example defines a function expression that returns the sum of two numbers : 

let add = function (x, y) {
	return x + y;
};
console.log(add(10, 20)); // 30

The following example is equivalent to the above add() function expression but use an arrow function instead :

let add = (x, y) => x + y;
console.log(add(10, 20)); // 30;

In this example, the arrow function has one expression x + y so it returns the result of the expression.

Every component in Angular has a lifecycle, different phases it goes through from the time of creation to the time it's destroyed. Angular provides hooks to tap into these phases and trigger changes at specific phases in a lifecycle.

ngOnChanges( ) This hook/method is called before ngOnInit and whenever one or more input properties of the component changes. This method/hook receives a SimpleChanges object which contains the previous and current values of the property.

ngOnInit( ) This hook gets called once, after the ngOnChanges hook. It initializes the component and sets the input properties of the component.

ngDoCheck( ) It gets called after ngOnChanges and ngOnInit and is used to detect and act on changes that cannot be detected by Angular. We can implement our change detection algorithm in this hook. ngAfterContentInit( ) It gets called after the first ngDoCheck hook. This hook responds after the content gets projected inside the component.

ngAfterContentChecked( ) It gets called after ngAfterContentInit and every subsequent ngDoCheck. It responds after the projected content is checked.

Every Angular application consists of components and templates which the browser cannot understand. Therefore, all the Angular applications need to be compiled first before running inside the browser.

Angular provides two types of compilation:
JIT(Just-in-Time) compilation : In JIT compilation, the application compiles inside the browser during runtime.
AOT(Ahead-of-Time) compilation : Whereas in the AOT compilation, the application compiles during the build time.

The first difference is that an Observable is lazy whereas a Promise is eager.
Promise emits a single value. Observable emits multiple values over a period of time
Promises are Not Lazy. Observable is lazy. An observable is not called until we subscribe to the observable
Promise cannot be cancelled. Observable can be cancelled by using the unsubscribe() method