JSON.parse() Memory Usage: Understanding the Browser's Hidden Costs

🔍 JavaScript Objects: Dot Notation vs Bracket Notation Why do we have two ways to access object properties — and when should we use each? If both dot notation and bracket notation do the same thing, why does JavaScript even support both? The short answer: flexibility + real-world use cases. Let’s break it down 👇 ⸻——————————————————- 1️⃣ Dot Notation – Clean, readable, and predictable const user = { name: "Jagdish", role: "Frontend Developer" }; user.name; // "Jagdish" ——————————————- ✅ When to use dot notation • Property names are known at development time • Keys are valid JavaScript identifiers • You want clean & readable code 🚫 When you can’t use dot notation user.first-name ❌ // Error user["first-name"] ✅ Why? Dot notation does not support: • Spaces • Hyphens (-) • Dynamic values —————————————————— 2️⃣ Bracket Notation – Dynamic and powerful const key = "role"; user[key]; // "Frontend Developer" ✅ When to use bracket notation • Property name is dynamic • Key comes from user input, API response, or loop • Property contains special characters ———————————— const data = { "total-users": 120, "2025": "Active" }; data["total-users"]; // 120 data["2025"]; // "Active" —————————————- Dot notation fails here ❌ Bracket notation works perfectly ✅ _______________________________ 3️⃣ Real-world examples 🔹 API responses response.data[fieldName]; You don’t know the key beforehand → bracket notation is required. 🔹 Forms & dynamic filters filters[selectedFilter]; 🔹 Looping through objects for (let key in user) { console.log(user[key]); } Dot notation simply cannot work here. ——————————————————————- 4️⃣ Mental model to remember forever 🧠 • Dot notation → Static & known • Bracket notation → Dynamic & unknown If JavaScript needs to evaluate the key at runtime, you must use bracket notation. JavaScript didn’t give us two notations by accident. It gave us simplicity and power. Knowing why and when to use each is what separates 👉 someone who knows syntax from 👉 someone who understands JavaScript deeply. If this helped you, react or share — someone in your network needs this today 🚀 #JavaScript #FrontendDevelopment #WebDevelopment #JavaScriptTips #CodingBestPractices #LearnJavaScript #SoftwareEngineering #CleanCode #DeveloperCommunity #ProgrammingConcepts #TechCareers #ReactJS #WebDev

🔁 Javascript Conditions and Loops 🔹 Why Conditions & Loops Matter - They help your program make decisions - They let your code repeat tasks - Without them, JavaScript is useless for logic Real use cases: Login validation, Form checks, Iterating data from APIs 🧠 Conditions (Decision Making) Conditions run code only when a condition is true. ✅ if statement let age = 20; if (age >= 18) { console.log("Eligible to vote"); } - Code runs only if condition is true 🔁 if–else if (age >= 18) { console.log("Adult"); } else { console.log("Minor"); } - Two paths • One always runs 🔂 else if let marks = 75; if (marks >= 90) { console.log("Grade A"); } else if (marks >= 70) { console.log("Grade B"); } else { console.log("Grade C"); } - Multiple conditions checked in order 🔀 switch statement Used when checking one value against many cases. let day = 2; switch (day) { case 1: console.log("Monday"); break; case 2: console.log("Tuesday"); break; default: console.log("Invalid day"); } ⚠️ Always use break to avoid fall-through. 🔁 Loops (Repetition) Loops run code multiple times. 🔹 for loop Best when number of iterations is known. for (let i = 1; i <= 5; i++) { console.log(i); } 🔹 while loop Runs while condition is true. let i = 1; while (i <= 3) { console.log(i); i++; } 🔹 do–while loop Runs at least once. let i = 5; do { console.log(i); i++; } while (i < 3); 📦 Loop Control Keywords - break → stops loop - continue → skips iteration for (let i = 1; i <= 5; i++) { if (i === 3) continue; console.log(i); } ⚠️ Common Beginner Mistakes - Infinite loops - Missing break in switch - Using == instead of === - Wrong loop condition 🧪 Mini Practice Task - Check if a number is even or odd - Print numbers from 1 to 10 - Print only even numbers - Use switch to print day name ✅ Mini Practice Task – Solution 🔁 🟦 1️⃣ Check if a number is even or odd let num = 7; if (num % 2 === 0) { console.log("Even number"); } else { console.log("Odd number"); } ✅ Uses modulus operator • Remainder 0 → even • Otherwise → odd 🔢 2️⃣ Print numbers from 1 to 10 for (let i = 1; i <= 10; i++) { console.log(i); } 🔁 3️⃣ Print only even numbers from 1 to 10 for (let i = 1; i <= 10; i++) { if (i % 2 === 0) { console.log(i); } } 📅 4️⃣ Use switch to print day name let day = 3; switch (day) { case 1: console.log("Monday"); break; case 2: console.log("Tuesday"); break; case 3: console.log("Wednesday"); break; case 4: console.log("Thursday"); break; case 5: console.log("Friday"); break; default: console.log("Invalid day"); }

