Mastering JavaScript's Tricky 'this' Keyword

Recently, I revisited one JavaScript concept that has confused me more than once: the this keyword 🤯 I knew what this was supposed to represent, but in real projects, it often didn’t behave the way I expected. Sometimes it worked ✅, sometimes it returned undefined ❌, and sometimes it pointed somewhere completely unexpected 😅 While digging deeper, I finally understood how call, apply, and bind actually give us control over this 🔧 Here’s what clicked for me 👇 1️⃣ call() lets you invoke a function immediately and explicitly tell it what this should be. 2️⃣ apply() does the same thing, but expects the arguments as an array 📦 3️⃣ bind() doesn’t execute the function right away — instead, it returns a new function where this is permanently fixed 🔒 Once I understood this difference, a lot of JavaScript behavior started to feel predictable instead of magical ✨➡️📐 To make sure I really internalized it, I wrote a short blog using a simple real-world example and practical code snippets 🧠💻 Sharing it here in case it helps someone else who’s wrestling with this 👇 🔗 https://lnkd.in/gDXMqP8m Hitesh Choudhary Piyush Garg Chai Aur Code Akshay Saini 🚀 #JavaScript #LearningInPublic #WebDevelopment #CallApplyBind #ThisKeyword #Frontend

Why does 0 == false return true in JavaScript? 😵 If this confuses you, you're not alone. I wrote a guide explaining == vs === and how to avoid common pitfalls that trip up even experienced developers. Link below 👇 https://lnkd.in/dGP2aJZr #JavaScript #CodingTips #WebDev

If you work with JavaScript, you know how often you forget small but important details. I put together a complete JavaScript quick reference guide that covers: – fundamentals – arrays & objects – async / await – DOM manipulation – advanced concepts with real examples It’s meant to be bookmarked and reused. Read here: https://lnkd.in/gNun7kxB

Many beginners get confused when they start using JavaScript with React. The reason is JSX. Let’s simplify it. JSX looks like HTML. Same structure. Same feel. But JSX is JavaScript. JSX works like HTML in syntax. You can enter JavaScript using curly braces. Inside curly braces, you can use expressions only. Anything that returns a value. Variables work. Arrays work. Objects work. Map works. The ternary operator works. Statements do not work. If else is not allowed. For is not allowed. Switch is not allowed. The key idea is simple. JSX itself is an expression. Because of that, you can place JSX inside curly braces. You can store JSX in a variable. You can pass JSX to a function. You can use it in if else logic outside the markup. There is one more rule. A component must return one root element. When you need more, use a Fragment. This works because JSX is transformed into createElement. createElement returns a value. Once this clicks, React becomes clearer. Your code becomes easier to read. When was the last time you tried to use if directly inside JSX and got an error? #React #ReactJS #JavaScript #FrontendDevelopment #WebDevelopment

JavaScript has both 𝗳𝗼𝗿𝗘𝗮𝗰𝗵 and 𝗳𝗼𝗿...𝗼𝗳. They both loop. They both look innocent. They are not the same thing. I ignored this for way longer than I should’ve. At some point I tried to: • break out of a forEach • await inside a forEach • return values from a forEach    JavaScript politely said: no ❤️ That’s when it clicked: 𝗳𝗼𝗿𝗘𝗮𝗰𝗵 is a method. 𝗳𝗼𝗿...𝗼𝗳 is an actual loop. Different tools. Different rules. Very different foot-guns. I wrote a short breakdown on: • why break and continue don’t work in forEach • why async/await + forEach is a trap • when performance actually matters (hint: almost never) • how to stop overthinking this choice altogether 👉 Read it here: https://lnkd.in/ezfQ2zhp Frontend looks simple until it isn’t. That’s what I write about. If this kind of “wait… why does JS do that?” content is your thing, I publish regularly on Substack. Subscriptions are free (and cheaper than debugging this at 2am). #frontend #uidevelopment #uiarchitecture #javascript #jsdev #ui

Most JavaScript developers use functions every day… But very few truly understand what happens before their code runs. Let’s talk about Execution Context. Every time JavaScript runs your code, it creates something called an execution context. There are two main types: 1️⃣ Global Execution Context 2️⃣ Function Execution Context When your file starts running, JavaScript creates the Global Execution Context. Example: var name = "Sadiq"; function greet() { var message = "Hello"; console.log(message + " " + name); } greet(); Before this code executes: Memory is created. Variables are stored (initially as undefined if declared with var). Functions are fully stored in memory. Then execution begins line by line. When greet() is called, a new Function Execution Context is created. That’s why variables inside a function don’t interfere with global ones. Execution Context explains: Why hoisting happens Why scope works the way it does Why some variables are accessible and others aren’t Understanding this changed how I read JavaScript code. Instead of asking: “What is this line doing?” I now ask: “What context is this running in?” Big difference. Are you writing JavaScript… or do you understand how JavaScript is running your code? 👇 What JavaScript concept confused you the most when you started? #JavaScript #FrontendDevelopment #WebDevelopment #SoftwareEngineering #BuildInPublic

