JavaScript Conditionals Explained

Yesterday, I went deeper into one of the most confusing parts of JavaScript: "The + operator" At first glance, `+` looks simple. But unlike operators such as -, *, and /, JavaScript’s + has two possible meanings: - numeric addition - string concatenation And that is exactly what makes it tricky. My biggest takeaway was this: 1. When JavaScript sees a + b, it does not immediately assume numeric addition. 2. It first has to decide: - Should this be string concatenation? - Or should this be numeric addition? That decision is what makes "+" so different from operators like "-". For example: - "5" - 1 gives 4 because subtraction is numeric only. But: - "5" + 1 gives "51" because once JavaScript sees that one side becomes a string, it goes down the string concatenation path. I also learned that the real logic of + is deeper than the small operator section most people look at first. The actual mental model I now use is: 1. Convert both sides to primitives 2. If either primitive is a string: - convert both to strings - concatenate Otherwise: - convert both to numeric values - make sure the numeric types match - perform numeric addition That also led me into learning ToNumeric, which was another big insight. Before this, I mostly thought in terms of ToNumber, but ToNumeric is different: - ToNumber only gives a Number - ToNumeric can return either a Number or a BigInt That is why: - 1n + 2n works but - 1 + 2n throws a TypeError because JavaScript does not allow mixing Number and BigInt in that numeric path. The more I study coercion, the more I realise that JavaScript is not random at all. A lot of “weird” behavior starts making sense when you stop memorising examples and instead ask: - what operation is being performed? - what kind of value does it need? - which abstract operation is JavaScript using behind the scenes? That shift in mindset is making the language far more understandable for me. I’ve also been maintaining detailed notes on everything I’m learning. If anyone wants the deeper breakdown with examples and spec-based notes, I’ve uploaded them here: GitHub repo: https://lnkd.in/ephuZ-w6 Next, I’ll keep going deeper into coercion and loose equality. #JavaScript #TypeScript #WebDevelopment #SoftwareEngineering #ECMAScript #100DaysOfCode

JavaScript in 2026: Temporal API makes dates actually good, Iterator helpers bring lazy evaluation, and RegExp.escape() finally exists after 15 years. Plus: TypeScript v6 is here, Vite dominates the build tool landscape, and 92% of devs are using AI to write code. Wild times. https://lnkd.in/gbNKWc4q #javascript #frontend

Most developers think inheritance in JavaScript works like traditional OOP. It doesn’t. And that confusion leads to messy, over-engineered code. JavaScript uses prototypal inheritance — not classical inheritance. 👉 Objects inherit directly from other objects. 💡 There are 3 main ways inheritance works in JavaScript: 🔹 1. Prototypal Inheritance (Core Concept) const animal = { speak() { console.log("Makes a sound"); } }; const dog = Object.create(animal); dog.bark = function () { console.log("Bark"); }; dog.speak(); // inherited dog.bark(); // own method ✔ Simple ✔ Flexible ✔ Native to JS 🔹 2. Constructor Function Inheritance function Animal(name) { this.name = name; } Animal.prototype.speak = function () { console.log(this.name + " makes noise"); }; function Dog(name) { Animal.call(this, name); // inherit properties } Dog.prototype = Object.create(Animal.prototype); const d = new Dog("Tommy"); d.speak(); ✔ More structured ✔ Used in older codebases 🔹 3. Class-based Inheritance (ES6) class Animal { constructor(name) { this.name = name; } speak() { console.log(this.name + " makes noise"); } } class Dog extends Animal { bark() { console.log("Bark"); } } const dog = new Dog("Rocky"); dog.speak(); dog.bark(); ✔ Cleaner syntax ✔ Easier to read ❗ Still uses prototypes under the hood ⚡ The truth most people miss: Even with classes… 👉 JavaScript is STILL prototype-based. Classes are just syntactic sugar. 🧠 The real upgrade: Stop thinking: “Which syntax should I use?” Start thinking: “How does inheritance actually work under the hood?” Because once you understand prototypes… You don’t just write code— you understand it. What confused you more in JavaScript—closures, promises, or prototypes? 👇 #JavaScript #WebDevelopment #Programming #Frontend #Coding #SoftwareEngineering

