Rebuilding JavaScript Array Methods with Custom Polyfills

Day 1 🧠 Understanding Lexical Scoping in JavaScript (in 2 minutes) One concept that quietly powers a lot of JavaScript behavior is lexical scoping. 👉 Simply put: A function remembers where it was written, not where it is called. 🔍 Example: let name = "Global"; function print() { console.log(name); } function test() { let name = "Local"; print(); } test(); // Output: Global 💡 Even though print() is called inside test(), it still logs "Global". Why? Because print() was defined in the global scope, so it uses that scope. 🧠 Key Takeaways: Scope is determined at write time (lexical), not run time. JavaScript looks for variables in the scope chain upward. This is the foundation of closures. 🚀 Why this matters: Understanding lexical scoping helps you: ✔ Write predictable code ✔ Debug faster ✔ Master closures, callbacks, and async logic ✔ Work better with React hooks 🔥 One-line takeaway: 👉 "Where you write your function decides what it can access." If you're learning JavaScript fundamentals, don’t skip this — it shows up everywhere. #JavaScript #WebDevelopment #Frontend #Coding #100DaysOfCode

🚀 JavaScript Problem-Solving Practice 💻 Today, I worked on improving my logic building skills with some interesting problems 👇 🔹 Minimum Coins Problem Used slice() + reduce() to find the minimum number of elements forming a target sum. 🔹 Array Transformation Replaced even indices with minimum value and sorted odd indices using sort(). 🔹 First Non-Repeating Character Used an object (frequency count) to find the first unique character in a string. 💡 Key Learnings: ✔️ Better understanding of slice(), reduce(), sort() ✔️ Improved array & string manipulation ✔️ Strengthened problem-solving approach Consistency is the key 🔑✨ #JavaScript #ProblemSolving #CodingPractice #FrontendDevelopment

Day 3/200🚀 Understanding JavaScript Closures, Scope & setTimeout Today I explored a tricky but important JavaScript concept while experimenting with setTimeout, var, and let. 🔹 What I Learned: JavaScript executes synchronous code first, then asynchronous callbacks setTimeout does NOT store values, it stores a function (closure) Closures capture variables by reference, not by value var uses a single shared variable let creates a new variable for each iteration 🔹 The Problem I Faced: I expected this code to print 0 1 2, but it printed 3 3 3 🔹 Why It Happened: Loop finished execution first i became 3 All callbacks accessed the same variable reference 🔹 Solution: Using let instead of var creates a new binding for each iteration, giving the expected output. 💡 Key Takeaway: “Closures capture variables by reference. var shares one binding, while let creates a new binding per iteration.” #JavaScript #WebDevelopment #Frontend #NodeJS #LearningInPublic #Coding

Garbage Collection in JavaScript — Simplified Garbage Collection (GC) is the process by which JavaScript automatically frees memory that is no longer in use. Anything reachable from the root (window in browsers, global in Node.js) is kept in memory. Anything not reachable becomes garbage. JavaScript uses the Mark and Sweep algorithm: 1. Mark all objects reachable from the root 2. Sweep (remove) all objects that are not marked Example: let user = { name: "Shreyas" }; // memory allocated user = null; // object becomes unreachable Now, since there is no reference to the object, it becomes eligible for garbage collection. Understanding this helps in writing memory-efficient JavaScript applications. #JavaScript #WebDevelopment #FrontendDevelopment #Performance

🚀 Day 947 of #1000DaysOfCode ✨ The Shortest JavaScript Program (You’ll Be Surprised 😮) This is one of those concepts that looks super simple… but completely changes how you see JavaScript. In today’s post, I’ve broken down the shortest possible JavaScript program — and trust me, it’s not just about writing less code. Behind this tiny piece of code lies how JavaScript actually runs your program, creates execution context, and prepares memory before even executing a single line. Sounds crazy? Wait till you see it. This is the kind of concept that once you understand, a lot of “weird JavaScript behavior” suddenly starts making sense. If you’re serious about mastering JavaScript, you don’t want to miss this one. 👉 Swipe through the carousel — this might blow your mind 🤯 👇 Did you already know what the shortest JS program is? #Day947 #learningoftheday #1000daysofcodingchallenge #FrontendDevelopment #WebDevelopment #JavaScript #React #Next #CodingCommunity #JSDeepDive

