Code10x

var, FUNCTION-SCOPED hai, aur RE-DECLARE ho sakta hai. let, BLOCK-SCOPED hai, RE-ASSIGN ho sakta hai LEKIN RE-DECLARE NAHI. const, BLOCK-SCOPED hai, aur RE-ASSIGN NAHI ho sakta.

==, TYPE COERCION (AUTOMATIC TYPE CONVERSION) KARKE COMPARE karta hai. ===, "STRICT EQUALITY" hai — TYPE aur VALUE, DONO SAME HONE CHAHIYE, KOI CONVERSION NAHI.

PRIMITIVE: string, number, boolean, null, undefined, symbol, bigint. NON-PRIMITIVE: object (arrays, functions, objects SAB ISI mein AATE hain).

undefined, EK VARIABLE ki DEFAULT STATE hai (DECLARE HUA, LEKIN VALUE ASSIGN NAHI HUI). null, EXPLICITLY, PROGRAMMER dwara, "KOI VALUE NAHI" SET karne ke liye USE hota hai.

JavaScript, VARIABLE aur FUNCTION DECLARATIONS ko, EXECUTION SE PEHLE, MEMORY mein, "UPAR" MOVE kar deta hai — isliye, KUCH CODE, DECLARATION SE PEHLE bhi, USE ho sakta hai (var/function ke SAATH).

BACKTICK CHARACTERS SE, MULTI-LINE STRINGS aur EMBEDDED EXPRESSIONS (DOLLAR-BRACE SYNTAX SE VARIABLES DIRECTLY STRING ke ANDAR) LIKHNE ka MODERN TAREEKA — STRING CONCATENATION (+) se ZYAADA READABLE.

Arrays, ORDERED, INDEX-BASED COLLECTIONS hain ([1,2,3]). Objects, KEY-VALUE PAIRS ka UNORDERED COLLECTION hain ({name: "Aarav"}).

EK VALUE ka DATA TYPE, STRING ke FORMAT mein — jaise typeof "hello" → "string", typeof 42 → "number".

Arrow functions, SHORTER SYNTAX DETI HAIN, aur APNA khud ka this NAHI RAKHTI (SURROUNDING SCOPE ka this INHERIT karti hain) — NORMAL functions, APNA ALAG this RAKHTI hain, CALL KE CONTEXT PAR DEPEND karta hai.

EK FUNCTION JO, EK YA MULTIPLE FUNCTIONS ko, ARGUMENTS ke ROOP mein LETA hai, YA EK FUNCTION RETURN karta hai — jaise map(), filter().

EK INNER FUNCTION, JO, OUTER FUNCTION KE VARIABLES ko, OUTER FUNCTION KE RETURN HONE KE BAAD BHI, "REMEMBER" karti hai — DATA PRIVACY aur STATE PRESERVE karne ka POWERFUL WAY.

EK FUNCTION JO, DEFINE HOTE HI, IMMEDIATELY, EXECUTE ho jaata hai — (function() { ... })() SYNTAX SE — VARIABLES ko GLOBAL SCOPE mein LEAK hone SE ROKTA hai.

Document Object Model — HTML DOCUMENT ka, EK TREE-LIKE, PROGRAMMATIC REPRESENTATION, JISE JavaScript, ACCESS aur MODIFY kar sakta hai (jaise ELEMENTS ADD/REMOVE karna, CONTENT CHANGE karna).

getElementById(), SIRF ID SE, EK ELEMENT DHOONDTA hai (FAST). querySelector(), KISI BHI CSS SELECTOR (class, tag, attribute) SE, PEHLA MATCHING ELEMENT DHOONDTA hai (MORE FLEXIBLE).

Jab EK EVENT (jaise click), EK ELEMENT PAR TRIGGER hota hai, WOH EVENT, USKE PARENT ELEMENTS TAK bhi, "BUBBLE UP" (UPAR JAATA) hai — jab tak STOP NA kiya jaaye (stopPropagation()).

addEventListener(), EK ELEMENT PAR, MULTIPLE EVENT HANDLERS ADD karne DETA hai (onclick, SIRF EK HANDLER SUPPORT karta hai, PURANA WALA OVERWRITE ho jaata hai). MORE FLEXIBLE, MODERN APPROACH.

EVENT LOOP aur CALLBACK QUEUE ke THROUGH — ASYNC OPERATIONS (jaise setTimeout, FETCH), BACKGROUND mein CHALTI hain, aur COMPLETE HONE PAR, UNKA CALLBACK, MAIN THREAD KHAALI HONE PAR, EXECUTE hota hai.