🔑 Prototype & Inheritance in JavaScript 1. Prototype Chain Every JavaScript object has a hidden property called [[Prototype]]. When you try to access a property that doesn’t exist on the object itself, JavaScript looks up the prototype chain to find it. Example: const obj = {}; console.log(obj.toString()); // found in Object.prototype 2. Constructor Functions & new When you use the new keyword, JavaScript creates a new object and links it to the constructor’s prototype. Example: function Person(name) { this.name = name; } Person.prototype.greet = function() { return `Hello, ${this.name}`; }; const varun = new Person("Varun"); console.log(varun.greet()); // Hello, Varun 3. ES6 Classes (Syntactic Sugar) JavaScript classes are just syntactic sugar over prototype-based inheritance. They make the code cleaner and more readable, but under the hood, they still use prototypes. Example: class Animal { speak() { console.log("Sound..."); } } class Dog extends Animal { speak() { console.log("Woof!"); } } new Dog().speak(); // Woof! 4. Why It’s Important Frameworks like React and Node.js rely heavily on prototype chains. Performance optimization: Adding methods to the prototype is memory-efficient. Inheritance patterns: Promotes reusability and follows the DRY (Don't Repeat Yourself) principle. 📌 Quick Interview Tip Interviewers often ask: “Explain the prototype chain.” “What’s the difference between class inheritance and prototype inheritance?” “Why are methods added to the prototype instead of inside the constructor?” const obj = {}; console.log(obj.toString()); // found in Object.prototype 2. Constructor Functions & new Jab tum new keyword use karte ho, ek naya object banata hai jo constructor ke prototype se link hota hai. Example: function Person(name) {  this.name = name; } Person.prototype.greet = function() {  return `Hello, ${this.name}`; }; const champ= new Person("Champ"); console.log(champ.greet()); // Hello, Champ 3. ES6 Classes (syntactic sugar) Classes JS me bas prototype-based inheritance ka cleaner syntax hain. Example: class Animal {  speak() { console.log("Sound..."); } } class Dog extends Animal {  speak() { console.log("Woof!"); } } new Dog().speak(); // Woof! 4. Why It’s Important Frameworks like React and Node.js rely heavily on prototype chains. Performance optimization: Adding methods to the prototype is memory-efficient. Inheritance patterns: Promotes reusability and follows the DRY (Don't Repeat Yourself) principle. #React #ReactJS #Frontend #WebDevelopment #JavaScript #Interviews #SoftwareEngineering #infy

