Afeef M’s Post

You know how JavaScript performs one function at a time and it becomes time consuming when a function takes too long to complete? This is because Js is a single threaded language and this behavior is called as synchronous. It can perform one task at a time which blocks other code. This can be solved by using Asynchronous functions (non-blocking way). JavaScript can execute code in two different ways: Synchronous (Blocking) Code runs line by line Each task waits for the previous one to finish If one task is slow, everything else pauses Think of it as a single-lane road. Asynchronous (Non-blocking) Time-consuming tasks run in the background JavaScript continues executing other code Once the task is done, the result is handled. In the next post I will tell how asnyc functions work. See you later. Cheers!! #JavaScript #WebDevelopment #MERN #AsyncJS #LearningInPublic

Most JavaScript bugs🐞 are not logic errors. They are scope misunderstandings. Ask yourself: Can a function access a variable declared outside it? 🤔 Can a block variable leak outside? 🤔 Why does lexical scope even exist? 🤔 If these questions make you pause, you’re not alone. I’ve broken down: • Global Scope • Function Scope • Block Scope • Lexical Scope Because once scope is clear 🎯, JavaScript stops feeling unpredictable. If you're revising fundamentals or mentoring juniors, this might help. Read Full Post content here 👇🏻 https://lnkd.in/dV8wsKKy 📌 Save it for later Full visual breakdown is also on Instagram → @JswithDhruv Let’s build fundamentals the right way. #JavaScript #JsConcepts #JsFundamentals #connections #followers #FrontendDevelopment #ReactJS #Developers

🔗 What is Promise Chaining in JavaScript? When working with asynchronous operations in JavaScript, we often need to perform tasks in sequence — one after another. This is where Promise Chaining comes in. Promise chaining means attaching multiple .then() methods to a promise so that the output of one step becomes the input of the next. ✅ Why It’s Needed : Imagine: 🔹 Fetching user data 🔹 Then fetching that user’s posts 🔹 Then processing those posts Each step depends on the previous one. Promise chaining allows us to handle this flow cleanly and predictably. 👉 How It Works : Each .then(): 🔹 Waits for the previous promise to resolve 🔹 Receives its result 🔹 Returns a new promise 🔹 That returned promise is passed to the next .then() in the chain. Example: 🔹 Each step runs only after the previous one completes 🔹 Errors are handled in a single .catch() 🚀 Benefits of Promise Chaining ✔ Avoids “callback hell” ✔ Keeps asynchronous code readable ✔ Maintains clean execution flow ✔ Centralized error handling 💡 Key Insight 👉 If you return a value → it automatically becomes a resolved promise. 👉 If you return a promise → the next .then() waits for it. #JavaScript #WebDevelopment #Frontend #AsyncProgramming #Promises

⚡ call() vs apply() vs bind() – Real Difference In JavaScript, these three methods are used to explicitly control the value of this inside a function. 🔹 call() Executes the function immediately Arguments are passed comma separated 🔹 apply() Executes the function immediately Arguments are passed as an array 🔹 bind() Does NOT execute the function immediately Returns a new function with a bound this value ✅ Quick Summary ✔ Use call() when you need to invoke a function immediately with comma separated arguments ✔ Use apply() when you need to invoke a function immediately with an array of arguments ✔ Use bind() when you need to create a new function with a fixed this value 💡 Pro Tip: call(), apply() and bind() are mainly used to explicitly set the value of this inside a function. #JavaScript #WebDevelopment #Frontend #JSConcepts #Coding #LearnToCode

Why try/catch Doesn’t Catch Everything in Async JavaScript try/catch works perfectly for synchronous errors. But in asynchronous JavaScript, it only works if you await the promise inside the try block. This is where many developers get confused. try/catch does not magically catch all async errors. It only catches: -Synchronous exceptions -Rejected promises that are properly awaited If a promise rejects outside of that boundary, the error escapes.