EK OBJECT JO, EK ASYNCHRONOUS OPERATION ke, EVENTUAL SUCCESS (resolve) YA FAILURE (reject) ko REPRESENT karta hai — .then()/.catch() SE, RESULT HANDLE kiya jaata hai.

Promises KE SAATH KAAM karne ka, EK MORE READABLE, "SYNCHRONOUS-LOOKING" SYNTAX — await, EK Promise ke RESOLVE hone tak, FUNCTION EXECUTION ko "PAUSE" karta hai (BINA MAIN THREAD BLOCK kiye).

EK FUNCTION, JO, EK DUSRE FUNCTION ko, ARGUMENT ke ROOP mein PASS kiya jaata hai, aur, US FUNCTION ke ANDAR, EK CERTAIN POINT PAR, "CALL BACK" (EXECUTE) kiya jaata hai.

Arrays/Objects se, VALUES ko, DIRECTLY, INDIVIDUAL VARIABLES mein, "UNPACK" karne ka SYNTAX — jaise const {name, age} = person; YA const [a, b] = array;.

Spread, EK ARRAY/OBJECT ko, "EXPAND" karta hai (jaise [...arr1, ...arr2]). Rest, MULTIPLE ARGUMENTS ko, EK ARRAY mein, "COLLECT" karta hai (jaise function(...args) {}).

CODE ko, ALAG-ALAG FILES mein, ORGANIZE karne DETE hain, aur SPECIFIC FUNCTIONS/VARIABLES ko, DUSRI FILES mein, import/export SE, SHARE karne DETE hain.

ES6 Classes, JavaScript's EXISTING PROTOTYPE-BASED INHERITANCE ke UPAR, EK "SYNTACTIC SUGAR" (SIMPLER SYNTAX) hain — UNDER THE HOOD, WOHI PROTOTYPE MECHANISM USE hota hai.

map(), HAR ELEMENT ko, TRANSFORM karके, EK NAYI ARRAY RETURN karta hai. filter(), CONDITION SATISFY karne wale ELEMENTS ki, EK NAYI ARRAY RETURN karta hai. reduce(), SAARE ELEMENTS ko, EK SINGLE VALUE mein, COMBINE karta hai.

forEach(), HAR ELEMENT PAR, EK FUNCTION RUN karta hai, LEKIN KUCH RETURN NAHI karta (undefined). map(), EK NAYI, TRANSFORMED ARRAY RETURN karta hai.

Object.keys(), SAARI KEYS ki ARRAY. Object.values(), SAARI VALUES ki ARRAY. Object.entries(), [key, value] PAIRS ki ARRAY.

try mein, RISKY CODE LIKHTE hain. AGAR ERROR (EXCEPTION) AAYE, MATCHING catch block, USE HANDLE karta hai — PROGRAM CRASH hone se BACHATA hai.

EK CUSTOM ERROR ko, MANUALLY, "THROW" (RAISE) karta hai — jaise throw new Error("Invalid input") — SPECIFIC ERROR CONDITIONS SIGNAL karne ke liye.

this ki VALUE, FUNCTION KAISE CALL HUA, US PAR DEPEND karti hai (NOT KAHA DEFINE HUA) — OBJECT METHOD ke ROOP mein CALL hone PAR, OBJECT ko REFER karta hai; GLOBAL CONTEXT mein, undefined (STRICT MODE) YA window.

Falsy VALUES (false, 0, "", null, undefined, NaN), CONDITIONS mein, false ki TARAH BEHAVE karte hain. BAAKI SAB, TRUTHY hain (jaise [], {}, "0" — YE bhi TRUTHY HAIN).

"Not a Number" — EK SPECIAL VALUE, JO, INVALID/UNDEFINED MATHEMATICAL OPERATIONS ka RESULT hota hai. Number.isNaN() SE CHECK kiya jaata hai (NaN === NaN, FALSE RETURN karta hai).

WOH AREA, JAHA, EK VARIABLE, ACCESSIBLE hai — GLOBAL SCOPE (POORE PROGRAM mein), FUNCTION SCOPE, aur BLOCK SCOPE (let/const KE SAATH).

EK FUNCTION ko, MULTIPLE ARGUMENTS lene KE BAJAYE, EK SEQUENCE of FUNCTIONS mein, TRANSFORM karna, JAHA HAR FUNCTION, EK ARGUMENT LETA hai — jaise add(a)(b)(c).

