Notes.txt

************************************************************************************************
-- Javascript is 
    1. high level language
    2. multi paradigm language
    3. object oriented language
    4. synchronous language
    5. single threaded language

-- It is language of web development it makes web pages and web apps works dynamically.

-- Every browser has embedded javascript engine and console
    for eg. chrome has v8 engine to run javascript code

-- The programs in this language is called as script.
    -- they can be written in html code or run automatically on page load

-- Node.js
    -- It is open source, cross platform, backend javascript runtime environment that runs on v8 engine and executes javascript code outside the browser.

// console.log('Welcome to JS Tutorial')

// let a = 98

// console.log('a : ' + a)

// let b = 89 + 789

// console.log('b : ' + b)


************************************************************************************************
// Variables in JS
************************************************************************************************

console.log('Variables in JS')

var a = 89

console.log(a)

var greet = 'hello'

var is_available = true

console.log(greet)

console.log(is_available)

************************************************************************************************
// Arrays in JS
************************************************************************************************

console.log('Arrays in JS')

// Arrays provides an ordered collection of data which can be of different data types

var arr = [12,'Ashish',true,23.4]

console.log(arr)

// accessing the elements of array

console.log(arr[1])

// replacing the existing element of array

arr[1] = 'Python'
console.log(arr)

// length of array

console.log("The length of array is ",arr.length)


// inbuilt array methods

var arr2 = [34,66,77,21]

// pop element --> remove element from end of array and will return that element

arr2.pop()

console.log('poppped array : ',arr2)

// push element --> add element to end of array

arr2.push(233)

console.log('Pushed array : ',arr2)


// shift method --> removes the first element of array and return that value

arr2.shift()

console.log('Shifted array : ',arr2)

// unshift method --> add the element at index 0 of array

arr2.unshift(123)

console.log('Unshifted array : ',arr2)

************************************************************************************************
// Objects
************************************************************************************************

// Everything in JS is object
// In JS, an object is unordered collection of key-value pairs. Each key-value pair is called as property.
// A key of property can be string and value of property can be any value i.e string ,number, array or even function
// JS provides you with many ways to create object. The most commonly used one is to use the object literal notation.

var person = {
    firstName : 'Ashish',
    lastName : 'Khedekar',
    age : 23,
    skills : ['Python', 'JS']
}

// accessing the objects

// 1. dot notation

console.log(person.firstName,person.lastName)

// 2. bracket notation

console.log(person['age'])


var favCricketer = {
    firstName : 'Rohit',
    lastName : 'Sharma',
    age : 34,
    isCWCWinner : false,
    friends : ['Virat Kohli', 'KL Rahul', 'Shubman Gill'],
    address : {
        state : 'Maharashtra',
        city : {
            name : 'Mumbai',
            pincode : 400068,
        }
    }
}


console.log(favCricketer.friends[0])

console.log(favCricketer.address.city.name)

// updating the existing properties

favCricketer.isCWCWinner = true

console.log('Updated object : ',favCricketer)

// add new key value pair 

favCricketer.iplTropies = 5

console.log('Added new property : ',favCricketer)

// deleting property

delete favCricketer.isCWCWinner

console.log('Deleted some property : ',favCricketer)

************************************************************************************************
// Conditional Statements
************************************************************************************************


// if - else statement

var myScore = 90

if (myScore > 90){
    console.log('Yayy got a bicycle!')
}

else{
    console.log("Oops didn't make it this time!")
}

// if - else if - else statement
// Greater than equal to 90 -- Grade A
// 70 to 89 -- Grade B
// 50 to 69 -- Grade C
// Lower than 50 -- Grade F

var marks = 35

if (marks >= 90){
    console.log('Student got a Grade A')
}

else if (marks >= 70 && marks <= 89){
    console.log('Student got a Grade B')
}

else if (marks >= 50 && marks <= 69){
    console.log('Student got a Grade C')
    
}

else {
    console.log('Oops! Student got a Grade F')
}

 
************************************************************************************************
// Control Statements :
************************************************************************************************


// For Loop
// Loops are basically used to control the flow of program and do repetative task

var nums = [2,3,4,5,6,7,8]
var squaredArr = []
for(var i = 0; i < nums.length; i++){
    squaredArr.push(nums[i] * nums[i])
}

console.log('squaredArray : ',squaredArr)


// While Loop

var i = 1
var n = 10
console.log('Printing 1 to 10 using while loop : ')
while (i <= n){
    console.log(i)
    i++
}


// Do while loop

var j = 11
var m = 10
console.log('Printing using do while loop : ')
do {
    console.log(i)
    i++
} while (i <= n)


// For-in Loops
// In JS, for-in loops allows you to loop through the properties of the object

var colors = {
    primary : 'Blue',
    secondary : 'Grey',
    danger : 'Red'
}
console.log('Printing using for-in loops :')
for (var color in colors) {
    console.log(color + ' -> ' + colors[color])
}

// Iterting arrays using for-in looops

