Notes.txt

var let const
const :- fixed value

Types of console 
console.log("hi")
console.info("hi") // is me and console.log me koi differnce nahi hota bus kisi kisi browser me i icon aata hai 
console.warn("hi")
console.error("hi")
console.table({name: "Aakash"})// isme object ki jarurat hai 

// Prompt alert // ye humesha STRING me value leta hai 
let nm = prompt("name ?")
console.log(nm)

// Is ko string se number yani INT me convert karne ke 3 tarike hai 
1. parseInt(nm)
2. Number(nm)
3.let nm = +prompt("name ?")

//   let age = prompt("age batao")
    if (age === null){ // agar cancel par clik kiya tho 
        console.log("abe cancel daya ")
    }
    else 
    { if (age.trim() === ""){ // agar sapce ke saath kuch likha ho (            a               ) tho ye trim kar dega
        console.log(`bhai sahi se likh le `)
    }


// Data Types
    int,float,String,boolean

// array 
    array ek se jada chizo k liye hota hai 
    ["AAKASH","RAN","ANKUR"]
    object ek bande ki kai saari cheejo k liye hota hai 
    {
        name:"AAKASH",
        class :"JS"
    }

undifine 
var a;

//NAN - koi number ke saath aisa operation kiya jo ho nahi skta to NAN milta hai 
        12*"AALASJ" = 
        
Infinity = 1/0

// relative and primitive datatyes in JS

refrence - array objects funtions 
primitive - number booleans Strings null undined NAN Infinity Sumbol Big INT

primitive - jinki value direct copy kar sate hai 
refrence  - jinki value direct copy nahi kar saktea hai 

typeof 12 :- kisi ka bhi type dekha na ho tho uske aaga typeof likh do 

.slice(2,6)
.split("")
.replace("love","study at")
.includes("love")

Comparison Operators 

== === != !== > < >= <=

//== not strict compare NEVER USE THIS 
//==== Strict compare ALWAYS USE THIS
// != NEVER USE THIS 
// !== ALWAYS USE THIS 


Logical Operators

&& || !

// true && true = true //username === exist && password === userpassword
// false && true = false
// true && false = false
// false && false = false

// true || true = true
// true || false = true
// false || true = true
// false || false = false

! not :- ulta karta hai true ko false and false ko true 


Ternary Operator 

// condition ? doThis : doThat // is me 1st condition hota hai uske baad agar wo condition true ho tho ? ke baad wala chalta hai, false ho tho : ke baad wala 
25>33 ? console.log("Ha 25 bada hai "):console.log("nahi  bada nahi hai ")

Type CHecking Operator

// Typeof 
//instanceof 


String Operator

// + (for concatenation)
"AAKASH"+"TIWARI"

// Nullish Coalescing Operator
// ?(fallback only when null / undefined)


// Variable hoisting in JS 
// hoisting ka matlab hai ki variable ko banane se pahle bhi use kiya jaa sakta hai 
// hoisting me aapka variable toot jata hai 
// intialization wohi rehta hai jaha variale tha
// ab aapka variable error nahi deta kyuki wo humesha use hone se phale exist kr rha tha
// hoisting let ke saath work nahi karta 


///###### Loops $ Conditionals in Javascrpit
//if else 
// truthy and falsy 
// 0 "" false NaN null undefined document.all
// kuch bhi dikhe -> true

Loops 

for(start;end;change)


while :- tab tak chalo jab tak condition true hai 

start
while(end){
    ////Your code 
    //change
}

example 

let i =1;
while(i<11){
  console.log("hello")
  i++;
}

// do while


// let i=1
// do {
//     console.log("1")
//     i++
// }while(1<10)

// --- Recursion In JS
===> funtions calling in itself

EXAMPLE 

    // function abcd(){
//     console.log("hey")
//     abcd()
// }
// abcd()

// Continue in JS
continue ka simple meaning hai:
    Current iteration ko skip karo aur next iteration par chale jao.

// funtion in JS 
====> aapka code jo turant nahi chalega tab chalega jab aap bole ge ki chalo
      aap us code ko kitni bhi baar chala sakte ho
      kisi kaam ko repat karna ho ya fir jo baar baar ho rha hai use specific time par karna ho tho funtion ka use karte hai 

      EXAMPLE
function khanakhaao(){
    console.log("step 1")
    console.log("step 2")
    console.log("step 3")
    console.log("step 4")
}
khanakhaao()



// parameter in JS
function doSomething(name, age, email){
    console.log(name,age,email)
     console.log(arguments) // is arguments ke help se hum values ko access kar sakete ye 2nd way hai 
                            [0] is tarah se bhi hum values ko access kar sakte hai 
    }
doSomething("Aakash",25,"aakash@gmial.com")



// variable hoisting
a() // ayise use nahi kar sakte variable me 
var a = function(){

}
a()// ayise use kar sakte ha 
function a(){}


// function 

// 1. why we use function
    code ko reuse karne mein help karta hai, function ko hum jab chaye tab chala sakte hai 

    
//  parameters and arguments in funtion 

function abcd(age, name ){
    // parameter
}
abcd(12,vicky) // arguments


// rest parameter 

function abcd(a,b,...c){ // is me b ke aage ke c tak sub ek array me chale jayenge 
    console.log(a,b,c)
}
abcd(1,2,3,4,5,6,7,8,9)



// hoisting :- kisi cheeZ ke bane ke phale uska istmal kar pana 

a() // function me hum is difine hone se phale bhi use kar sakte hai 
function a(){
    console.log(
        "aakash"
    )
}

// hoisting :- kisi cheeZ ke bane ke phale uska istmal kar pana 

 // function me hum is difine hone se phale bhi use kar sakte hai 
// function a(){
//     console.log(
//         "aakash"
//     )
// }

// var a=function(){
//     console.log(
//         "aakash"
//     )
// }
// Error :- Uncaught TypeError: a is not a function

// function a(){} → poora function hoist ✅
// var a = function(){} → sirf a hoist, value initially undefined ❌



// - Paramertes in JS - [`required`, `destructured`, `rest`, `default`]

// required parameter

    // function abcd(a,b,c,d){
    //     console.log(a,b,c,d)
    //     // agar aapne parameter banaaye and aapne unme arguments nahi bheje tho fir wo value parameter ki undifined ho jaayegi
    // }
    // abcd()


// default parameter

// function ab(a=0,b=0,c=0){ // ye ha par hum default values de salte hai other wise undifined aaye ga 
//     console.log(a,b,c)
// }
// ab(1,2)

// `destructured`, `rest`, ===> is ke like OOPS and object lage ga


// - Arguments in JS -[`positional`,`default`, `spread`]

// function ab(a=0,b=0,c=0,d=0){// default hai
//     console.log(a,b,c,d)
// }
// ab(1,2,3,4) // ye [psitional hai]

// function ab(a=0,b=0,c=0,d=0){// default hai
//     console.log(a,b,c,d)
// }
// let arr=[1,2,3,4] // ye hai spread 
// ab(...arr) // ye [psitional hai]

// function Types
    [Classic function, Nested function(funtion within function// function ke ander function), Scope Chain in JS]

    // Nested Function
    function ab(){
        function cd(){
            console.log("ander ka chala cd")
        }
        cd()
    }
    ab()


    // Scope chain
    let a=12 //global scope
    function abcd(){
         let b = 13;
         function df(){
            console.log(b)
         }
         
    }
    abcd()


- Understanding Immediately Invoked Function Expression (IIFE)
    
(function () {})()(
  // - function without name ,  this use to make private variable

  // example

  function () {
    let balance = 5000;
  },
)();


// More Functions in JS -[Arrow Function. Fat Arrow, Anonymousm, Higher Order, Callback,First class, Pure Function, Impure Function]
// Arrow Function :- normal 
    Eg:- 
    let function a(){
        console.log("Aakash")
    } 

//  Fat Arrow Function 
    ()=>{}
    ({})=>{}

let fnc = ()=>{
    console.log("Aaaaa")
}
fnc()

// Anonymous Function :- ek ayisa function jiska koi naam naa ho 
    // function() {
    //     console.log("Hello");
    // }


// Higher Order Function 
    // 1. ek aisa fnc jo ki return karde ek aur funtion 
    // wo fnc accept karle ek aur fnc parameter main 

    // 1.
    function abcd(){
        return function(){
        }
    }

    //2.
    function ab(){
    }
    ab(function cd(){})