EK FUNCTION JO, SAME INPUT ke liye, HAMESHA SAME OUTPUT RETURN karta hai, aur KOI SIDE EFFECTS (jaise EXTERNAL VARIABLES MODIFY karna) NAHI karta.

function greet(name = "Guest") {} — AGAR CALLER, ARGUMENT PROVIDE NA KARE, DEFAULT VALUE AUTOMATICALLY USE hoती hai.

EK PARENT ELEMENT PAR, SINGLE EVENT LISTENER LAGAके, USKE CHILDREN ke EVENTS ko, BUBBLING KE THROUGH, HANDLE karna — MULTIPLE, INDIVIDUAL LISTENERS lagaने se, ZYAADA EFFICIENT hai.

preventDefault(), EVENT ke DEFAULT BROWSER BEHAVIOR ko ROKTA hai (jaise FORM SUBMIT). stopPropagation(), EVENT ko, PARENT ELEMENTS TAK, BUBBLE hone se ROKTA hai.

createElement(), EK NAYA, EMPTY HTML ELEMENT, MEMORY mein, CREATE karta hai. appendChild(), US ELEMENT ko, DOM TREE ke ANDAR, EK PARENT ke, LAST CHILD ke ROOP mein, INSERT karta hai.

MULTIPLE Promises ko, PARALLEL mein, RUN karta hai, aur, JAB SAARE RESOLVE ho jaayein, TABHI, EK SINGLE Promise, SAARE RESULTS ki ARRAY ke SAATH, RESOLVE hota hai — AGAR KOI EK REJECT ho, POORA Promise.all() REJECT ho jaata hai.

Microtasks (Promises), MACROTASKS (setTimeout) se PEHLE, PRIORITY SE, EXECUTE hote hain — EVENT LOOP, HAR MACROTASK ke BAAD, SAARE PENDING MICROTASKS, PEHLE CLEAR karta hai.

Browser ka BUILT-IN, MODERN WAY, HTTP REQUESTS BHEJNE ka — EK Promise RETURN karta hai, JO, RESPONSE MILNE PAR, RESOLVE hota hai.

EK NESTED PROPERTY ko, SAFELY, ACCESS karne DETA hai, BINA MANUALLY, HAR LEVEL PAR, null/undefined CHECK kiye — jaise user?.address?.city — AGAR KOI BHI LEVEL MISSING hai, undefined RETURN hota hai, ERROR NAHI.

value ?? defaultValue — SIRF TAB defaultValue USE karta hai, JAB value, null YA undefined ho (0, "", false ko, || OPERATOR ki TARAH, "FALSY" NAHI TREAT karta).

Map, KEY-VALUE PAIRS ka COLLECTION hai (OBJECT jaisa, LEKIN KISI BHI TYPE ki KEYS SUPPORT karta hai). Set, UNIQUE VALUES ka COLLECTION hai (DUPLICATES AUTOMATICALLY IGNORE hote hain).

find(), CONDITION SATISFY karne wala, PEHLA ELEMENT (SINGLE VALUE) RETURN karta hai. filter(), CONDITION SATISFY karne WALE SAARE ELEMENTS ki, EK NAYI ARRAY RETURN karta hai.

includes(), TRUE/FALSE RETURN karta hai (VALUE PRESENT hai YA NAHI). indexOf(), VALUE ka INDEX RETURN karta hai (AGAR NAHI MILA, -1).

EK OBJECT ko, IMMUTABLE bana deta hai — PROPERTIES ADD, REMOVE, YA MODIFY NAHI ki JA SAKTI (STRICT MODE mein, ERROR AATA hai; NORMAL MODE mein, SILENTLY IGNORE hota hai).

HAMESHA EXECUTE hota hai, CHAHE ERROR AAYE YA NA AAYE — CLEANUP CODE (jaise LOADING SPINNER HIDE karna) ke liye USE hota hai.

Error class ko EXTEND KARKE — jaise class ValidationError extends Error { constructor(msg) { super(msg); this.name = "ValidationError"; } }

HAR OBJECT, EK "PROTOTYPE" (DUSRA OBJECT) SE, PROPERTIES/METHODS INHERIT karta hai — CLASS-BASED languages (Java) ki TARAH NAHI, JavaScript, "OBJECTS SE OBJECTS" INHERIT karta hai.