var colorsArray = ['Yellow','Blue','Orange','Pink']
console.log('Printing array using for-in loops :')
for (var color in colorsArray) {
    console.log(color + ' -> ' + colorsArray[color])
}



// For-of Loops :
// The for-of loops creates a loop iterating over iterable objects
// includes : string, arrys and arrays-like objects like NodeList and also map and set
// The differene between for-in and for-of is for-in holds key and for-of hold value


var scores = [34,56,89,67]
console.log('Printing using for-of loop :')
for (var score of scores) {
    console.log(score)
}

// if we want index to be print or access use entries method
console.log('Printing using entries method : ')
for (var [index, score] of scores.entries()) {
    console.log(index + ' -> ' + score)
}

// iterating over string using for-of loops :

var str = 'Ashish'
console.log('Printing string using for-of looop : ')
for (var c of str) {
    console.log(c)
}


************************************************************************************************
// Functions in JS
************************************************************************************************

// Functions are block of code that performs some task on invokation.

// Basic fundtion

function greet() { // function defination or declaration
    console.log('Hello ! Good Morning')
}

greet()  // function invokation or function calling

// Parameters and Arguments
// parameter -> defined in function defination
// arguments -> passed when we call function 

function add(a,b) {
    console.log(a + b)
}

add(2,3)

add(4,6)


// Functions as Expression 

// In this we basically create one anonoymous function and assign it to one variable

var add = function(a, b){
    return a + b
}

var sum = add

var result = sum(4,7)

console.log('Result of function as expression : ' + result)


// Hoisting :

// 1. every variable which is called above declaration will result as undefined 
// bcz whenever code execution begins first memory allocation is done and then code execution starts

// 2. basic function will give result as they are declared during memory allocation phase

// 3. function expression also reacts same as variables


console.log(a)
sub(2,3)
greet()

var a = 'hi'

function greet(){
    console.log('Good Morning')
}


var sub = function(a,b){
    console.log(a + b)
}


************************************************************************************************
// ES6 in JS :
************************************************************************************************

// Problems with var keyword

// 1. It allows redeclaration of a variable

var a = 21

var a = 32

console.log(a)

// 2. variables declared with var keyword are not blocked scope they are function scope

var num = 67

if (num === 67){
    var num1 = 6909
    console.log('Inside if loop : ',num1)
}

console.log('Outside if loop : ',num1)


// with function

function test() {
    var c = 87
    console.log('Inside for loop : ',c)
}

test()
// console.log('Outside for loop : ',c) --> will give errors as var is function scoped

************************************************************************************************
// let keyword :
************************************************************************************************

// 1. Redeclaration of variable is not allowed
// 2. Reassignment is allowed using let keyword
// 3. It is block scoped
// 4. It added itself in window object

let key = 89

console.log('Before reassigmnent : ',key)
// let key = 90

key = 67

console.log('After reassigmnent : ',key)


if (true){
    let newKey = 56
    console.log('Inside block : ',newKey)
}

// console.log('Outside block : ',newKey) // will get error

************************************************************************************************
// const keyword :
************************************************************************************************

// 1. Redeclaration and reassignment is not allowed
// 2. It is block scoped
// 3. It added itself in window object

const ans = true

// const ans = false // redeclaration is not allowed

// ans = false

// console.log(ans) // reassignment is not allowed

console.log(ans)


if (true) {
    const new_ans = 'true'
    console.log(new_ans)
}

// console.log(new_ans) // it is block scoped


************************************************************************************************
// Arrow functions
************************************************************************************************

// Usage of arrow function will be seen after oops module

let test1 = () => {
    console.log('This is basic arrow function : ',1)
}

// we can make it one line function

let test4 = () => console.log('This is one line function')

let test2 = a => {
    console.log('This is one parameter arrow function : ',a + 6)
}

let test3 = (a, b) => {
    console.log('This is two parameter arrow function : ',a + b)
}

// fat arrow function with implicit return

let func = () => 122
console.log(func())

// fat arrow function with implicit return

let func = () => 'This is implicit return function'
console.log(func())

test1()

test2(4)

test3(3,6)

test4()

************************************************************************************************
// template literal and mutli line string :
************************************************************************************************

console.log(`Ashish
is
python
programmer`)

let mon = 'November'

console.log(`This is ${mon} month.`)

************************************************************************************************
// Destructuring :
************************************************************************************************

// The destructuring assigment syntax is JS expression that makes it possible to unpack values
// from arrays, or properties from objects into distinct variables

let arr = ['Hi','I','am','Ashish']

let [w, x, y, z] = arr

console.log(x)

// Destructuring the object
// NOTE : We need to define key as variable name in object destructuring

// let colors = {
//     primary : 'Blue',
//     secondary : 'Grey',
//     danger : 'Red'
// }

// let {primary,secondary,danger} = colors

// console.log(primary)
// console.log(secondary)
// console.log(danger)

// --> We can change key variable name with another name

// let colors = {
//     primary : 'Blue',
//     secondary : 'Grey',
//     danger : 'Red'
// }

// let {primary:p,secondary:s,danger:d} = colors

