Quick Sort Algorithm in JavaScript Explained

What is the difference between let, var, and const? `var`, `let`, and `const` are used to declare variables in JavaScript, but they behave differently. `var` is the older way and has function scope, which can lead to unexpected behavior. It also allows redeclaration and can be updated freely. `let` is block-scoped, meaning it only exists within the block where it’s defined. It can be updated but not redeclared in the same scope, making it safer than `var`. `const` is also block-scoped but cannot be reassigned after it’s declared. It’s used for values that should not change. Overall, `let` and `const` are preferred in modern JavaScript. #webdeveloper #tech #coding #programming

🚀 Day 2 of Logic Building in JavaScript Most beginners ignore this… but pattern problems actually build real programming logic 🤯 Today I focused on strengthening my fundamentals through pattern-based questions 👇 ✅ What I practiced: • Right-angled star pattern • Inverted right-angled star pattern • Pyramid star pattern • Diamond shape ⭐ & inverted pattern (odd numbers) • Hollow square star pattern • Hollow pyramid triangle • Alternate binary triangle (0-1 pattern) 🧠 What I actually learned: • How 2*i - 1 controls pyramid width • How spacing (n - i) creates perfect alignment • Difference between boundary vs inner logic in hollow patterns • Importance of print vs println (small thing, big impact!) Consistency 💯 Building logic one day at a time 🚀 👉 What was the toughest pattern you faced while learning? #Day2 #LogicBuilding #JavaScript y #DSA #100DaysOfCode #LearnInPublic #Developers

30 Days JavaScript Challenge : Day 27 ✅ Today’s problem was about creating a compact object basically removing all falsy values from an object or array, even if they are nested. At first glance it looks easy, but once nested structures come in, it gets interesting. This problem really tests your understanding of: Falsy values (null, 0, false, "", etc.) Recursion for nested objects/arrays Treating arrays like objects (since indices are keys) It’s one of those questions that feels very practical like cleaning API responses or filtering unwanted data before using it. Definitely helped me think more deeply about how JavaScript handles data structures. Almost at the end now… consistency paying off 🚀 #javascript #leetcode #webdevelopment #frontenddeveloper #codingchallenge #learninginpublic #developers #programming #buildinpublic

Closures look confusing at first, but the core idea is simple: A closure is when a function remembers variables from the scope where it was created, even after that outer function has finished running. That is why closures are so useful for private state, counters, factories, and callbacks. The infographic breaks it down visually: create a variable, return an inner function, and that inner function keeps access to the remembered value. If you understand this, a lot of JavaScript starts making more sense. What JavaScript concept should I simplify next? #JavaScript #Closures #WebDevelopment #FrontendDevelopment #Programming #LearnToCode #ReactJS #SoftwareEngineering

Today, I learned something interesting about numbers in JavaScript. For example: 0.1 + 0.2 = 0.30000000000000004  But 1.1 plus 1.2 equals 2.3 In simple terms: JavaScript doesn't store numbers in decimal form; it stores them in binary (0s and 1s). Binary can't store some decimal numbers exactly, like 0.1 and 0.2. This means that a very small error is added when you do math. That's why you might see results like 0.30000000000000004. Temporary Fixes : Use Math.round : Math.round((0.1 + 0.2) * 100) / 100  Use toFixed:  (0.1 + 0.2).toFixed(2)  Use Math.floor or Math.ceil: Math.floor((0.1 + 0.2) * 100) / 100  //when rounding off lower value Math.ceil((0.1 + 0.2) * 100) / 100 //when rounding off to upper value This is not a bug in JavaScript. It happens because of how most programming languages store floating-point numbers. #JavaScript #Coding #WebDevelopment #Programming #100DaysOfCode

this in JavaScript looks simple… until it starts pointing to the wrong thing 😵 Same function, different outputs — just because of how it’s called. So what does this actually mean? 👉 It’s not about where the function is written 👉 It’s about who is calling the function In this blog, I’ve explained: What this really represents this in global context this inside objects and functions How calling context changes everything Kept it simple with clear examples (no unnecessary theory) ✨ 🔗 Read here: https://lnkd.in/dMkPffeA Would appreciate your feedback 🙌 #javascript #webdevelopment #programming #coding

30 Days JavaScript Challenge : Day 26 ✅ Today’s problem was about flattening a multi-dimensional array, but with a twist we were given a depth n and had to flatten only up to that level. Not a full flatten, not a shallow one… somewhere in between. It really makes you think about recursion and depth control: When to go deeper When to stop How to keep track of current depth What I liked is how this problem builds intuition around nested data structures something you see a lot in real apps (APIs, configs, UI trees, etc.). Slowly getting more comfortable with recursion and thinking in layers. #javascript #leetcode #webdevelopment #frontenddeveloper #codingchallenge #learninginpublic #developers #programming #buildinpublic

Day 98 of my #100DaysOfCodeChallenge Today I explored Object-Oriented Programming in JavaScript using classes. Here’s what I worked on: Built a Product class with methods to display details and calculate total price Learned how constructors initialize object properties Implemented static properties and methods using a utility class Created a User class to track the number of users created This helped me understand the difference between instance-level and class-level behavior, and how to structure code more effectively. It’s a shift from just writing functions to designing systems. #JavaScript #OOP #WebDevelopment #SoftwareEngineering

The new keyword looks simple… but most people use it without knowing what it actually does 👀 That’s exactly where confusion starts. Why does a function suddenly create objects? Where does this point? And how do methods magically appear? 👉 It’s all because of new. In this blog, I’ve explained: What new actually does behind the scenes How constructor functions create objects How objects link to shared methods (prototype) Why everything breaks without new Kept it simple, with step-by-step explanation and examples ✨ 🔗 Read here: https://lnkd.in/dyZwek-x Would love your feedback 🙌 Next: Constructor Functions or this keyword? #javascript #webdevelopment #programming #coding

LeetCode Day 20 : Problem 15 (3Sum) Just solved my LeetCode problem for today. It was "3Sum", find all unique triplets in an array that add up to zero. Sounds like a natural extension of Two Sum, right? Just add a third pointer. But here's what I actually learned: The naive extension doesn't work cleanly. Three nested loops give you O(n³) and you still have to deduplicate the output, which becomes its own problem. The real insight is that sorting first unlocks everything else. Once the array is sorted, you fix one number with an outer loop and reduce the remaining problem to exactly Two Sum II on the rest of the array. Two pointers, moving inward, same logic as yesterday. O(n²) total, one pass per fixed element. But the deduplication is where this problem actually lives. There are three places duplicates can sneak in and each needs its own guard. The first is the outer pointer. If nums[i] equals nums[i-1], you've already explored every triplet that starts with this value. Skip it. The second and third are the inner pointers after finding a valid triplet. If nums[left] equals nums[left+1], moving left forward once would just find the same triplet again. Same for the right side. So you skip past all consecutive duplicates before moving both pointers inward. The order of those inner skips matters too. You skip duplicates first, then move the pointers. Not the other way around. Sorting is doing most of the heavy lifting here. It makes the two-pointer approach possible, it makes duplicate detection trivial with a single comparison, and it guarantees that once your fixed element is positive, no valid triplet can exist ahead of it since two positives can never sum to zero with another positive. The real lesson? Sorting is often the unlock that turns an ugly O(n³) problem into a clean O(n²) one. Before writing nested loops, ask whether sorting the input first changes what's possible. #DSA #LeetCode #JavaScript #CodingJourney #Programming