Understanding JavaScript Promises: Pending, Resolve, Reject

𝗧𝗵𝗲 𝗕𝗲𝗻𝗲𝗳𝗶𝘁𝘀 𝗼𝗳 𝗔𝗿𝗿𝗼𝘄 𝗙𝘂𝗻𝗰𝗍𝗶𝗼𝗻𝘀 You've seen the => symbol in JavaScript code. It's called an Arrow Function. - Makes your code look sleeker - Reduces "boilerplate" code Let's look at an example: squaring a number. You can write it like this: const square = function(n) { return n * n; }; Or like this: const square = (n) => { return n * n; }; We removed the word "function" and added => after the parameters. If your function only needs one parameter, you can drop the parentheses. const square = n => { return n * n; }; If your function needs more than one parameter, you add the parentheses back. const multiply = (a, b) => { return a * b; }; console.log(multiply(5, 4)); // Output: 20 The coolest part of Arrow Functions is Implicit Return. If your function only has one line of code, you can throw away the curly braces and the return keyword. const add = (a, b) => a + b; Arrow functions are perfect for methods like map(). Check an array of numbers and return if they are "Even" orOdd.const numbers = [1, 2, 3, 4]; const checkNumbers = numbers.map(num => num % 2 === 0 ? "Even : Odd"); console.log(checkNumbers); // ["Odd", "Even", "Odd", "Even"] Arrow functions make your code shorter, easier to read, and more expressive. They help you write functions quickly and make your code easier for other developers to understand. Source: https://lnkd.in/gh_-Skrh

Blog 07 of my JS Unlocked series is live! 🚀 Array Methods You Must Know in JavaScript 👇 Arrays store data. But these methods are what make that data actually useful — transform it, filter it, calculate from it. In this one I cover: ✅ push() & pop() — add/remove from the end ✅ shift() & unshift() — add/remove from the front ✅ forEach() — loop through every item cleanly ✅ map() — transform every item into a new array ✅ filter() — keep only what passes the condition ✅ reduce() — combine everything into one value ✅ Visual flowcharts for map, filter & reduce ✅ for loop vs map/filter — side by side comparison Would love your feedback if you read it 🙏 🔗 https://lnkd.in/d26hbMGM Thanks to Hitesh Choudhary Sir, Piyush Garg #JavaScript #WebDevelopment #Hashnode #WebDevCohort2026 #LearningInPublic #Frontend #JS

Is Node.js Single-Threaded? Yes… and No. Your JavaScript runs on one thread — always. The V8 engine executes your code sequentially, one operation at a time. No parallelism. No race conditions on your JS logic. That part is true. But here's what most tutorials skip: Under the hood, Node.js uses libuv — a C library that manages a thread pool (4 threads by default). When you do something expensive like reading a file, querying a DB, or hashing a password, Node offloads that work to libuv's thread pool. Your JS thread stays free, picks up the next task, and libuv calls back when the heavy work is done. That's the Event Loop in action. So in reality: → JS execution = single-threaded ✅ → I/O & async operations = multi-threaded behind the scenes ✅ And since Node.js 10.5+, you can even spin up true Worker Threads for CPU-intensive tasks — breaking out of the single-thread model entirely when you need to. The "single-threaded" label is a simplification. It's accurate for your code, but the engine powering it is anything but. This is why Node.js can handle thousands of concurrent connections without breaking a sweat — and also why blocking the event loop with heavy CPU work is so dangerous. If this reframed how you think about Node.js, hit 👍 and drop a comment — do you think the "single-threaded" label does more to help or confuse developers?