JavaScript Arrays, Objects & Array Methods Understanding how arrays and objects work helps you organize, transform, and analyze data in JavaScript. Here's a quick and clear breakdown: *1️⃣ Arrays in JavaScript* An array stores a list of values. ```js let fruits = ["apple", "banana", "mango"]; console.log(fruits[1]); // banana ``` ▶️ This creates an array of fruits and prints the second fruit (`banana`), since arrays start at index 0. *2️⃣ Objects in JavaScript* Objects hold key–value pairs. ```js let user = { name: "Riya", age: 25, isAdmin: false }; console.log(user.name); // Riya console.log(user["age"]); // 25 ``` ▶️ This object represents a user. You can access values using dot (`.`) or bracket (`[]`) notation. *3️⃣ Array Methods – map, filter, reduce* 🔹 *map()* – Creates a new array by applying a function to each item ```js let nums = [1, 2, 3]; let doubled = nums.map(n => n * 2); console.log(doubled); // [2, 4, 6] ``` ▶️ This multiplies each number by 2 and returns a new array. 🔹 *filter()* – Returns a new array with items that match a condition ```js let ages = [18, 22, 15, 30]; let adults = ages.filter(age => age >= 18); console.log(adults); // [18, 22, 30] ``` ▶️ This filters out all ages below 18. 🔹 *reduce()* – Reduces the array to a single value ```js let prices = [100, 200, 300]; let total = prices.reduce((acc, price) => acc + price, 0); console.log(total); // 600 ``` ▶️ This adds all prices together to get the total sum. *💡 Extra Notes:* • `map()` → transforms items • `filter()` → keeps matching items • `reduce()` → combines all items into one result 🎯 *Practice Challenge:* • Create an array of numbers • Use `map()` to square each number • Use `filter()` to keep only even squares • Use `reduce()` to add them all up

𝗪𝗲𝗹𝗹-𝗞𝗻𝗼𝘄𝗻 𝗦𝘆𝗺𝗯𝗼𝗹𝘀 𝗮𝗻𝗱 𝗧𝗵𝗲𝗶𝗿 𝗔𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀 JavaScript has evolved over time. One major update was the introduction of Symbols in ECMAScript 2015. Well-Known Symbols provide a unique way to define behavior and properties in JavaScript. To understand Well-Known Symbols, you need to know what symbols are. Before ECMAScript 2015, JavaScript did not have a way to create private object properties. Developers used tricks like prefixes or closures to manage uniqueness. The introduction of Symbols solved this problem. A Symbol is a unique identifier created using the Symbol() function. Here are some key Well-Known Symbols: - Symbol.hasInstance: customizes the instanceof operator behavior - Symbol.isConcatSpreadable: determines if an object should be flattened when using Array.prototype.concat - Symbol.iterator: defines the default iterator for an object - Symbol.match: specifies a function used for pattern matching with regex - Symbol.replace: customizes the behavior of String.prototype.replace - Symbol.search: customizes the behavior of String.prototype.search - Symbol.split: determines how String.prototype.split performs on an object You can use Symbol.hasInstance to define custom behaviors for the instanceof operator. For example: class MyArray { static [Symbol.hasInstance](instance) { return Array.isArray(instance) && instance.length > 0; } } You can also use Symbol.iterator to define object iteration. For example: class Fibonacci { constructor() { this.current = 0; this.next = 1; } [Symbol.iterator]() { return this; } next() { const current = this.current; [this.current, this.next] = [this.next, this.current + this.next]; return { value: current, done: false }; } } Well-Known Symbols can streamline code and improve architecture. However, they can also impact performance. Using Symbols can incur a cost, especially when abstracting data structures or heavy computational tasks. Many modern frameworks and libraries use Well-Known Symbols for internal management. For example, React and Vue use Symbols to handle component states uniquely. To debug issues with Well-Known Symbols, you can use console logging and debugging tools like Chrome DevTools. Source: https://lnkd.in/d_8if4qz