Ever wondered how JavaScript actually finds variables 🤔 Think of it like Russian nesting dolls or rooms inside rooms: 🏠 Global Scope → The Big House 🛏️ Outer Scope → The Bedroom 🚪 Local Scope → The Closet Here’s the rule 👇 You can always look outward, but never inward. When JavaScript searches for a variable, it follows a simple path: 👉 Check local 👉 Move outward 👉 Keep searching… 👉 Still not found? 💥 Reference Error This is Lexical Scoping + Scope Chain — the reason your code stays organized, predictable, and safe. Where did Lexical Scoping finally click for you — tutorials, projects, or debugging pain? 😄 Drop your experience below 👇 Let’s help beginners understand this faster. #JavaScript #WebDevelopment #Frontend #ProgrammingConcepts #100DaysOfCode #LearnToCode #DevCommunity

JavaScript Practice – Day by Day Improvement Today I practiced a JavaScript logic problem “Array Chunking.” The goal was to split an array into smaller subarrays (chunks) of a given size.  Concepts & Methods Used: • for loop for iteration • Array.slice() method to extract subarrays • Incrementing index by chunk size (i += n) for efficient traversal This approach helps break a large array into manageable chunks and improves understanding of array manipulation and problem-solving in JavaScript. I’m focusing on improving my JavaScript logic day by day through consistent practice. 💻 #JavaScript #ProblemSolving #CodingPractice #WebDevelopment #FrontendDevelopment

Day 5 of my JavaScript journey Today I went behind the scenes of JavaScript to understand how it works, and here is what I found; When you write JavaScript, it feels simple. You declare variables. You call functions. You await promises. The browser responds. Things move on the screen. But under the surface, there’s an entire engine working relentlessly to make that happen. JavaScript is a high-level language. This simply means you don't have to worry about managing your computer's memory or CPU manually. JavaScript quietly handles all of that for you in the background. That's one less thing to stress about as a beginner. It is also multi-paradigm. A paradigm is just a mindset or approach to writing code. And JavaScript doesn't force you into one way of thinking, you can structure your code in multiple ways depending on what the situation calls for. That flexibility is honestly one of the biggest reasons JavaScript is so popular. And then there's the concurrency model, how JavaScript handles multiple tasks at the same time even though it can only do one thing at a time. This is because, the "Event Loop" constantly checks: is the call stack empty? if yes, move the next task from the queue to the stack #JavaScriptJourney #LearningToCode

-- Did you know this in JavaScript? typeof null === "object" // true Looks wrong, right? It is. null is not an object. It’s a primitive value that represents the intentional absence of a value. So why does JavaScript say it's an object? Because of a historical bug from the early days of JavaScript. The mistake shipped, the web grew, and now it can’t be fixed without breaking existing websites. That’s why: typeof null // "object" still returns "object" today. Lesson: Don’t use typeof to check for null. Instead, do this: value === null Sometimes, understanding JavaScript means understanding its history — not just its syntax.

Promises in JavaScript is actually an interesting concept. Promises are one of the most important concepts in modern JavaScript. A Promise is an object that represents a value that will be either available now, later or never. It has three states: pending, fulfilled and rejected. Instead of blocking the program while waiting for something like data or an image to load, a promise allows JavaScript to continue running and then react when the task finishes. We can build a promise by using the Promise constructor, which takes an executor function with two parameters: resolve and reject. Resolve is called when the operation succeeds, and reject is called when something goes wrong. We can also consume promises using the .then() to handle success and catch() to handle errors. Each .then() method returns a new promise which allows us to chain asynchronous steps in sequence. Another powerful concept is PROMISIFYING, this simply means converting old callback-based APIs (like setTimeout or certain browser APIs) into promises so they can fit into modern asynchronous workflows. Understanding how to build, chain and handle promises properly is the foundation we need in mastering asynchronous JavaScript. #JavaScript #WebDevelopment #FrontendDevelopment #TechJourney #Growth