// console.log(p)
// console.log(s)
// console.log(d)

// --> destructing nested objects

let myobj = {
    name : 'Ashish',
    age : 23,
    gender : 'Male',
    address : {
        country : 'India',
        city : 'Mumbai'
    }
}

let {name, age , gender, address : {country}} = myobj

console.log(name)
console.log(age)
console.log(gender)
console.log(country)

************************************************************************************************
// Modules & Modularity
************************************************************************************************
calc.js
===========================
function add(a,b) {
    console.log(a + b)
}

function sub(a,b) {
    console.log(a - b)
}

function mul(a,b) {
    console.log(a * b)
}

function div(a,b) {
    console.log(a / b)
}

module.exports = {
    addition : add,
    substraction : sub,
    multiplication : mul,
    division : div
}

=========================================
script.js
=========================================
const calculator = require('./calc')

calculator.addition(2,5)
calculator.substraction(8,2)
calculator.multiplication(4,4)
calculator.division(4,2)

=========================================

************************************************************************************************
// Spread & Rest
************************************************************************************************

// Spread
// It is used to do deep copy of the array or object.

// let arr = [3,5,6,7,8]

// let arr1 = arr

// console.log(arr1)

// arr[1] = 789  // Here we change value if index 1 in arr it will affect arr1 too as this method do shallow copy of arr

// console.log(arr1)

// let myobj = {
//     name : 'Ashish',
//     age :  34,
//     gender : 'M'
// }

// let myobj1 = myobj

// console.log(myobj1)

// myobj.age = 23 // same thing happen in objects

// console.log(myobj1)

// To overcome above problem we use spread

let arr = [34,5,6,7]

let arr1 = [...arr]

console.log(arr1)

arr[1] = 89798
// arr1[1] = 90
console.log(arr1)


// for objects

let myobj = {
    name : 'Ashish',
    age : 34,
}

let myobj1 = {...myobj}

console.log(myobj1)

myobj.age = 23
// myobj1.age = 23
console.log(myobj1)


// ===========================================================================================

// Rest
// It is used whenever we need to take multiple values at a time or we need to store remaining values in one variable

function abcd(a,b,c,...d){
    console.log(a,b,c,d)
    console.log(d[5].name)
}

abcd(1,2,3,4,5,6,6,7,{name : 'Ashish'})

************************************************************************************************
// Functional Programming
************************************************************************************************

// It is programming paradigm designed to handle functions in better way in JS (mainly pure function)

// Imperative and declarative functions :



// Imperative functions : How to go about a problem (approach/structure/logic)

// Problem : we will be given number and need to check if square of the number is even or not

// Imperative way of writing code

const num = 4

const squared = num * num

let isEven;

if (squared % 2 == 0) {
    isEven = true
}
else {
    isEven = false
}

console.log('Imperative way of writing code : ',isEven)




// Declarative functions : What to achieve from the problem (shorten the code)

// Declarative way of writing code

const checkForSquare = num => (num * num % 2 == 0 ? true : false)

console.log('Declarative way of writing code : ',checkForSquare(5))

************************************************************************************************
// Impure and Pure Function and its side effects :
************************************************************************************************

// 1. Impure Functions :
// -> It takes same input but gives different output
// -> It uses external factors or resources

// let a = 10

// function addImpure(x) {
//     console.log(x+a)
//     a++
// }

// addImpure(2) // 12
// addImpure(2) // 13
// addImpure(2) // 14


// 2. Pure Functions :
// -> It takes same input and gives same output
// -> It doesn't use any external factors or resources

function addPure(x,a) {
    return x + a
}

console.log(addPure(2,4)) // 6
console.log(addPure(2,4)) // 6
console.log(addPure(2,4)) // 6

************************************************************************************************
// Callback Function :
************************************************************************************************

// It is function which takes another function as an argument which can be invoked later on whenever required.

// writing callback function

function printFirstName(firstname, callback) {
    console.log(firstname)
    callback('Khedekar')
}

function printLastName(lastname) {
    console.log(lastname)
}

printFirstName('Ashish',printLastName) // callback function


// Application of callback function

const isEven = num => {
    return num % 2 == 0
}

let checkEvenNumber = (evenFunc, number) => {
    const result = (evenFunc(number) ? 'Even' : 'Odd')
    console.log(`The given number ${number} is ${result}.`)
}

checkEvenNumber(isEven, 16)

************************************************************************************************
// Higher Order Functions :
************************************************************************************************

// It is function which takes a function as argument or return a function as output

// let do one task we need to make square of all array numbers

// let arr = [1,2,3,4,6]

// let squaredArr = []

// for (let i = 0; i < arr.length; i++){
//     squaredArr.push(arr[i] * arr[i])
// }

// console.log(squaredArr)

// In above task we are writing code imperatively, so to overcome this issue we use one higher order function
// i.e map

// map function :
// map will loop through every element of an array and will perform a specific task that you have provided
// it takes a function as argument
// map will always return a new array with result.

// let arr = [1,2,4,5,6]