I’ve been writing JavaScript for around 2.6 years now, and looking back, there are a few things I really wish someone had just shown me. Not advanced stuff—just the “why didn’t I know this earlier?” kind of basics 👇 ━━━━━━━━━━━━━━━━━━━ 1️⃣ Optional Chaining (?.) I used to write checks like: if (user && user.profile && user.profile.name) Now it’s just: user?.profile?.name Feels small, but it removes so much noise from the code. ━━━━━━━━━━━━━━━━━━━ 2️⃣ Nullish Coalescing (??) I used to do: const name = user.name || "Guest" But that breaks when value is 0 or empty string. Now: const name = user.name ?? "Guest" This one saved me from so many weird bugs. ━━━━━━━━━━━━━━━━━━━ 3️⃣ Destructuring Earlier: const name = user.name const age = user.age Now: const { name, age } = user Simple change… but code becomes so much easier to scan. ━━━━━━━━━━━━━━━━━━━ 4️⃣ Promise.all() I didn’t realize how slow my code was until I learned this. Instead of waiting one by one: await fetchUsers() await fetchProducts() Now: Promise.all([...]) Everything runs together. Much faster response time. ━━━━━━━━━━━━━━━━━━━ 5️⃣ console.table() This one is underrated. Instead of messy logs everywhere, just: console.table(data) Clean rows, clean columns. Debugging becomes less painful. ━━━━━━━━━━━━━━━━━━━ Nothing fancy here. But honestly, these small things quietly level up your everyday coding. ━━━━━━━━━━━━━━━━━━━ If you’re just starting out, I’d focus on these before jumping into frameworks. They stick with you everywhere — React, Node, anything. ━━━━━━━━━━━━━━━━━━━ What about you? Which one did you start using first? 👇 #JavaScript #WebDevelopment #MERNStack #ReactJS #NodeJS #CodingLife #LearnToCode

