Class Inheritance

let name;
let age;
let type;
let country;

// Parent Class
class Person {
    constructor () {
        this.name = "Sakib";
        this.age = 35;
    }
    eat () {
        console.log(`${this.name} is eating`);
    }
}

// Child Class
class Cricketer extends Person {
    constructor () {
        super();
        this.type = "All rounder";
        this.country = "Bangladesh";
    }
}

const sakib = new Cricketer();
console.log(sakib.eat());

Prototype Inheritance

// Parent Constructor
let name;
let age;

function Person () {
    this.name = "Sakib";
    this.age = 35;
}

// Child Constructor
let type;
let country;

function Cricketer () {
    Person.call(this);
    this.type = "All rounder";
    this.country = "Bangladesh";
}

// Parent Person prototype
Person.prototype = {
    eat: function () {
        console.log(`${this.name} is eating`);
    }
}

// Inheritance for Cricketer prototype
Cricketer.prototype = Object.create(Person.prototype);

// Override the Cricketer constructor
Cricketer.prototype.constructor = Cricketer;

const sakib = new Cricketer();
console.log(sakib.name);

Prototype

Prototype is an object or a built in property of a function who point the object

// Constructor function becuase ei function diye amra object create korte pari
function Human (name, age, city) {
    // Child object
    /*
    let person = Object.create(Human.prototype);
    person.name = name;
    person.age = age;
    person.city = city;
    return person;
    */

    /*
    vitore vitore javascript ei kajta kore dicche new keyword use korar karone
    let this = Object.create(Human.prototype);
    */
    this.name = name;
    this.age = age;
    this.city = city;
    // return this;
}

// Parent object
Human.prototype = {
    salary: 20000,
    eat () {
        console.log(`Person is eating`);
    },
    sleep () {
        console.log(`Person is sleeping`);
    },
    play () {
        console.log(`Person is playing`);
    }
}

// Create a new object from Human object/function
const sakib = new Human('Sakib', 35, 'Dhaka');
console.log(sakib);
sakib.play();

// Create a new object from Human object/function
const musfiq = new Human('Musfiq', 32, 'Dhaka');
musfiq.sleep();
console.log(musfiq.salary);

async/await

Async/await makes your code look synchronous, and avoiding the need to explicitly configure promise chains.

const hasMeeting = true;

const meeting = new Promise((resolve, reject) => {
    if (!hasMeeting) {
        const meetingDetails = {
            name: 'Technical meetings',
            location: 'Google meet',
            time: '10:00 pm'
        };
        resolve(meetingDetails)
    }
    else {
        reject(new Error('Meeting already scheduled!'));
    }
});

async function myMeeting () {
    try {
        const meetingDetails = await meeting;
        console.log(meetingDetails);
    }
    catch (error) {
        console.log(error.message);
    }
}

myMeeting();

Promise

A promise is an object that is used for handling asynchronous results. Asynchronous function returns a promise.

const hasMeeting = false;

const meeting = new Promise((resolve, reject) => {
    if (!hasMeeting) {
        const meetingDetails = {
            name: 'Technical meetings',
            location: 'Google meet',
            time: '10:00 pm'
        };
        resolve(meetingDetails)
    }
    else {
        reject(new Error('Meeting already scheduled!'))
    }
});

meeting
    .then((res) => {
        console.log(res);
    })
    .catch((err) => {
        console.log(err.message);
    })

Asynchronous task order control by the callback function

const takeOrder = (customer, callback) => {
    console.log(`Take order for ${customer}`);
    callback(customer);
}

const processOrder = (customer, callback) => {
    console.log(`Processing order for ${customer}`);
    setTimeout(() => {
        console.log('Cooking completed');
        console.log(`Order processed for ${customer}`);
        callback(customer);
    }, 6000);
}

const completeOrder = (customer) => {
    console.log(`Completed order for ${customer}`);
}

takeOrder('customer 1', (customer) => {
    processOrder(customer, (customer) => {
        completeOrder(customer);
    });
});

Asynchronous

Asynchronous code allows the program to be executed immediately where the synchronous code will block for the previous execution

const processOrder = (customer) => {
    console.log('Processing order for customer 1');

    setTimeout(() => {
        console.log('Cooking completed');
    }, 10000);

    console.log('Order processed for customer 1');
}

console.log('Take order for customer 1');
processOrder();
console.log('Completed order for customer 1');

Synchronous

JavaScript is a single threaded language and has a synchronous execution model. Single threaded means javascript code executed line by line. Every line of code waits for its previous one to get executed first and then it gets executed.

const processOrder = (customer) => {
    console.log('Processing order for customer 1');

    let currentTime = new Date().getTime();
    while (currentTime + 10000 >= new Date().getTime());
    console.log('Order processed for customer 1');
}

console.log('Take order for customer 1');
processOrder();
console.log('Completed order for customer 1');