// let squaredArr = arr.map(function(elem){
//     return elem * elem
// })

// console.log('Using map function : ',squaredArr)


// const transaction = [1000,3000,4000,2000,-898,3800,-4500]

// const inrToDollar = 80

// let transactionInDollars = transaction.map((tran)=>{
//     return (tran / inrToDollar).toFixed(0)
// })

// console.log('Transaction after converting inr to dollar : ',transactionInDollars)


// // ForEach function :
// // it will loop through every element of an array and will perform a specific task that you have provided
// // it takes a function as argument
// // it will work inside forEach scope doesn't return anything


// const transaction1 = [1000,3000,4000,2000,-898,3800,-4500]

// const dollarToInr = 80

// let transactionInInr = transaction.forEach((amount)=>{
//     console.log('Transaction after converting dollar to inr : ',amount * dollarToInr)
// })

************************************************************************************************
// find and findIndex methods :
************************************************************************************************

// find will returns the first element of an array that satisfies the condition

// const transaction = [1000,3000,4000,2000,-898,3800,-4500]

// let firstWithdrawl = transaction.find(function(amount){
//     return amount < 0
// })

// console.log('First Withdrawl : ',firstWithdrawl)


// // findIndex will returns the first element index from an array that satisfies the condition 

// let firstWithdrawlIndex = transaction.findIndex(function(amount){
//     return amount < 0
// })

// console.log('Index of First Withdrawl : ',firstWithdrawlIndex)

// ===============================================================================================

// some and every :

// some will return true or false based on condition 
// it will return true even if one satisfies the condition


// const transaction = [-1000,-3000,-4000,-2000,898,-3800,-4500]

// let resultSome = transaction.some(function(amount){
//     return amount > 0
// })

// console.log('The result of some : ',resultSome)


// // every will return true or false based on condition 
// // it will return true if all satisfies the condition

// let resultEvery = transaction.every(function(amount){
//     return amount < 0
// })

// console.log('The result of every : ',resultEvery)

************************************************************************************************
// Filter method :
************************************************************************************************

// filter method will return new array it will return all those elements that satisfies the specific condition

// let arr = [1,3,5,6,8,88,35,454,6457]

// let evenArr = arr.filter(function(num){
//     return num % 2 == 0
// })

// console.log('Even numbers : ',evenArr)


// // find all transactions which are positive

// const transaction = [1000,3000,4000,-2000,-898,3800,-4500]

// let depositAmount = transaction.filter(function(amount){
//     return amount > 0
// })

// console.log('Credited Amount : ',depositAmount)

// ==============================================================================

// Reduce method :
// It will return one result value after performing some operations inside function
// function which is passed as parameter takes two value (accumulator and value)

// problem : you need to sum every even element of array

// imperative way :

// let arr = [1,2,3,5,10]

// let sumOfEven = 0

// for (let i = 0; i < arr.length; i++) {
//     sumOfEven += (arr[i] % 2 == 0 ? arr[i] : 0)
// }

// console.log('Imperative way of finding the even number sum of array : ',sumOfEven)


// declarative way using reduce method:

// let arr = [1,2,3,5,10]

// let sumOfEven = arr.reduce((accumulator, value)=>{
//     return (value % 2 == 0 ? accumulator + value : accumulator + 0)
// }, 0)

// console.log('Declarative way of finding the even number sum of array : ',sumOfEven)

// ************************************************************************************************
// Chaining :
// ************************************************************************************************

// chaining will help to process multiple higher order functions in same line one after another.

// problem 1 : you need to filter out all males and return ages of all males

// let persons = [
//     {name : 'A',age : 23,gender : 'M'},
//     {name : 'B',age : 24,gender : 'F'},
//     {name : 'C',age : 27,gender : 'F'},
//     {name : 'D',age : 29,gender : 'M'},
//     {name : 'E',age : 34,gender : 'M'},
//     {name : 'F',age : 36,gender : 'F'},
//     {name : 'G',age : 21,gender : 'M'},
//     {name : 'H',age : 19,gender : 'F'},
// ]

// will solve without using chaining

// let males = persons.filter(function(male){
//     return male.gender == 'M'
// })

// let malesAges = males.map((male)=>{
//     return male.age
// })

// console.log('Ages of all males in array without using chaining : ',malesAges)


// using chaining

// let maleAges = persons.filter(function(males){
//     return males.gender == 'M'
// }).map((male)=>{
//     return male.age
// })

// console.log('Ages of all males in array using chaining : ',maleAges)

// Problem 2 : 
// from transaction array filter out positive amount and calculate the total amount 

// let transaction = [1000,3000,4000,2000,-898,3800,-4500]

// let totalAmount = transaction.filter((amount)=>{
//     return amount > 0
// }).reduce((acc,value)=>{
//     return acc +  value
// },0)

// console.log('Total amount of all positive element : ',totalAmount)


// ************************************************************************************************
// Object Oriented Programming :
// ************************************************************************************************

