How to Center a Div Using CSS


Do you want to learn how to center a div using CSS? Centering elements on a web page is a common design feature, and mastering the technique can help you create a professional-looking website. In this blog post, we’ll discuss how to center a div using the margin and transform properties.

Margin Property

The margin property is the most common way to center a div. You can use the auto value for the left and right margins to make the div center itself. Here is an example of the margin property in action:

div {
    margin-left: auto;
    margin-right: auto;

Transform Property

The transform property is a newer way to center a div. It works by translating the div to the center of the page. Here is an example of the transform property in action:

div {
    position: absolute;
    top: 50%;
    left: 50%;
    transform: translate(-50%, -50%);


Flexbox is another way to center a div. It is a powerful tool that allows you to align and order elements on a page. To center a div using flexbox, you can use the justify-content and align-items properties. Here is an example of flexbox in action:

div {
    display: flex;
    justify-content: center;
    align-items: center;


Centering a div is a common design feature, and there are several ways to do it. The most common way is to use the margin property, but the transform and flexbox properties can also be used. With some practice, you can master the technique and create a professional-looking website.


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.