#Day16 Understanding Callback Hell in JavaScript. Today I took on one of the most talked-about challenges in asynchronous JavaScript Callback Hell (also known as the Pyramid of Doom). In my Mentorship for Acceleration backend track, I built a simulated ice cream production process using multiple nested setTimeout callbacks to represent real asynchronous steps in a production line. What is Callback Hell? It occurs when we have multiple asynchronous operations that depend on each other, leading to deeply nested callbacks. While the code works, it becomes extremely difficult to read, debug, and maintain as the number of steps increases. It’s called the Pyramid of Doom because of the visual shape the code creates when you have many nested callbacks. Problems it creates: => Very difficult to read and understand the flow. => Hard to debug (which line belongs to which callback?). => Painful to maintain or add new steps. => Error handling becomes messy. => Code looks ugly and unprofessional. #M4ACELearningChallenge #LearningInPublic #JavaScript #CallbackHell #AsynchronousJavaScript

🚀 Understanding Async JavaScript: async/await vs .then() Today I practiced handling asynchronous operations in JavaScript using both Promises and async/await 🔥 📌 What I explored: 💡 Key Insight:While .then() works perfectly, async/await makes asynchronous code look synchronous — improving readability and maintainability. 🧠 Example takeaway: Both approaches are powerful — choosing the right one depends on the use case! 🌐 API used: JSONPlaceholder for dummy data testing 📈 Small steps every day towards mastering JavaScript! #JavaScript #AsyncAwait #WebDevelopment #FrontendDeveloper #CodingJourney #LearnInPublic #100DaysOfCode

Can you explain the JavaScript event loop? Not because the concept is hard, but because explaining it clearly is what actually matters. Here’s the simplest way to break it down: JavaScript runs in a single thread, using a call stack to execute code. 1. Synchronous code runs first → Functions are pushed to the call stack and executed immediately 2. Async tasks are handled by the browser/environment → e.g. setTimeout, fetch, DOM events 3. Once the call stack is empty → the event loop starts working It processes queues in this order: 👉 Microtasks first (Promises, queueMicrotask) 👉 Then macrotasks (setTimeout, setInterval, I/O) Why? - A and D are synchronous → executed first - Promise (C) → microtask queue → runs next - setTimeout (B) → macrotask → runs last Explaining it step by step is simple — but doing it clearly makes all the difference. #Frontend #JavaScript #WebDevelopment #TechInterviews #SoftwareEngineering

I ran a small JavaScript experiment today, and it was a good reminder that performance often hides inside simple concepts. I used the same function twice with the same inputs. The first call took noticeable time. The second call returned almost instantly. Nothing changed in the inputs. Nothing changed in the output. The only difference was that the second time, JavaScript didn’t need to do the work again. That’s the beauty of memoization. Instead of recalculating, it remembers the previous result and returns it from cache. What looks like a small optimization in code can make a big difference in how efficiently an application behaves. The deeper I go into JavaScript, the more I realize: the real power is not just in writing code — it’s in understanding how to make code smarter. #JavaScript #WebDevelopment #FrontendDevelopment #Memoization #Closures

💻 JavaScript Array Methods – Hands-on Practice Completed Worked on some fundamental Array methods in JavaScript and practiced how they actually behave 👇 ✔️ Used push() and pop() to add/remove elements from the end ✔️ Used unshift() and shift() to work with elements at the beginning ✔️ Explored length to track array size ✔️ Understood the difference between slice() and splice() through practice 💡 Key takeaway: slice() does not modify the original array, while splice() directly changes it — this difference is really important while working with data. Practicing these basics is helping me build a strong foundation in JavaScript 🚀 #JavaScript #WebDevelopment #Frontend #CodingJourney #LearningByDoing