The return Statement, Pocket Knowledge for the Era of Vibe Coding You can vibe code an entire app today. Prompt your way from idea to deployment without writing a single function from scratch. And that’s fine. But when undefined stares back at you and the AI-generated function isn’t behaving, you need to know why. Not from another prompt. From your own head. This isn’t a tutorial on return. It’s a briefing. Four things you carry with you as a developer. 1. A function is a private world When JavaScript runs a function, it creates a closed room. Variables built inside live inside. Instructions run inside. Nothing walks out on its own, no matter how clearly you can see the value sitting there. function buildLink() { const link = “https://lnkd.in/eH3akRij"; } const result = buildLink(); console.log(result); // undefined That link exists. It’s just trapped. return is the only door out of that room. No return nothing comes back. Ever. 2. return does two things at once This is the one most people miss. return doesn’t just send a value out. It stops the function dead at the same moment. Not pauses. Stops. Everything below it in that block becomes invisible to JavaScript, it won’t run, it won’t error, it will simply never execute. function buildCdnLink(packageName, version, filePath) { let link = `https://lnkd.in/eUAsawyz; if (filePath) { return; // door opens, function dies HERE link = link + “/” + filePath; // dead code. JavaScript never sees this. } return link; } return fired with nothing after it. The function answered with silence. JavaScript calls that silence undefined. Two things. Simultaneously. Send the value out, kill the function. Miss the second one and you’ll spend hours debugging code that looks completely fine. 3. Placement is everything Because return kills the function the moment it runs, where you put it is as important as what you put after it. The rule is simple, do the work first, return at the bottom. // wrong, return fires before the work is done function buildCdnLink(packageName, version, filePath) { let link = `https://lnkd.in/eUAsawyz; if (filePath) { return; // too early, work never happens link = link + “/” + filePath; } return link; } // right, work happens first, return hands it back at the end function buildCdnLink(packageName, version, filePath) { let link = `https://lnkd.in/eUAsawyz; if (filePath) { link = link + “/” + filePath; // work done first } return link; // then the door opens } Every time you write a function, ask yourself, have I done everything before I open the door? If the answer is no, return is in the wrong place. Read the full piece on Medium; [https://lnkd.in/eEu9frGx] #JavaScript #WebDevelopment #Programming #LearnToCode #SoftwareDevelopment #VibeCoding #OpenSource

🚀 𝗡𝗲𝘄 𝗕𝗹𝗼𝗴 𝗣𝗼𝘀𝘁: 𝗧𝗵𝗲 '𝗻𝗲𝘄' 𝗞𝗲𝘆𝘄𝗼𝗿𝗱 𝗶𝗻 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 Excited to share that I’ve just published a detailed blog breaking down one of the fundamental (and often misunderstood) concepts in JavaScript — the '𝗻𝗲𝘄' keyword! Covered everything from constructor functions and prototypes to how it actually works under the hood with clear examples. 🔗 Read it here: https://lnkd.in/gWRTW87v Huge thanks to the ChaiCode community and mentors for the constant push and inspiration! Hitesh Choudhary Piyush Garg Anirudh J. Akash Kadlag Suraj Kumar Jha Chai Aur Code Jay Kadlag Nikhil Rathore Would love to hear your feedback or thoughts on the post! #JavaScript #JSFundamentals #WebDevelopment #ChaiCode #Cohort #LearningInPublic #DevCommunity

Keeping up with JavaScript in 2026 🏃♂️ A big part of this overview by Chris Coyier (Frontend Masters) focuses on how JavaScript itself is evolving through ECMAScript. The 2025 edition brings incremental but meaningful improvements, and the 2026 pipeline already shows where the language is heading with cleaner APIs and better consistency. Beyond the language, the ecosystem keeps moving fast. Bun keeps gaining traction as a runtime, Vite remains dominant on the tooling side, and frameworks keep exploring new patterns around server-first and reduced client-side JavaScript. A quick read to stay aligned with both the present and near future of JavaScript. https://lnkd.in/edeS58kd

Day 11 / 30 - Javascript Coding Challenge - Memoization in JavaScript 🚀 Problem: Given a function fn, return a memoized version of that function. A memoized function is a function that will never be called twice with the same inputs. Instead it will return a cached value. You can assume there are 3 possible input functions: sum, fib, and factorial. sum accepts two integers a and b and returns a + b. Assume that if a value has already been cached for the arguments (b, a) where a != b, it cannot be used for the arguments (a, b). For example, if the arguments are (3, 2) and (2, 3), two separate calls should be made. fib accepts a single integer n and returns 1 if n <= 1 or fib(n - 1) + fib(n - 2) otherwise. factorial accepts a single integer n and returns 1 if n <= 1 or factorial(n - 1) * n otherwise.   Solution: function memoize(fn) {  let memoValues = {};   return function (...args) {     const key = JSON.stringify(args)     if (key in memoValues) {       return memoValues[key];     } else {       memoValues[key] = fn(...args);       return memoValues[key];     }   }; } #JavaScript #Memoization #DSA #CodingPractice #100DaysOfCode #FrontendDevelopment

The JavaScript Temporal API will soon be Baseline Newly Available. Here's a cheatsheet that I built for developers who already know Date. https://lnkd.in/emvWBw-v Enjoy!

Lately, I’ve been going deeper into JavaScript coercion, and the more I study it, the less random JavaScript feels. A lot of behaviour that looks strange at first starts making sense once you realise that JavaScript is following rules defined in the ECMAScript specification. Recently, I focused on the abstract operations behind conversion, especially: - ToNumber - StringToNumber - ToString - ToPrimitive - OrdinaryToPrimitive One of the biggest takeaways for me is that JavaScript does not just “guess” what to do with values. It follows a defined process depending on the operation being performed. For example: - `"5" - 1` works because subtraction expects numbers. - `Number("")` becomes `0`. - `Number(undefined)` becomes `NaN`. - `ToNumber(BigInt)` throws an error, but `ToString(BigInt)` works. - When an object is involved, JS first tries to extract a primitive value before continuing coercion The part I found especially interesting was object-to-primitive conversion. If JavaScript encounters an object in a coercion context, it first checks for `Symbol.toPrimitive`. If that is not available, it falls back to `OrdinaryToPrimitive`, where the order of calling `toString()` and `valueOf()` depends on the hint being used: - string hint → toString() first - number hint → valueOf() first I also learned more about why string-to-number conversion behaves the way it does: - Number("25") gives 25 - Number(" 25 ") also gives 25 - Number("Infinity") gives Infinity - Number("1_000") gives NaN - Number("10n") gives NaN What is changing my understanding the most is this: - Instead of memorising “weird JavaScript behaviour”, I’m now trying to ask: 1. What operation is being performed? 2. What type of value does that operation expect? 3. Which abstract operation is JavaScript using behind the scenes? That mindset makes the language much easier to reason about. I’ve also been maintaining detailed notes on what I’m learning. If anyone wants to go deeper into these topics, I’ve uploaded them here: GitHub repo: https://lnkd.in/ephuZ-w6 #JavaScript #TypeScript #WebDevelopment #SoftwareEngineering #ECMAScript #100DaysOfCode