JavaScript Execution Order: Async Function Test

Quick JS Brain Teaser: What will be the output of this code? console.log('Start'); setTimeout(() => { console.log('Timeout'); }, 0); Promise.resolve() .then(() => console.log('Promise 1')) .then(() => console.log('Promise 2')); console.log('End'); Options: A) Start → End → Timeout → Promise 1 → Promise 2 B) Start → End → Promise 1 → Promise 2 → Timeout C) Start → Promise 1 → Promise 2 → End → Timeout D) Start → Timeout → Promise 1 → Promise 2 → End What's your answer? #JavaScript #JavaScriptInterviewQuestion #JavaScriptFundamentals

🌙 Evening Post — Function Reference vs Function Call (Very Important!) This morning’s code was: function show() { return "Hello"; } console.log(show); console.log(show()); 💡 Correct Output : [ Function : show ] Hello (Exact formatting may vary by browser, but the meaning is the same.) 🧠 Simple Explanation : 🔹 Line 1: console.log(show); Here, we are NOT calling the function. show refers to the function itself JavaScript prints the function definition This is called a function reference So the output shows something like: [ Function : show ] 👉 You’re telling JS: “Show me the function, not run it.” 🔹 Line 2: console.log(show()); Now the function IS called. show(); // returns "Hello" So this becomes: console.log("Hello"); ✔ Output: Hello 🎯 Key Takeaways : show → function reference (no execution) show() → function execution Functions in JS are values, just like numbers or strings You can pass functions around without calling them 📌 This difference is very important in: callbacks event handlers React props higher-order functions 💬 Your Turn Did you already know this difference? 😄 Comment “Clear now ✅” or “Didn’t notice this before 🤯” #JavaScript #LearnJS #FrontendDevelopment #CodingInterview #Functions #TechWithVeera #WebDevelopment

𝗪𝗲𝗹𝗰𝗼𝗺𝗲 𝘁𝗼 𝗗𝗮𝘆 𝟵 Have you ever updated one variable… and another one changed automatically? 𝙋𝙖𝙪𝙨𝙚 𝙛𝙤𝙧 𝙖 𝙨𝙚𝙘𝙤𝙣𝙙 — 𝙬𝙤𝙪𝙡𝙙 𝙮𝙤𝙪 𝙚𝙭𝙥𝙚𝙘𝙩 𝙩𝙝𝙞𝙨 𝙘𝙤𝙙𝙚 𝙩𝙤 𝙢𝙪𝙩𝙖𝙩𝙚 𝙗𝙤𝙩𝙝 𝙫𝙖𝙡𝙪𝙚𝙨? { 𝚕𝚎𝚝 𝚞𝚜𝚎𝚛𝟷 = { 𝚗𝚊𝚖𝚎: "𝙰𝚕𝚎𝚡" }; 𝚕𝚎𝚝 𝚞𝚜𝚎𝚛𝟸 = 𝚞𝚜𝚎𝚛𝟷; 𝚞𝚜𝚎𝚛𝟸．𝚗𝚊𝚖𝚎 = "𝙹𝚘𝚑𝚗"; 𝚌𝚘𝚗𝚜𝚘𝚕𝚎．𝚕𝚘𝚐(𝚞𝚜𝚎𝚛𝟷．𝚗𝚊𝚖𝚎); // "𝙹𝚘𝚑𝚗" } Why did user1 change? Because: • Both variables point to the same memory address • No copy was created • Only the reference was shared 𝘛𝘩𝘪𝘴 𝘪𝘴 𝘑𝘢𝘷𝘢𝘚𝘤𝘳𝘪𝘱𝘵’𝘴 𝘝𝘢𝘭𝘶𝘦 𝘷𝘴 𝘙𝘦𝘧𝘦𝘳𝘦𝘯𝘤𝘦 𝘣𝘦𝘩𝘢𝘷𝘪𝘰𝘳 — 𝘢𝘯𝘥 𝘪𝘵’𝘴 𝘥𝘦𝘦𝘱𝘭𝘺 𝘵𝘪𝘦𝘥 𝘵𝘰 𝘮𝘦𝘮𝘰𝘳𝘺. 𝙏𝙝𝙚 𝙈𝙚𝙣𝙩𝙖𝙡 𝙈𝙤𝙙𝙚𝙡 (𝙈𝙚𝙢𝙤𝙧𝙮 𝙁𝙞𝙧𝙨𝙩) JavaScript mainly uses two memory areas: -> Stack Memory • Stores primitive values • Fixed size • Fast access -> Heap Memory • Stores objects, arrays, functions • Dynamic size • Accessed via references 𝙒𝙝𝙚𝙣 𝙥𝙖𝙨𝙨𝙚𝙙 𝙗𝙮 𝙫𝙖𝙡𝙪𝙚: A copy of the actual value is passed. Primitives (number, string, boolean, null, undefined, symbol) are always passed by value. 𝙒𝙝𝙚𝙣 𝙥𝙖𝙨𝙨𝙚𝙙 𝙗𝙮 𝙧𝙚𝙛𝙚𝙧𝙚𝙣𝙘𝙚: A memory address (reference) is passed, not the object itself. Objects & arrays live in heap memory. #JavaScript #JSFundamentals #MemoryManagement #FrontendDevelopment #ReactJS #BugFixing #InterviewPrep #LearningInPublic

Quick JS Brain Teaser: What happens when you have return statements in try, catch, AND finally blocks? function testReturn() { try { return "try"; } catch (e) { return "catch"; } finally { return "finally"; } } console.log(testReturn()); What will be logged to the console? A) "try" B) "catch" C) "finally" D) undefined Does this match your expectations? Drop your answer and explain why! #JavaScript #JavaScriptInterviewQuestion #JavaScriptFundamentals

