Difference between constructor and ngOnInit

The Constructor is a default method of the class that is executed when the class is instantiated and ensures proper initialisation of fields in the class and its subclasses. Angular, or better Dependency Injector (DI), analyses the constructor parameters and when it creates a new instance by calling new MyClass() it tries to find providers that match the types of the constructor parameters, resolves them and passes them to the constructor like

new MyClass(someArg);

ngOnInit is a life cycle hook called by Angular to indicate that Angular is done creating the component.

We have to import OnInit like this in order to use it (actually implementing OnInit is not mandatory but considered good practice):

import { Component, OnInit } from '@angular/core';

then to make use of the method OnInit, we have to implement the class like this:

export class App implements OnInit {
constructor() {
// Called first time before the ngOnInit()

ngOnInit() {
// Called after the constructor and called after the first ngOnChanges()

Implement this interface to execute custom initialization logic after your directive’s data-bound properties have been initialized. ngOnInit is called right after the directive’s data-bound properties have been checked for the first time, and before any of its children have been checked. It is invoked only once when the directive is instantiated.

Mostly we use ngOnInit for all the initialisation/declaration and avoid stuff to work in the constructor. The constructor should only be used to initialise class members but shouldn’t do actual “work”.

So you should use constructor() to setup Dependency Injection and not much else. ngOnInit() is better place to “start” – it’s where/when components’ bindings are resolved.

Angular forms

From my point of view,

If you have more than two inputs in an form, don’t use template driven forms.

When we are going with template driven forms for large forms, we will end up dealing with potential bugs.

So what should I use?

Just check.

What is Reactive forms?

Building forms with Functional Reactive Programming will help us to build feature like undo/redo quickly.

Handling various validation is quickly doable.

We can have features like partially update the form or fully update the form.

FormGroup have api methods called

patchValue() – partially update form

setValue() – fully updates the form (required all form fields)

You don’t have to set all fields to empty. The following single line will does that for you this.form.reset();

Your form gets to its initial state in one line of code.

Even we can mix up both the techniques in building forms.

That’s technically possible.

I personally wish to use it seperately.

Moral of story

If you are building new forms in your application.

USE reactive form..