💛 Memoization in JavaScript — Make Your Functions Faster ⚡ Ever written a function that: 👉 Does heavy computation 👉 Gets called repeatedly 👉 Repeats the same work again? That’s wasted performance 😬 Memoization fixes this elegantly. ♦️ What is Memoization? Definition: Memoization is an optimization technique where we: 👉 Store results of expensive function calls 👉 Return the cached result when the same inputs occur again In simple terms: “If I’ve already solved this once, why solve it again?” ♦️ Simple Example Without Memoization function square(n) { console.log("Calculating..."); return n * n; } square(5); // Calculating... square(5); // Calculating... again 😑 Same input. Same output. Still recalculating ❌ With Memoization function memoizedSquare() { let cache = {}; return function (n) { if (cache[n]) { console.log("From cache"); return cache[n]; } console.log("Calculating..."); cache[n] = n * n; return cache[n]; }; } const square = memoizedSquare(); square(5); // Calculating... square(5); // From cache ✅ 🔥 Faster 🔥 Smarter 🔥 Efficient ♦️ Why It Works (Closures) The cache variable persists because of closures. So you can think of it as: Memoization = Closure + Cache Closures power many advanced JavaScript patterns. ♦️ Real-World Use Cases ✔️ Expensive computations ✔️ Recursive algorithms ✔️ Derived data calculations ✔️ Performance optimization in React ✔️ Reducing repeated logic calls ♦️ Classic Interview Example — Fibonacci Without Memoization function fib(n) { if (n <= 1) return n; return fib(n - 1) + fib(n - 2); } Time complexity: O(2ⁿ) 😱 With Memoization function memoFib() { let cache = {}; return function fib(n) { if (n in cache) return cache[n]; if (n <= 1) return n; cache[n] = fib(n - 1) + fib(n - 2); return cache[n]; }; } const fib = memoFib(); Now time complexity becomes O(n) ⚡ Massive improvement. ♦️ Generic Memoize Utility function memoize(fn) { const cache = {}; return function (...args) { const key = JSON.stringify(args); if (key in cache) return cache[key]; const result = fn.apply(this, args); cache[key] = result; return result; }; } const fastSquare = memoize(n => n * n); Reusable. Clean. Powerful. ♦️ Important Notes 1️⃣ Best for pure functions (same input → same output) 2️⃣ Be careful if function depends on: External state Randomness API calls 3️⃣ Trade-off: 👉 Faster execution 👉 More memory usage It’s a classic time vs space trade-off ⚖️ 🎯 Interview One-Liner Memoization is an optimization technique that stores results of expensive function calls and returns the cached result when the same inputs occur again, typically implemented using closures. If this helped, drop a 💛 or share 🔁 Next deep dive 👉 Prototypes and Prototypal Inheritance 😄 #JavaScript #JSInternals #LearnJavaScript #WebDevelopment  #ProgrammingConcepts #WebDevJourney #BuildInPublic