// It is computer programming model that organizes software design around data or objects rather than function or logic.
// An object can be defined as data field that has unique attributes and behaviour.

// 4 pillars of oops :

// 1. Encapsulation
// 2. Abstraction
// 3. Polymorphism
// 4. Inheritance

// IMP : javascript is not actually an object oriented language but we can write object oriented code by using 
// something called as prototype object

// ================================================================================================================

// this keyword :
// this keyword refers to an object

// ========================================================================================

// this keyword in node.js runtime env under non-strict mode :

// -----------------------------------------------------
// 1. on console :

// console.log(this) // returns empty object

// -----------------------------------------------------

// 2. inside function :

// function displayThis() {
//     console.log(this) // returns global object
// }

// -----------------------------------------------------

// 3. inside object --> function :

// let myObj = {
//     name : 'Ashish',
//     age : 23,
//     myFun : function(){
//         console.log(this) // returns object itself
//     }
// }

// myObj.myFun()

// -----------------------------------------------------

// 4. inside object --> function --> function :


// let myObj = {
//     name : 'Ashish',
//     age : 23,
//     myFun : function(){
//         function myFun1() {
//             console.log(this) // returns global object
//         }
//         myFun1()
//     }
// }

// myObj.myFun()

// ===========================================================================================

// this keyword in node.js runtime env under strict mode :
// 'use strict'  // need to mention this string on top of code for using strict mode

// -----------------------------------------------------
// 1. on console :

// console.log(this) // returns empty object

// -----------------------------------------------------

// 2. inside function :

// function displayThis() {
//     console.log(this) // returns undefined
// }

// -----------------------------------------------------

// 3. inside object --> function :

// let myObj = {
//     name : 'Ashish',
//     age : 23,
//     myFun : function(){
//         console.log(this) // returns object itself
//     }
// }

// myObj.myFun()

// -----------------------------------------------------

// 4. inside object --> function --> function :


// let myObj = {
//     name : 'Ashish',
//     age : 23,
//     myFun : function(){
//         function myFun1() {
//             console.log(this) // returns undefined
//         }
//         myFun1()
//     }
// }

// myObj.myFun()

// ===========================================================================================

// this keyword in browser under non-strict mode :

// -----------------------------------------------------
// 1. on console :

// console.log(this) // returns window object

// -----------------------------------------------------

// 2. inside function :

// function displayThis() {
//     console.log(this) // returns window object
// }

// -----------------------------------------------------

// 3. inside object --> function :

// let myObj = {
//     name : 'Ashish',
//     age : 23,
//     myFun : function(){
//         console.log(this) // returns object itself
//     }
// }

// myObj.myFun()

// -----------------------------------------------------

// 4. inside object --> function --> function :


// let myObj = {
//     name : 'Ashish',
//     age : 23,
//     myFun : function(){
//         function myFun1() {
//             console.log(this) // returns window object
//         }
//         myFun1()
//     }
// }

// myObj.myFun()

// ===========================================================================================

// this keyword in browser under strict mode :
// 'use strict'  // need to mention this string on top of code for using strict mode

// -----------------------------------------------------
// 1. on console :

// console.log(this) // returns window object

// -----------------------------------------------------

// 2. inside function :

// function displayThis() {
//     console.log(this) // returns undefined
// }

// -----------------------------------------------------

// 3. inside object --> function :

// let myObj = {
//     name : 'Ashish',
//     age : 23,
//     myFun : function(){
//         console.log(this) // returns object itself
//     }
// }

// myObj.myFun()

// -----------------------------------------------------

// 4. inside object --> function --> function :


// let myObj = {
//     name : 'Ashish',
//     age : 23,
//     myFun : function(){
//         function myFun1() {
//             console.log(this) // returns undefined
//         }
//         myFun1()
//     }
// }

// myObj.myFun()

// ************************************************************************************************
// Constructor Functions :
// ************************************************************************************************

// It is used for reusability of the code or we can say it works as template
// we can create constructor function using new keyword and it will starting pointing to this keyword of function
// we can define method using this keyword

// function createCar(name, company, color) {
//     this.name = name
//     this.company = company
//     this.color = color

//     this.drive = function () {
//         console.log(`I am driving ${this.name} and it is of ${this.color} color 🤩.`)
//     }
// }

// let car1 = new createCar('X4','BMW','White')

// console.log(car1)

// let car2 = new createCar('S-class', 'Mercedes', 'Silver')

// console.log(car2)

// // also we can add method to above constructor function

// car1.drive() 

// car2.drive()


// ************************************************************************************************
// Classes :
// ************************************************************************************************

// It is blueprint or template which consists of data and methods

// class Person {
//     constructor(name, age){
//         this.name = name
//         this.age = age
//     }

//     canDrive(){
//         (this.age > 18 ? console.log(`Hey! ${this.name} your age is above 18 hence you can drive`) : console.log(`Hey! ${this.name} your age is below 18 hence you can't drive`))
//     }
// }

// let person1 = new Person('Ashish',23)

// person1.canDrive()

// let person2 = new Person('Shivani',16)