call()/apply(), FUNCTION ko, IMMEDIATELY, SPECIFIC this VALUE KE SAATH, INVOKE karte hain (ARGUMENTS PASS karne ka STYLE ALAG hai). bind(), EK NAYA FUNCTION RETURN karta hai, JISME this, PERMANENTLY, BIND ho chuka hai (IMMEDIATELY CALL NAHI hota).

EK MECHANISM JO, CONTINUOUSLY, CHECK karta hai — "CALL STACK KHAALI hai? TO CALLBACK QUEUE se, NEXT TASK, LEKE AAO" — YAHI, JavaScript ke SINGLE-THREADED HONE ke BAAWAJOOD, ASYNC BEHAVIOR ENABLE karta hai.

Debouncing, EK FUNCTION ko, TAB tak DELAY karta hai, JAB TAK, EK CERTAIN TIME tak, NO NEW CALLS AAYE (jaise SEARCH INPUT). Throttling, EK FUNCTION ko, EK FIXED INTERVAL mein, SIRF EK BAAR, EXECUTE hone DETA hai (jaise SCROLL EVENTS).

localStorage, DATA ko, BROWSER TAB/WINDOW CLOSE hone ke BAAD BHI, PERSIST karta hai. sessionStorage, DATA ko, SIRF, US SPECIFIC TAB ki, SESSION tak, RAKHTA hai.

Cookies, HAR HTTP REQUEST KE SAATH, SERVER ko BHEJI JAATI hain (LIMITED SIZE, ~4KB). localStorage, SIRF, BROWSER mein, CLIENT-SIDE, STORE hota hai (BADI SIZE, ~5-10MB), SERVER ko AUTOMATICALLY NAHI JAATA.

Variables ko, RUNTIME PAR, EK TYPE SE DUSRE TYPE mein, AUTOMATICALLY, CONVERT kiya ja sakta hai (jaise "5" + 5 → "55") — EXPLICIT TYPE DECLARATIONS ki zaroorat NAHI, aur TYPE MISMATCH, COMPILE-TIME PAR PAKDA NAHI JAATA.

JavaScript ko, EK "STRICTER" SET of RULES ke SAATH, RUN karta hai — SILENT ERRORS (jaise UNDECLARED VARIABLES) ko, EXPLICIT ERRORS mein CONVERT karta hai, aur KUCH UNSAFE ACTIONS ko, DISALLOW karta hai.

JavaScript, AUTOMATICALLY, VALUES ko, true/false mein, CONVERT karta hai (jaise if(value)) — YE COERCION RULES, TRUTHY/FALSY VALUES ki LIST FOLLOW karte hain.

Function declaration (function foo() {}), HOISTED hoti hai (DEFINITION SE PEHLE bhi CALL ho sakti hai). Function expression (const foo = function() {}), HOISTED NAHI hoti (VARIABLE ki TARAH BEHAVE karti hai).

EK FUNCTION, KHUD KO, CALL karta hai, TAB TAK, JAB TAK, EK "BASE CASE" (STOPPING CONDITION) NA MIL JAAYE — BINA BASE CASE ke, "Maximum call stack size exceeded" ERROR AATA hai.

innerHTML, HTML ko, STRING ke ROOP mein, PARSE karके, INSERT karta hai (XSS RISK, AGAR USER INPUT DIRECTLY USE HO). textContent, SIRF PLAIN TEXT INSERT karta hai (SAFER, HTML TAGS PARSE NAHI hote).

FIRE hota hai, JAB HTML, POORI TARAH, PARSE ho chuki ho (DOM READY hai), CHAHE IMAGES/STYLESHEETS ABHI LOAD ho rahi HON — JavaScript CODE ko, DOM ELEMENTS MANIPULATE karne SE PEHLE, ISKA WAIT karna CHAHIYE.

MULTIPLE, NESTED CALLBACKS ki wajah SE, CODE, "PYRAMID" jaisa, UNREADABLE ban jaata hai — Promises YA async/await SE, ISE FLAT, READABLE CODE mein CONVERT kiya ja sakta hai.

Promise.race(), JAISE HI, PEHLA Promise, RESOLVE/REJECT HOTA hai, RESULT DETA hai. Promise.all(), TAB TAK WAIT karta hai, JAB TAK, SAARE Promises, RESOLVE NA HO JAAYEIN.

Variable ki DECLARATION SE PEHLE, USE karne ki KOSHISH karने PAR, EK ERROR AATA hai (var ki TARAH, undefined NAHI MILTA) — YE "ZONE", BLOCK ke SHURU SE, DECLARATION LINE tak, EXTEND hota hai.