Quick JS Brain Teaser: What happens when you try to add a property to a primitive string value? let str = "hello"; str.customProp = "world"; console.log(str.customProp); Options: A) "world" B) undefined C) TypeError D) "helloworld" Does this match your expectations? Drop your answer in the comments and explain the autoboxing behavior! Let's discuss how JavaScript handles primitives vs objects. #JavaScript #JavaScriptInterviewQuestion #JavaScriptFundamentals

🧠 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗚𝗮𝗿𝗯𝗮𝗴𝗲 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 (𝗚𝗖) — 𝗤𝘂𝗶𝗰𝗸 𝗜𝗻𝘀𝗶𝗴𝗵𝘁 JavaScript automatically manages memory using 𝗚𝗮𝗿𝗯𝗮𝗴𝗲 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 ✅ Most JS engines (like V8) use the 𝗠𝗮𝗿𝗸-𝗮𝗻𝗱-𝗦𝘄𝗲𝗲𝗽 𝗮𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺: ✅ 𝗠𝗮𝗿𝗸: GC starts from root references (global scope, current stack, closures) and marks all 𝗥𝗲𝗮𝗰𝗵𝗮𝗯𝗹𝗲 objects. ✅ 𝗦𝘄𝗲𝗲𝗽: 𝗨𝗻𝗿𝗲𝗮𝗰𝗵𝗮𝗯𝗹𝗲 objects are removed from memory. ⚠️ 𝗖𝗼𝗺𝗺𝗼𝗻 𝗺𝗲𝗺𝗼𝗿𝘆 𝗹𝗲𝗮𝗸 𝗿𝗲𝗮𝘀𝗼𝗻𝘀: ✔ Unremoved event listeners ✔ Uncleared setInterval() / timers ✔ Closures holding large references ✔ Accidental global variables Understanding GC helps build 𝗳𝗮𝘀𝘁𝗲𝗿, 𝘀𝘁𝗮𝗯𝗹𝗲, 𝗮𝗻𝗱 𝗺𝗲𝗺𝗼𝗿𝘆-𝗲𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝘁 apps 🚀 #JavaScript #FrontendDevelopment #Performance #MemoryManagement #V8 #WebDevelopment #SoftwareEngineering

JavaScript TDZ — Where are var, let, and const stored? 🧠 When JS runs, it creates an Execution Context ⚙️ with two memory areas: 1️⃣ Global Object Environment 🌍 → var variables go here → attached to the global object (like window in browsers) → auto-initialized with undefined ✅ 2️⃣ Script / Lexical Environment 📦 → let and const go here → block-scoped memory space → memory reserved but not initialized 🚫 (TDZ ⏳) That’s why: var before declaration → undefined let/const before declaration → error ⛔ JS separates them to enforce block scope and reduce bugs 🛡️ #JavaScript #JSCore #ExecutionContext

🚀 Closures finally clicked for me! While revisiting JavaScript fundamentals, I spent time deeply understanding Closures — and it changed how I see functions. 💡 A closure is when an inner function remembers variables from its outer function — even after the outer function has executed. Example: function counter() { let count = 0; return function () { count++; return count; }; } const c = counter(); console.log(c()); // 1 console.log(c()); // 2 Even though counter() has finished executing, the inner function still remembers count. That memory is called a closure. 🔑 Why closures matter: • Helps keep data private • Used in counters, timers, modules • Very common in React & event handlers #JavaScript #Closures #FrontendDevelopment #WebDevelopment 

I made SyntaxShift, a better transform tool for Devs. All of these comes with a Custom logic on the FrontEnd Engine. > json-to-typescript > json-schema-to-typescript (with fallback inference) > svg-to-jsx > html-to-jsx > python-to-javascript > javascript-to-python Library-backed > yaml-to-json and json-to-yaml → js-yaml > xml-to-json → fast-xml-parser > markdown-to-html → marked Collaborate here -> https://lnkd.in/dxqrVEnn Live -> https://lnkd.in/d2J5ZG9i

𝐓𝐨𝐝𝐚𝐲 𝐈 𝐫𝐞𝐯𝐢𝐬𝐢𝐭𝐞𝐝 𝐚 𝐜𝐨𝐫𝐞 𝐉𝐚𝐯𝐚𝐒𝐜𝐫𝐢𝐩𝐭 𝐜𝐨𝐧𝐜𝐞𝐩𝐭 𝐭𝐡𝐚𝐭 𝐪𝐮𝐢𝐞𝐭𝐥𝐲 𝐚𝐟𝐟𝐞𝐜𝐭𝐬 𝐜𝐨𝐝𝐞 𝐪𝐮𝐚𝐥𝐢𝐭𝐲: 𝒗𝒂𝒓 𝒗𝒔 𝒍𝒆𝒕 𝒗𝒔 𝒄𝒐𝒏𝒔𝒕 👇 var x = 10; // function-scoped let y = 20; // block-scoped const z = 30; // block-scoped & cannot be reassigned Key differences that matter in real projects: > "var" is function-scoped and can lead to unexpected bugs due to hoisting. > "let" provides block scope, making control flow safer. > "const" enforces immutability of the reference, improving readability. Modern JavaScript favors const by default, uses let when reassignment is required and avoids var in most cases. Back to fundamentals — with a modern JS lens. Any insights or suggestions are welcome🙂 #DAY6 #JavaScript #WebDevelopment #FrontendDevelopment #LearningInPublic #dailyChallenge