// person2.canDrive()

// ************************************************************************************************
// Classical Inheritance :
// ************************************************************************************************

// It is used for code reusability
// Properties and methods of Base class can be put down or accessed in derived class
// extends keyword is used for inheritance
// super method is used to access properties and methods of base class

// class Person {
//     constructor(name, age){
//         this.name = name
//         this.age = age
//     }

//     greet(){
//         console.log(`Hey! Good Morning ${this.name}`)
//     }
// }

// class Teacher extends Person{
//     constructor(name, age, department){
//         super(name, age)
//         super.greet() // calling base class method on constructor invokation
//         this.department = department
//     }
// }

// class Student extends Person {
//     constructor(name, age, subjects){
//         super(name, age)
//         this.subjects = subjects
//     }

//     greeting(){
//         super.greet() // calling base class method in derived method using super keyword
//     }
// }


// let teacher = new Teacher('Ashish', 23, 'IT')

// console.log(teacher)


// let student = new Student('Shivani', 23, ['IT','Maths','Science'])
// student.greeting() 
// console.log(student)

// ************************************************************************************************
// Polymorphism :
// ************************************************************************************************

// poly --> many
// morph --> forms
// ism --> method
// It means that one can have many forms

// class Animal {
//     sound(){
//         console.log('Animal can make different sounds')
//     }
// }

// class Dog extends Animal{
//     // sound(){
//     //     console.log('Dog barks')
//     // }
    
// }

// class Cat extends Animal{
//     sound(){
//         console.log('Cat mews')
//     }
// }

// let dog = new Dog()
// dog.sound()

// ************************************************************************************************
// Encapsulation :
// ************************************************************************************************

// It is used to hide the properties of class or function

// using function

// function Person(_name, _age) {
//     var name = _name // here var keyword is working as access modifier
//     var age = _age

//     this.getName = function(){
//         return name
//     }

//     this.getAge = function(){
//         return age
//     }
// }

// let person1 = new Person('Ashish',23)

// console.log(person1)
// console.log(person1.getName())
// console.log(person1.getAge())

// // updating existing properties

// person1.name = 'Shivani' // not updating existing properties

// console.log(person1.getName()) // still it is showing 'Ashish'

// ================================================

// using class 

// class Person {
//     constructor(name, age){
//         this._name = name
//         this._age = age
//     }

//     get getName(){
//         return this._name
//     }

//     set setName(name){
//         this._name = name
//     }
// }

// let person2 = new Person('Ashish',23)

// console.log(person2)

// console.log(person2.getName)

// person2._name = 'Shivani'


// console.log(person2)

// ************************************************************************************************
// Prototype :
// ************************************************************************************************

// In JavaScript, the prototype is an internal property of objects that is used for inheritance. 
// Each object in JavaScript has a prototype, which is a reference to another object. 
// we can create our own prototype method in our object prototype

// Prototype chainig :
// When you access a property on an object, and if the property is not found on the object itself, 
// JavaScript looks for the property in the object's pre-built prototype, and this process continues up the prototype chain until the property is found or the end of the chain is reached. 


// function Person(name, age){
//     this.name = name
//     this.age = age
// }

// // creating prototype method

// Person.prototype.getNameAndAge = function(){
//     console.log(`My name is ${this.name} and my age is ${this.age}`)
// }

// let person1 = new Person('Ashish',23)

// console.log(person1)

// person1.getNameAndAge()


// let person2 = new Person('Shivani',24)

// console.log(person2)

// person2.getNameAndAge()

// ************************************************************************************************
// call, apply and bind :
// ************************************************************************************************

// call method :
// The call method is used to invoke a function with a specific 'this' value and arguments provided individually.
// It immediately executes the function with the specified this value and arguments.

// let printDetails = function(city){
//     console.log(`Hey ! My name is ${this.name} and I am ${this.age} years old and I am from ${city}`)
// }

// let person1 = {
//     name : 'Ashish',
//     age : 23
// }

// printDetails.call(person1,'Mumbai')


// apply method :
// The apply method is similar to call, but it takes an array of arguments instead of individual arguments.


// let person2 = {
//     name : 'Shivani',
//     age : 23
// }

// printDetails.apply(person2,['Nashik'])


// bind method :
// The bind method is used to create a new function with a specified this value and initial arguments.
// It does not immediately execute the function but returns a new function that, when called, has the this value and arguments provided during the bind call.

// let person3 = {
//     name : 'Adarsh',
//     age : 21
// }

// let bindFunc = printDetails.bind(person3,'Lonere')

// bindFunc()

// ************************************************************************************************
// Synchronous programming & Asynchronous programming :
// ************************************************************************************************

// It means it is single threaded, so only one operation or program will run at a time.

// Asynchronous programming :
// It means a server can send multiple requests at a time.

// how async code works :
// there are 3 queues :
// 1. callstack queue -> here all sync code go and execute one by one
// 2. node/browser apis -> all callback functions goes here and wait until all sync code gets completed
// 3. callback queue -> all callback functions comes here in random order and wait for event loop
// 4. event loop --> it work as security it checks if callstack queue is empty if it is then it will send one callback func to callstack for execution