Understanding why `Promise.all()` needs an array in JavaScript Many developers try this and get confused 👇 ❌ Wrong way Promise.all(p1, p2); ✅ Correct way Promise.all([p1, p2]); 🤔 Why does this happen? Promise.all() accepts only ONE argument, and that argument must be an iterable (most commonly an array). 👉 An array allows JavaScript to loop through multiple promises and wait for all of them to resolve.  ✅ Working example let p1 = new Promise((resolve) => {   resolve(1); }); let p2 = new Promise((resolve) => {   resolve(2); }); Promise.all([p1, p2]) .then((data) => {   console.log(data); // [1, 2] }); ❌ Why `Promise.all(p1, p2)` throws an error? When you write: Promise.all(p1, p2); JavaScript treats it as: Promise.all(p1); But p1 is a "Promise object", not an iterable like an array. So JS throws: TypeError: object is not iterable  🧠 Easy way to remember > Promise.all waits for a collection of promises, not individual ones Always wrap promises inside an array.  ⚠️ One more important thing If any promise rejects, Promise.all() immediately rejects. Promise.all([Promise.resolve(1), Promise.reject("Error")]) .catch(console.error); // Error 💡 Hope this helps someone avoid a common JavaScript pitfall! . . . . . #SRYTAL #JavaScript #Promises #WebDevelopment #Frontend #Learning #Promise.all #Growtogether

So, you're writing JavaScript code across multiple files - it's a mess. Three files, to be exact: user.js, admin.js, and main.js. It's simple. You've got variables flying around, and they're all overwriting each other - not good. This happens because, by default, you're loading scripts into the global scope, which is like trying to have a conversation in a loud bar - everything gets lost in the noise. To fix this, you need to think about Modules - they're like little containers that keep your code organized. You enable Modules by adding type="module" to your script tag, like this: <script type="module" src="main.js"></script>. And just like that, you've got three strict rules in place: - File-Level Scope, which means variables aren't global by default - they're more like secrets shared among friends. - Strict Mode, which is like having a code reviewer who's always on your case - it's a good thing, trust me. - Deferred Execution, which means your code waits patiently until the HTML is parsed - it's like waiting for your coffee to brew before you start your day. Think of a Module like a private club - nothing gets in or out unless you explicitly allow it. You export what you want to share, and you import what you need - it's like trading secrets with your friends. And when you import a Module, you get a Live Reference, which is like having a direct hotline to the variable inside the Module - if something changes, you'll know instantly. Modules are also Singletons, which means the Engine evaluates them only once, and every subsequent import is like getting a reference to the same old friend - you're not starting from scratch every time. Using Modules gives you boundaries, and that's a beautiful thing - you can build complex systems without everything collapsing into the global scope. It's like having a clean and organized desk - you can focus on what matters. Source: https://lnkd.in/gD78hVjr #JavaScript #Modules #CodingBestPractices

🤔 Quick question: When JavaScript runs async code, where does everything actually go? After learning about the Call Stack and Event Loop, I realized something important: JavaScript doesn’t work alone — it collaborates with Web APIs and queues 👇 --------------------------- console.log("Start"); setTimeout(() => {  console.log("Timeout"); }, 0); console.log("End"); ---------------------------- Output: - Start - End - Timeout 💡 What happens behind the scenes? - console.log("Start") → pushed to the Call Stack - setTimeout → handed off to Web APIs - console.log("End") → runs immediately Once the Call Stack is empty: - Event Loop checks the Task Queue - setTimeout callback is pushed back to the stack - Callback executes How the pieces fit together Call Stack → executes JavaScript Web APIs → handle timers, DOM events, network calls Queues → hold callbacks waiting to run Event Loop → coordinates everything Takeaway JavaScript executes code using the Call Stack, offloads async work to Web APIs, and uses the Event Loop to decide when callbacks can run. #JavaScript #WebDevelopment #FullStack #LearningInPublic

JavaScript didn’t betray you. You just didn’t copy the object the way you thought you did. Shallow copy vs Deep copy in JavaScript Think of it like a shared Google Doc: Shallow copy -You made a shortcut to the doc -Edit one line & everyone sees the change Deep copy -You downloaded your own copy -Edit freely & no one else is affected Same in JavaScript: -Shallow copy copies references -Deep copy copies actual data If you’ve ever changed an object and thought, “Why did this other variable update too?” that’s shallow copy saying hello 👋 #javascript #frontend #reactjs