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(){})


    // First class 

###  Pure Function
A **pure function** always gives the same output for the same input and does not modify anything outside its scope.        

// pure Function = ek aisa function jo ye 2 chiZe Follow karta hai
                    same input hone par same output hota hai 
                    koi side effect nahi hoga

// impure function 
    same input = diffrent output ho sakta hai 
               side effect hosakta hai       

// Closure -> ek function hai jo return karta hai function but
              returning function jo hai wo parent function ka koi variable use kar gaaa 
        
    function ab(){
        let a= 12;
        return function(){
            console.log(a)
        }
    }
    let fun= ab()
    fun()

/* 🔥 Closure kya hai?

Jab ek inner function, apne outer function ke variables ko remember karta hai, even after outer function ka execution khatam ho gaya ho, usko Closure kehte hain.

Tere example mein:

ab()
 │
 ├── a = 12
 │
 └── inner function
       │
       └── remembers → a
       
*/

// ======================================Return ==============================================
🔥 return kya karta hai?

return function ke andar ka result function ke bahar bhejta hai.
return = function ka result bahar bhejna + function ko wahi stop kar dena. 🧠

JavaScript mein return ko function ke bahar use nahi kar sakte. ❌

return 10;

Function ke bahar → SyntaxError

return ka purpose hi hai function se value bahar bhejna aur function ko stop karna.


// =================+++++++++++++++++++++ Arrays +++++++++++++++++++++======================

// Ararys ->
//  ek se jaada members rakhne ki jagah hote hai
             // 0   1   2    3    4    5    6 
    let arr = [671,902,3534,4534,5675,8996,4567]
    console.log(arr[5])

// How to create Arrays in JS
    let arr = []
    let arr2 = new Array()
/*[]              → array banao
[5]             → 5 ko value samjho

new Array()     → empty array
new Array(5)    → 5 length ka empty array
new Array(5,6)  → [5,6]*/

matalb arr[5] ye bus 1 array ho ga [5]
NewArray(5) 5 length honge [0,1,2,3,4]



// Understanding how to Accessing Elements in Array

    let arr = [1,2,3,4,5]
    console.log(arr[3])


// Function on Arrays -[push, pop , shift,unshift, indexof, array destructuring ,filter, some,
                        map ,reduce ,spread operator, slice, reverse , sort, join, toString]


// Iterating over Arrays using -[For loop , forEach-ye shirf array par chalta hai ]

// let arr = [1,2,3,4]
// for(let i = 0; i<4; i++){
//     console.log(arr[i])
// }
// let arr = [1,2,3,4]
// arr.forEach(function(val){
//     console.log(val)
// })



// -Understanding what are Object in JS 
// [key-value pair]


let obj ={
//  KEY    VALUE
    name :"aakash",
    age :25,
    email:"aakash@gmail.com"
}

let obj2 =new Object();

1️⃣ Object Literal — {}
let obj = {
    name: "aakash",
    age: 25,
    email: "aakash@gmail.com"
}

Isko Object Literal bolte hain.

Yaha tum object banate waqt hi properties de rahe ho:

obj.name   // "aakash"
obj.age    // 25
2️⃣ new Object()
let obj2 = new Object();

Ye bhi ek empty object banata hai.

Ab properties baad me add kar sakte ho:

obj2.name = "aakash";
obj2.age = 25;
obj2.email = "aakash@gmail.com";

Ab obj2 bhi almost obj jaisa hi ho gaya.

🔥 Main difference
let obj = {}	let obj2 = new Object()
Object Literal	Object Constructor
Short & simple	Thoda lengthy
Most commonly used	Rarely needed
Properties directly likh sakte ho	Baad me bhi add kar sakte ho



// Nested Object 
    let obj={
        name:"aakash",
        socials:{
            instagram:"_aakash7781",
            facebook:"aakash",
        }
    }
    console.log(obj.socials)