// In above working callback function execution is in random manner
// To make execution in serial manner we can call next function at the end of previous function

// const fs = require('fs')
// console.log('Started')

// fs.readFile('f1.txt',cb1)

// function cb1(error, data){
//     if (error){
//         console.log(error)
//     }
//     else {
//         console.log('File 1 data -> ',data)
//     }
//     fs.readFile('f2.txt',cb2)
// }

// function cb2(error, data){
//     if (error){
//         console.log(error)
//     }
//     else {
//         console.log('File 2 data -> ',data)
//     }
//     fs.readFile('f3.txt',cb3)
// }

// function cb3(error, data){
//     if (error){
//         console.log(error)
//     }
//     else {
//         console.log('File 3 data -> ',data)
//     }
// }

// console.log('Completed')

// ==============================================================

// setTimeout function :
// It is async function
// It takes two parameter -> setTimeout(callback function, timeout in milisecond)

// console.log('Started')

// function greet(){
//     console.log('Hello from setTimeout function')
// }

// setTimeout(greet, 5000)

// console.log('Completed')


// -----------------------------------------

// setInterval function :
// it is async finction
// it will run after every milisecond mention in paramter
// it takes two parameter -> setInterval(callback function, time in milisecond)

// console.log('Started')

// function hello(){
//     console.log('Hello from setInterval')
// }

// let timer = setInterval(hello, 1000)

// // to break setInterval function we require setTimeout and clearInterval function

// setTimeout(function(){
//     clearInterval(timer)
// },3000)

// console.log('Completed')

// ************************************************************************************************

// Promises :

// In JavaScript, promises are a programming construct that represents the eventual completion or failure of an asynchronous operation and its resulting value. 
// They provide a cleaner and more organized way to work with asynchronous code compared to traditional callback functions.

// how to construct a promise

// let myPromise = new Promise(function(resolve, reject){
//     const a = 6
//     const b = 6

//     setTimeout(()=>{
//         if (a === b){
//             resolve('The values are equal')
//         }
//         else{
//             reject('The values are not equal')
//         }
//     },2000)
// })

// consuming a promise

// pending state

// console.log(myPromise)

// fulfiled state

// myPromise.then(function(result){
//     console.log(result)
// })

// // rejected state

// myPromise.catch(function(error){
//     console.log(error)
// })

// settled state

// we can right fulfiled or rejected on below manner

// myPromise
// .then((result1)=>{
//     console.log(result1)
// })
// .catch(function(error){
//     console.log(error)
// })

// ===========================================================================

// problem : create a coffee shop which only takes orders of coffee

// function coffeeShop(order){
//     return new Promise(function(resolve, reject){
//         if (order === 'coffee'){
//             resolve('Order has been placed')
//         }
//         else {
//             reject('Order has been rejected')
//         }
//     })
// }

// function processOrder(order){
//     return new Promise(function(resolve){
//         console.log('Order is being processing ....')
//         resolve(`${order} and is served.`)
//     })
// }

// coffeeShop('coffee').then(function(orderPlaced){
//     console.log(orderPlaced)
//     return processOrder(orderPlaced)
// }).then(function(processedOrder){
//     console.log(processedOrder)
// }).catch(function(orderRejected){
//     console.log(orderRejected)
// }) // chaining of promise


// async await --> this are keyword which makes promises much simplier
// In async await we need to use try catch block to handle rejected cases
// writing above code using async await

// async function serverOrder(){
//     try {
//         let orderPlaced = await coffeeShop('coffee')
//         console.log(orderPlaced)
//         let processedOrder = await processOrder(orderPlaced)
//         console.log(processedOrder)
//     } catch (error) {
//         console.log(error)
//     }
// }

// serverOrder()

// ************************************************************************************************
// Comparison Operators :
// ************************************************************************************************

// loose checking or '==' :
// This operator will be check only value 

// let a = 6
// let b = '6'

// console.log(a==b)


// strict checking or '===' :
// This operator will check both value and type

// let x = 4
// let y = '4'

// console.log(x===y)


// ====================================================================================================
// Truthy & Falsy :
// ====================================================================================================

// All falsy values :
// false
// 0
// -0
// 0n
// '',"",``
// NaN
// null
// undefined

// let a = 1

// if (a){
//     console.log('I am truthy')
// }
// else {
//     console.log('I am falsy')
// }

// problem :

// (function(){
//     if ((-100 && 100 && "0") || [] === true || 0){
//         console.log(1) ✅

//         if ([] || (0 && false)) {
//             console.log(2) ✅
//         }

//         if (Infinity && NaN && 'false') {
//             console.log(3)

//             if ('') {
//                 console.log(4)
//             }
//         }
//         else{
//             console.log(5) ✅

//             if (({} || false === '') && !(null && undefined)) {
//                 console.log(6) ✅
//             }
//         }
//     }
// })()