The bug made no sense. The variable existed. He could see it. JavaScript couldn't. A developer stared at the screen for twenty minutes before another developer pulled up a chair, looked at the code, and said one word. "Scope." Everything clicked after that. In JavaScript, scope simply answers one question - where can this variable be seen and used? There are three types. Here, each one is simply explained: Global Scope - Visible everywhere. Declare a variable outside any function or block and it belongs to the entire program. Any part of your code - inside functions, inside blocks, can access it freely. let name ="Aniekan"; Function Scope - Visible only inside the function. Variables declared inside a function live and die there. They're created when the function runs and gone when it finishes. var, let, and const all behave the same way here. function greet() { let message ="Hello"; -> only lives inside the greet() function } Block Scope - Visible only inside the block. Variables declared inside this curly braces {} This can be an if statement, a loop inside a function or inside another block of code define by curly braces. let and const respect this. var does not. That's one of the reasons var quietly causes bugs that are hard to trace. This is because var is scoped to a function not just a block of code. function greet() { let age; if(true) { let age =25; -> only exists inside this block } } Scope isn't just a concept for interviews. It's the invisible boundary that decides whether your variable exists or vanishes. Understanding it will save you hours of confusion, and unnecessary debugging.

Day 87 of me reading random and basic but important dev topicsss....... Today I read about the Blobs in JavaScript As a developer, we deal with file uploads or downloads in the browser. But what happens under the hood and how JS handles binary data? While ArrayBuffer is part of the core ECMA standard, the browser’s File API gives us a higher-level abstraction: The Blob (Binary Large Object). What exactly is a Blob? Unlike a raw ArrayBuffer, a Blob represents binary data with type. It consists of an optional string type (usually a MIME-type) and blobParts (a sequence of strings, BufferSources, or even other Blobs). Construction We construct them by passing an array of parts and an options object: let blob = new Blob( [new Uint8Array([72, 101, 108, 108, 111]), ' ', 'world'], { type: 'text/plain', endings: 'native' } ); Immutability Just like JavaScript strings, Blobs are entirely immutable. We cannot directly edit the data inside a Blob. However, we can create new Blobs from existing ones using the .slice() method: blob.slice([byteStart], [byteEnd], [contentType]); This allows us to chop up files for chunked uploads or assemble new files in memory without altering the original binary data. Keep Learning!!!!! #JavaScript #WebDevelopment #FrontendDev #SoftwareEngineering #WebAPIs

JavaScript's Date object is broken — and we've all just been pretending it isn't. 😅 For over 25 years, JS developers have wrestled with mutable dates, silent timezone bugs, and month indexing that starts at 0 (January is 0... really?). Most of us gave up and reached for Moment.js or date-fns just to stay sane. That era is ending. ⚡ Enter the Temporal API — a TC39 Stage 3 proposal designed as a full, native replacement for Date. Here's what makes it a game-changer: ✅ Immutable date/time objects — no more accidental mutations ✅ First-class timezone & calendar support — built right in, no workarounds ✅ Crystal-clear types — PlainDate, PlainTime, ZonedDateTime — you always know exactly what you're working with ✅ Precise arithmetic — adding months or comparing durations just works, correctly ✅ No more external libraries needed for everyday date logic Instead of new Date() giving you a mutable, timezone-confused mess, you get: Temporal.Now.zonedDateTimeISO() — explicit, reliable, readable. The intriguing part? This could render entire categories of npm packages obsolete overnight. 👇 If this is news to you, you'll want to start experimenting now before it lands in all browsers. ♻️ Like this post if you found it useful, and drop a comment — are you excited about Temporal, or will you stick with your current date library?

Just dropped my 2nd blog in my JS Unlocked series! 🚀 This time — Variables & Data Types in JavaScript 👇 I'm now going deeper into JavaScript fundamentals as part of Web Dev Cohort 2026. In this one I cover: ✅ What variables are (with a real-life box analogy) ✅ var vs let vs const — when to use what ✅ All 5 primitive data types with real examples ✅ Scope explained simply — no jargon ✅ A hands-on challenge to test yourself If you're just starting out with JavaScript, this one's for you 🙏 🔗 https://lnkd.in/dEkjzfMq Thanks to #HiteshChoudhary Sir, #PiyushGarg and #AkashKadlag for building this cohort 💛 #JavaScript #WebDevelopment #Hashnode #WebDevCohort2026 #LearningInPublic #Frontend #JS