𝗖𝗹𝗼𝘀𝘂𝗿𝗲, the invisible thread that binds a function to its birthplace. In technical terms,  𝗖𝗹𝗼𝘀𝘂𝗿𝗲 𝗶𝘀 𝗮 𝗳𝘂𝗻𝗰𝘁𝗶𝗼𝗻 𝗯𝘂𝗻𝗱𝗹𝗲𝗱 𝘁𝗼𝗴𝗲𝘁𝗵𝗲𝗿 𝘄𝗶𝘁𝗵 𝗶𝘁𝘀 𝗹𝗲𝘅𝗶𝗰𝗮𝗹 𝗲𝗻𝘃𝗶𝗿𝗼𝗻𝗺𝗲𝗻𝘁. In JavaScript, a closure is created every time a function is defined within another function, allowing the inner function to "𝗿𝗲𝗺𝗲𝗺𝗯𝗲𝗿" the variables and scope of its parent, even after the parent has finished executing. When you return a function from another function, you aren't just returning the code; you are returning a persistent link to the surrounding variables. This means Closure doesn't just store a snapshot of a value; 𝗶𝘁 𝗵𝗼𝗹𝗱𝘀 𝗮 𝗿𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲 𝘁𝗼 𝘁𝗵𝗲 𝘃𝗮𝗿𝗶𝗮𝗯𝗹𝗲 𝗶𝘁𝘀𝗲𝗹𝗳. 𝗘𝘅𝗮𝗺𝗽𝗹𝗲: 𝘧𝘶𝘯𝘤𝘵𝘪𝘰𝘯 𝘰𝘶𝘵𝘦𝘳() {   𝘭𝘦𝘵 𝘤𝘰𝘶𝘯𝘵 = 10;   𝘧𝘶𝘯𝘤𝘵𝘪𝘰𝘯 𝘪𝘯𝘯𝘦𝘳() {     𝘤𝘰𝘯𝘴𝘰𝘭𝘦.𝘭𝘰𝘨(𝘤𝘰𝘶𝘯𝘵); // 𝘐 𝘳𝘦𝘮𝘦𝘮𝘣𝘦𝘳 '𝘤𝘰𝘶𝘯𝘵' 𝘵𝘩𝘳𝘰𝘶𝘨𝘩 𝘵𝘩𝘦 𝘭𝘦𝘹𝘪𝘤𝘢𝘭 𝘴𝘤𝘰𝘱𝘦!   }   𝘳𝘦𝘵𝘶𝘳𝘯 𝘪𝘯𝘯𝘦𝘳; } 𝘤𝘰𝘯𝘴𝘵 𝘮𝘺𝘊𝘭𝘰𝘴𝘶𝘳𝘦 = 𝘰𝘶𝘵𝘦𝘳();  // 𝘈𝘵 𝘵𝘩𝘪𝘴 𝘱𝘰𝘪𝘯𝘵, 𝘰𝘶𝘵𝘦𝘳() 𝘩𝘢𝘴 𝘧𝘪𝘯𝘪𝘴𝘩𝘦𝘥, 𝘣𝘶𝘵 𝘐 𝘴𝘵𝘪𝘭𝘭 𝘦𝘹𝘪𝘴𝘵. 𝘮𝘺𝘊𝘭𝘰𝘴𝘶𝘳𝘦(); // 𝘖𝘶𝘵𝘱𝘶𝘵: 10 Closure is not just an interview question; It is the backbone of many powerful JavaScript patterns. Use for: • 𝗠𝗼𝗱𝘂𝗹𝗲 𝗗𝗲𝘀𝗶𝗴𝗻 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀: To create private variables that can’t be accessed from the outside. • 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻 𝗖𝘂𝗿𝗿𝘆𝗶𝗻𝗴: Transforming a function with multiple arguments into a sequence of nesting functions. • 𝗗𝗮𝘁𝗮 𝗣𝗲𝗿𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝗲: Creating functions that can only be called once (the "once" pattern) or maintaining state in asynchronous operations like setTimeout. • 𝗠𝗲𝗺𝗼𝗶𝘇𝗮𝘁𝗶𝗼𝗻: Storing the results of expensive function calls to speed up your programme. Deep Nesting: Closure can even reach across multiple levels. If you nest functions deep within each other, the innermost function forms a closure with all its parent scopes. 𝘧𝘶𝘯𝘤𝘵𝘪𝘰𝘯 𝘨𝘳𝘢𝘯𝘥𝘗𝘢𝘳𝘦𝘯𝘵() {   𝘷𝘢𝘳 𝘢 = "𝘏𝘦𝘭𝘭𝘰";   𝘳𝘦𝘵𝘶𝘳𝘯 𝘧𝘶𝘯𝘤𝘵𝘪𝘰𝘯 𝘱𝘢𝘳𝘦𝘯𝘵(𝘣) {     𝘳𝘦𝘵𝘶𝘳𝘯 𝘧𝘶𝘯𝘤𝘵𝘪𝘰𝘯 𝘤𝘩𝘪𝘭𝘥() {       𝘤𝘰𝘯𝘴𝘰𝘭𝘦.𝘭𝘰𝘨(𝘢, 𝘣); // 𝘐 𝘩𝘢𝘷𝘦 𝘢𝘤𝘤𝘦𝘴𝘴 𝘵𝘰 𝘣𝘰𝘵𝘩!     };   }; } 𝘨𝘳𝘢𝘯𝘥𝘗𝘢𝘳𝘦𝘯𝘵()("𝘞𝘰𝘳𝘭𝘥")(); // 𝘖𝘶𝘵𝘱𝘶𝘵: 𝘏𝘦𝘭𝘭𝘰 𝘞𝘰𝘳𝘭𝘥 Image Concept: The "Lexical Suitcase" If you were to visualise Closure, imagine a bubble (the inner function) flying away from its home (the outer function). Inside that bubble, the function is carrying a suitcase labelled "Lexical Environment". Even though the "home" disappears from the call stack, the function still has its suitcase filled with all the variables it needs to survive in the outside world

🚀 20 JavaScript Snippets Tiny code, big impact. Bookmark this for your next project! 🔖 1. Flatten an array ```javascript const flatten = arr => arr.flat(Infinity); ``` 2. Check if object is empty ```javascript const isEmpty = obj => Object.keys(obj).length === 0; ``` 3. Generate random hex color ```javascript const randomHex = () => `#${Math.floor(Math.random()*0xffffff).toString(16).padEnd(6,"0")}`; ``` 4. Remove duplicates from array ```javascript const unique = arr => [...new Set(arr)]; ``` 5. Capitalize first letter ```javascript const capitalize = str => str.charAt(0).toUpperCase() + str.slice(1); ``` 6. Copy to clipboard ```javascript const copyToClipboard = text => navigator.clipboard.writeText(text); ``` 7. Get current URL params ```javascript const params = new URLSearchParams(window.location.search); ``` 8. Detect dark mode preference ```javascript const isDarkMode = window.matchMedia('(prefers-color-scheme: dark)').matches; ``` 9. Debounce function ```javascript const debounce = (func, wait) => { let timeout; return (...args) => { clearTimeout(timeout); timeout = setTimeout(() => func.apply(this, args), wait); }; }; ``` 10. Wait for a set time ```javascript const wait = ms => new Promise(resolve => setTimeout(resolve, ms)); ``` 11. Toggle boolean in state (React-friendly) ```javascript const toggle = prev => !prev; ``` 12. Sort by key ```javascript const sortBy = (arr, key) => arr.sort((a, b) => a[key] > b[key] ? 1 : -1); ``` 13. Convert RGB to hex ```javascript const rgbToHex = (r,g,b) => "#" + ((1<<24) + (r<<16) + (g<<8) + b).toString(16).slice(1); ``` 14. Validate email ```javascript const isValidEmail = email => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email); ``` 15. Group array by property ```javascript const groupBy = (arr, key) => arr.reduce((acc, obj) => { acc[obj[key]] = (acc[obj[key]] || []).concat(obj); return acc; }, {}); ``` 16. Get average of array ```javascript const average = arr => arr.reduce((a, b) => a + b, 0) / arr.length; ``` 17. Random item from array ```javascript const randomItem = arr => arr[Math.floor(Math.random() * arr.length)]; ``` 18. Scroll to top smoothly ```javascript const scrollToTop = () => window.scrollTo({ top: 0, behavior: 'smooth' }); ``` 19. Format number with commas ```javascript const formatNumber = num => num.toLocaleString(); ``` 20. Check if array includes all values ```javascript const includesAll = (arr, values) => values.every(v => arr.includes(v)); ``` --- ✨ Which one will you use first? 💬 Comment your favorite snippet or share one of your own! #JavaScript #WebDevelopment #CodingTips #Programming #Frontend #DeveloperTools #CodeSnippets #JS #TechTips #LearnJavaScript #SoftwareEngineering #DevCommunity 📌 Follow Sasikumar S for daily practical developer tips & hands-on learning. ❤️ Join TechVerse Collective – a daily learning community for coders growing together. 🔁 Repost to save for later & share with your network.

"JavaScript is single-threaded" We don't call C++ or Go "single-threaded" — yet they execute in one thread by default too. Creating parallel threads requires explicit code in any language. So why do we label JavaScript this way? -- HISTORICAL CONTEXT -- In the 2000s, browsers themselves were single-process. One frozen tab = entire browser frozen. Chrome (2008) pioneered multi-process architecture. Firefox followed with Electrolysis only in 2016. The "JS is single-threaded" myth was born in that era — and stuck. -- MODERN JAVASCRIPT -- Today, JavaScript has full parallelism capabilities. Let's look at the tools. -- WEB WORKERS -- Separate threads with their own event loop. True parallel execution. const worker = new Worker('heavy-task.js'); worker.postMessage(data); worker.onmessage = (e) => console.log(e.data); Limitation: no DOM access, communication via postMessage (structured clone). -- SHARED MEMORY -- SharedArrayBuffer + Atomics enable lock-free concurrent programming: // Main thread const sab = new SharedArrayBuffer(1024); const view = new Int32Array(sab); worker.postMessage(sab); // Worker Atomics.add(view, 0, 1); // atomic increment Atomics.wait(view, 0, expectedValue); // block until changed Same memory model as C++/Rust. Race conditions included. -- WORKLETS -- Lightweight threads for specific tasks: • AudioWorklet — real-time audio processing • PaintWorklet — custom CSS painting • AnimationWorklet — off-main-thread animations -- NODE.JS -- Node.js is multithreaded out of the box. libuv thread pool: 4 threads by default (UV_THREADPOOL_SIZE, max 1024). Handles: file system, DNS, crypto. For custom parallelism: worker_threads. For multiprocessing: child_process, cluster. -- THE REAL CONSTRAINT -- DOM access is single-threaded. Not JavaScript itself. The event loop is scheduling, not a threading limitation. V8 runs on multiple threads — it just gives you one main thread by default. Same story as C++ or Go: one thread by default, explicit code for parallelism. #JavaScript #WebWorkers #NodeJS #Concurrency #Performance

🚀 JavaScript Output Challenge — Can You Guess Them All? Let’s test your core JavaScript knowledge — Event Loop, Closures, Hoisting, and Shallow Copy. 👇 Try to guess the output before running the code. 🧩 Question 1 — Event Loop + Promises + setTimeout console.log(1) const promise = new Promise((resolve) => { console.log(2) resolve() console.log(3) }) console.log(4) promise.then(() => { console.log(5) }).then(() => { console.log(6) }) console.log(7) setTimeout(() => { console.log(8) }, 10) setTimeout(() => { console.log(9) }, 0) 👉 What is the exact order of logs? 🧩 Question 2 — Spread Operator (Shallow Copy) let person = { name: "Ram", age: 29, marks: { math: 21, physics: 25 } } let person2 = { ...person } person2.name = "Shyam" person2.age = 21 person2.marks.math = 50 console.log(person, person2) 👉 Will both objects change or only person2? 🧩 Question 3 — Closure Inside Loop function test(arr, x) { var a, c = 0; for (var i = 0; i < arr.length; i++) { if (i === x) { a = function () { console.log(i, c++) } } } return a; } var t = test([1,2,3,4,5,6,7,8,9], 5) t(); t(); t(); 👉 What gets printed each time and why? 🧩 Question 4 — Hoisting + Scope Confusion var a = 10; var b = 100; function test() { a = 30; var a; console.log(a); b = 200; console.log(b); b = 300; } test(); console.log(a); console.log(b); 👉 What are the final values of a and b? 💬 Drop your answers in the comments (no cheating 😄). I’ll share detailed explanations in the next post! #JavaScript #FrontendDevelopment #WebDevelopment #InterviewPrep #JSChallenge #100DaysOfCode