// ----------------------------------------------------------------------------------------------
// Primitive Data Types :
// ----------------------------------------------------------------------------------------------

// They are immutable and cannot change once assign
// It is stored in stack memory

// Numbers, Strings, Booleans, Null, Undefined are of primitive data types

// let a = 5

// let b = a

// a = 4

// console.log(a)
// console.log(b)

// let x = 'Ashish'

// let y = x

// x = 'SK'

// console.log(x)
// console.log(y)

// let n = true

// let m = n

// n = false

// console.log(n)
// console.log(m)

// -------------------------------------------------------------------------------------
// Reference Data Types :
// -------------------------------------------------------------------------------------

// They are mutable and can be changed
// They are stored in heap memory but address of heap memory is stored in stack memory

// objects, arrays and functions are reference data types

// let firstPerson = {
//     name : 'Ashish',
//     age : 23
// }

// let secondPerson = firstPerson

// firstPerson.name = 'Shivani'

// console.log(firstPerson)
// console.log(secondPerson)


// let firstPerson = [1,2,4,5,6]

// let secondPerson = firstPerson

// firstPerson[2] = 0

// console.log(firstPerson)
// console.log(secondPerson)

// -------------------------------------------------------------------------------------------
// Shallow Copy :
// -------------------------------------------------------------------------------------------

// To overcome the problem of referencing we use shallow copy i.e spread operator {...}

// let firstPerson = {
//     name : 'Ashish',
//     age : 23
// }

// let secondPerson = {...firstPerson}

// secondPerson.name = 'Shivani'

// console.log(firstPerson)
// console.log(secondPerson)

// but shallow copy will not work on nested objects

// let firstPerson = {
//     name : 'Ashish',
//     age : 23,
//     address : {
//         city : 'Mumbai',
//         state : 'MH'
//     }
// }

// let secondPerson = {...firstPerson}

// secondPerson.address.city = 'Pune' // here both objects gets changed

// console.log(firstPerson)
// console.log(secondPerson)


// ===============================================================================
// Deep Copy :
// ===============================================================================

// This is used to overcome the problem with shallow copy 
// It will make separate reference for all objects which are getting created with reference to previous one
// we use JSON.parse(JSON.stringfy(object))


// let firstPerson = {
//     name : 'Ashish',
//     age : 23,
//     address : {
//         city : 'Mumbai',
//         state : 'MH'
//     }
// }

// let secondPerson = JSON.parse(JSON.stringify(firstPerson)) // Deep copy

// secondPerson.address.city = 'Pune' // here both objects gets changed

// console.log(firstPerson)
// console.log(secondPerson)

// ===============================================================================
// Closures :
// ===============================================================================

// In JavaScript, a closure is a combination of a function and the lexical environment within which that function was declared. 
// A lexical environment consists of any local variables that were in-scope at the time the closure was created. 
// In simpler terms, a closure allows a function to access variables from its outer (enclosing) scope even after the outer function has finished executing.

// function outerFunction() {
//     let a = 9

//     function innerFunction(){
//         console.log(a)
//     }

//     return innerFunction
// }

// let fun = outerFunction()

// fun()


// ------------------------------------------

// function outerFunction() {
//     let age = 9

//     function innerFunction(){
//         console.log(age)

//         let name = 'Ashish'

//         function greet(){
//             console.log(`My name is ${name} and I am ${age} years old`)
//         }
        
//         return greet
//     }

//     return innerFunction
// }

// let fun = outerFunction()

// let g1 = fun()

// fun()
// g1()

// ===============================================================================

// ===============================================================================

// Function Currying :

// Currying is a technique in functional programming where a function is transformed into a sequence of functions, each taking a single argument. 
// The curried function returns a new function for each argument until it receives all the necessary arguments and finally evaluates the original function.


// Manual currying
// function curry(fn, ...args) {
//     return function (...newArgs) {
//         const allArgs = [...args, ...newArgs];
//         console.log(allArgs)
//         if (allArgs.length >= fn.length) {
//             return fn(...allArgs);
//         } else {
//             return curry(fn, ...allArgs);
//         }
//     };
// }

// // Example usage
// function add(a, b, c) {
//     return a + b + c;
// }

// const curriedAdd = curry(add);
// // console.log(curriedAdd)
// console.log(curriedAdd(1)(2)(3)); // Output: 6
// console.log(curriedAdd(1, 2)(3)); // Output: 6
// console.log(curriedAdd(1)(2, 3)); // Output: 6
// console.log(curriedAdd(1, 2, 3)); // Output: 6

// ===============================================================================

// typeof :
// It is used to check the type of any variable

// let a = 9

// console.log(typeof a)

// let b = 'Ashish'

// console.log(typeof b)

// let c = {
//     name : 'ashish'
// }

// console.log(typeof c)

// let arr = [344,6,7,8,]

// console.log(typeof arr)

// ===============================================================================

// Array.isArray :
// This will help to check type of array

// let arr = [3,4,5,6,]

// let checkArrayType = Array.isArray(arr)

// console.log(checkArrayType)

// ===============================================================================