EK UNIQUE, IMMUTABLE PRIMITIVE VALUE, TYPICALLY, OBJECT PROPERTIES ke liye, UNIQUE, NON-COLLIDING IDENTIFIERS BANANE ke liye USE hota hai.

SPECIAL FUNCTIONS, JO, yield KEYWORD SE, VALUES ko, EK-EK KARKE, PRODUCE karte hain (PAUSE/RESUME kiya ja sakta hai) — ITERATORS BANANE ka POWERFUL WAY.

EK "ARRAY-LIKE" YA ITERABLE OBJECT (jaise NodeList, STRING) ko, EK ACTUAL, REAL Array mein, CONVERT karta hai.

Default mein, sort(), ELEMENTS ko, STRINGS ki TARAH, ALPHABETICALLY, SORT karta hai — NUMBERS ke liye, [10, 1, 2].sort() → [1, 10, 2] (GALAT) — COMPARE FUNCTION PASS karна ZAROORI hai NUMERIC SORT ke liye.

message, ERROR ka DESCRIPTIVE TEXT hai. name, ERROR ka TYPE hai (jaise "TypeError", "RangeError") — DEBUGGING ke liye, DONO USEFUL hain.

TypeError, TAB AATA hai, JAB EK VALUE, EXPECTED TYPE ki NAHI hai (jaise null.property). ReferenceError, TAB AATA hai, JAB, EK UNDECLARED VARIABLE, USE karne ki KOSHISH ki JAAYE.

Shallow copy (jaise spread {...obj}), TOP-LEVEL PROPERTIES COPY karta hai, LEKIN NESTED OBJECTS, SHARED REFERENCE rehte hain. Deep copy (jaise structuredClone()), NESTED OBJECTS SAHIT, POORI TARAH, INDEPENDENT COPY BANATA hai.

WeakMap/WeakSet, KEYS ko, "WEAKLY" HOLD karte hain — AGAR KISI OBJECT KA, KOI aur REFERENCE NAHI bacha, GARBAGE COLLECTOR, USE, WeakMap/WeakSet SE bhi, AUTOMATICALLY, REMOVE kar deta hai (MEMORY LEAKS AVOID hote hain).

EK OPTIMIZATION TECHNIQUE — EK FUNCTION ke, EXPENSIVE CALCULATIONS ke RESULTS ko, CACHE (STORE) kar liya jaata hai, TAAKI, SAME INPUT ke liye, DOBARA CALCULATION NA KARNI PADE.

JSON.stringify(), EK JavaScript OBJECT ko, EK JSON STRING mein, CONVERT karta hai (STORAGE/TRANSMISSION ke liye). JSON.parse(), EK JSON STRING ko, WAAPAS, EK JavaScript OBJECT mein, CONVERT karta hai.

EK SECURITY MECHANISM, JO, EK WEBSITE ke SCRIPTS ko, EK DIFFERENT ORIGIN (DOMAIN/PORT/PROTOCOL) ke DATA ko, DIRECTLY, ACCESS karne SE ROKTA hai — CSRF/XSS jaise ATTACKS se BACHATA hai.

Variables mein, ACTUAL VALUE NAHI, BALKI, MEMORY mein, WOH VALUE KAHA hai, USKA "REFERENCE" (ADDRESS) STORE hota hai — isliye, EK VARIABLE ko, DUSRE mein ASSIGN karne PAR, DONO, SAME OBJECT ko POINT karte hain.

setTimeout(), EK FUNCTION ko, EK SPECIFIED DELAY ke BAAD, EK BAAR, EXECUTE karta hai. setInterval(), EK FUNCTION ko, REPEATEDLY, EK FIXED INTERVAL PAR, EXECUTE karta hai, JAB TAK clearInterval() NA CALL HO.

EK ELEMENT ki CSS CLASSES ko, EASILY, MANIPULATE karne DETA hai — jaise element.classList.toggle("active") — MANUALLY, className STRING ko, PARSE/CONCATENATE karne se, ZYAADA CLEAN.

EK FUNCTION, TEMPLATE LITERAL ke, PEHLE, LAGAके, USKE PARTS (STRINGS, EXPRESSIONS) ko, CUSTOM tareeke SE, PROCESS karne DETA hai — jaise EK i18n LIBRARY, ISKA USE, TRANSLATIONS ke liye kar sakti hai.