🚀Day 4/100 – Understanding JSON & Fetch in JavaScript Today I focused on two fundamental concepts in modern web development: 1️⃣ JSON (JavaScript Object Notation) JSON is the standard format for sending data between a client and a server. Key things I reinforced today: Keys must be in double quotes Strings must use double quotes Numbers & booleans don’t need quotes JSON stores only data (no functions, no undefined) I practiced converting between objects and JSON: JSON.stringify() → Object ➝ JSON string JSON.parse() → JSON string ➝ Object Understanding this flow is critical because servers send data as JSON strings, and we convert them back into JavaScript objects to use in our applications. Data Flow: Server ➝ JSON String ➝ Parse ➝ JavaScript Object ➝ UI 2️⃣ Fetch API I learned how to retrieve data from an API using fetch(). Basic flow: Send request using fetch() Convert response using response.json() Use the data Also practiced the cleaner modern approach using async/await, which makes asynchronous code much more readable and scalable compared to chaining multiple .then() calls. What I Realized Today- If you don’t understand JSON and fetch deeply, you can’t properly build real-world applications. Every frontend app talks to a backend, and this is the bridge. On to Day 5. #100DaysOfCode #JavaScript #WebDev #API #JSON #CodingChallenge #Frontend #SoftwareEngineering #MERNStack #LearningEveryday

🚀 JavaScript Memory Management & Garbage Collection (Under the Hood) Understanding how JavaScript handles memory is key to writing efficient and bug-free applications. Here’s the mental model that made it clear 👇 🧠 Garbage Collection (Automatic Memory Management) JavaScript automatically frees memory using a garbage collector. 💡 Rule: An object stays in memory as long as it has at least one reference. let user = { name: "Rahul" } let anotherUser = user user = null 👉 The object is NOT removed — because anotherUser still holds a reference. 🔁 Closures & Memory Retention Closures can keep variables alive even after function execution. function outer() { let count = 0 return function () { count++ console.log(count) } } const counter1 = outer() const counter2 = outer() 💡 Each call creates a new closure with its own memory: • counter1 → independent state • counter2 → independent state ⚡ Why It Matters • Prevents memory leaks • Helps understand hidden data retention • Improves performance awareness • Essential for large-scale apps 🎯 Takeaway: Memory isn’t about allocation — it’s about references and lifecycle. Building a deeper understanding of how JavaScript behaves beyond just writing code. 💪 #JavaScript #MemoryManagement #Closures #WebDevelopment #FrontendDeveloper #MERNStack #SoftwareEngineering

I used to wonder: if JavaScript can only do one thing at a time, why doesn't the whole website stop whenever I'm waiting for a slow API? Today, I’m documenting the "Magic" behind the scenes: The Event Loop. Think of it as a traffic controller that keeps everything moving. Here is what I learned about how it works: The Call Stack: This is my "To-Do List." It finishes one task before moving to the next. 1) The Waiting Room (Web APIs): When I set a timer or fetch data, JavaScript sends it here so the main list stays free for other work. 2) The Callback Queue: This is where finished tasks wait in line for their turn. 3) The Event Loop: The star of the show. It waits until the Stack is empty, then pushes the next task from the line into the code. The "Senior Secret" I learned today: Never run massive calculations directly on the main thread. It blocks the loop and makes the website feel laggy or "dead." I'm not a master yet, but understanding this makes me much better at fixing bugs. Tomorrow, I'm looking at where we hide all our data: Browser Storage! Did the Event Loop ever confuse you? It definitely took me a few tries to finally "get it"! #CodeWithWajid #JavaScript #EventLoop #WebDevelopment #100DaysOfCode #LearningToCode #BuildingInPublic