JavaScript Equality: Understanding === and == in ECMAScript

Understanding JavaScript internals completely changed the way I write and think deeply about how it works, which has given me confidence. 🚀 How Objects Work Behind the Scenes in JavaScript In JavaScript, objects are not stored directly in variables the way primitive values are. 👉 Objects(body) live in Heap Memory, and variables only store a reference (address) to that object. What does this mean in practice? When you assign an object to another variable, the reference is copied, not the object itself When you pass an object to a function, the function receives the same reference Any change made using one reference affects the original object let user1 = { name: "Alex" }; let user2 = user1; user2.name = "John"; console.log(user1.name); // John Both variables point to the same memory location in the heap. 🧠 Key Insight: JavaScript objects follow pass-by-reference behavior (reference copy), which is why unintended mutations can happen if we’re not careful. Understanding this concept helped me clearly see: Why shallow copy causes issues Why deep copy is sometimes necessary Why objects behave differently from primitives Once you understand the internals, JavaScript stops feeling magical and starts making sense. Go through the diagram, and you will understand better. Thanks to AKA- Anshu Pandey #JavaScript #Objects #MemoryManagement #JSInternals #WebDevelopment #Learning #FrontendDevelopment #WebDevelopment

While learning JavaScript, I noticed something that felt really strange at first. If you create a variable without using let, var, or const, JavaScript doesn’t throw an error. Instead… it silently creates a new variable What’s even more surprising is that this variable can be accessed outside the block where it was written. So how does this happen? When the JavaScript engine encounters a variable, it first checks the current block scope. If it doesn’t find it, it keeps going up through the parent scopes. If the variable is still not found, JavaScript creates it in the global scope, making it accessible everywhere. This behavior comes from the early philosophy of JavaScript. The language was designed to be forgiving and flexible, to help developers build web pages quickly without strict rules getting in the way. But this flexibility comes at a cost. Accidentally creating global variables can lead to: Data leaking between parts of the app Hard-to-track bugs Conflicts between scripts Once developers realized how dangerous this could be, Strict Mode was introduced: Js "use strict"; With strict mode enabled, JavaScript throws an error when you try to use an undeclared variable, preventing this silent leakage. This was a great reminder for me that JavaScript’s “weird” behaviors usually have historical reasons behind them — and understanding those reasons makes you a better developer, not just a user of the language. #JavaScript #JS #LearningJoureny #Web #SWE #coding

🗓️Day 38 of 100 - Why Does JavaScript Feel So Confusing? 🤯 If you’ve ever felt lost while learning JavaScript, trust me — you’re not alone. At first, JavaScript feels unpredictable: "5" + 1 // "51" "5" - 1 // 4 Same values. Different results. No error. 😅 Then there’s this: "5" == 5 // true "5" === 5 // false Small symbols. Big confusion. But here’s the truth 👇 JavaScript isn’t broken. It’s flexible. JavaScript: • Automatically converts types • Allows dynamic values • Follows hidden execution rules • Handles async work behind the scenes Once I stopped asking ❌ “Why is JavaScript so weird?” and started asking ✅ “What rule is JavaScript following?” Things slowly began to make sense. Feeling confused doesn’t mean you’re bad at coding. It means you’re learning a powerful language. One concept at a time. One bug at a time. It gets better. 💪✨ #JavaScript #WebDevelopment #LearningJourney #100DaysOfCode #Programming

So JavaScript is getting a whole lot more interesting. It's evolving, and fast. You can already play with some of these new features in the latest JavaScript engines - they're like the beta testers of the coding world. But here's the thing: these features aren't officially part of the standard yet, so you gotta be careful. Experimental features are like the secret menu at your favorite restaurant - they're not always on the menu, but they can be super useful if you know how to order them. For instance, there's Top-Level Await, which lets you use await in modules without needing async functions - it's like being able to get your food without waiting in line. And then there's Private Class Fields, which helps you encapsulate class properties, like keeping your secret recipe, well, secret. Logical Assignment Operators are another cool one - they simplify coding patterns, making it easier to write clean code. Oh, and let's not forget WeakRefs and FinalizationRegistry, which let you set references to objects that can be garbage-collected - it's like having a cleaning crew for your code. When you're using these experimental features, you gotta stay on top of things - proposed features can change, and that can break your existing code. It's like building a house on shifting sand - you need to be prepared for things to move. So, to use these features safely, you should always check browser compatibility - don't assume everyone's on the same page. Use polyfills and transpilation for unsupported features, like a translator for your code. And test those edge cases with frameworks like Jest or Mocha - it's like having a safety net for your code. Check out this article for more info: https://lnkd.in/gz8tXVm5 #ExperimentalFeatures #CodingBestPractices #ECMAScript #ProductionCode

So, keywords are a big deal in JavaScript. They're like the secret language that JavaScript uses to get things done. You can't just use them for anything, or it's like trying to sit at a table that's already reserved for someone else - it's just not gonna work. Think about it, when you're coding, you're basically giving the computer a set of instructions, and keywords are like the commands that make it all happen. For instance, you useconst to create a constant value, like a fixed price that never changes - it's like setting a price tag that says "this is what it costs, no negotiations." And then there's "let", which creates a variable, like a price that can fluctuate based on demand - it's like a price tag that says "make an offer." And don't even get me started on decision making - that's where "if" and "else" come in, like a flowchart that helps the computer figure out what to do next. It's like, "if it's sunny, then go to the beach, else stay home and watch Netflix." Some other key keywords to keep in mind: - "function" creates a block of code that can be used again and again, like a recipe that you can follow to make your favorite dish. - "return" gives the result of a function, like the final answer to a math problem. The thing is, these keywords can be a bit tricky to use, and they can behave differently in different situations - it's like trying to navigate a maze, you gotta know the right turns to take. So, use them carefully, and make sure you understand how they work. Check out this article for more info: https://lnkd.in/d4s9vnnv #JavaScript #Coding #WebDevelopment

🚀 JavaScript Object Prototypes – My Learning Notes While revisiting JavaScript fundamentals, I spent time understanding object prototypes, and it finally clicked. Sharing my notes in case it helps someone else too 👇 🔹 What is a Prototype? In JavaScript, prototypes are the mechanism by which objects inherit features from one another. Every object has a built-in property called its prototype. 🔹 Prototype Chain The prototype itself is also an object, which can have its own prototype — forming a prototype chain. This chain ends when we reach an object whose prototype is null. 🔹 Accessing the Prototype The property that points to an object’s prototype is not called prototype. Although browsers use __proto__, the standard and recommended way is: Object.getPrototypeOf(myObject); 🔹 Shadowing Properties When accessing a property, JavaScript first looks in the object itself. If not found, it searches up the prototype chain — this is called property shadowing. 🔹 Setting a Prototype You can set prototypes in two main ways: 1.Using Object.create() 2.Using constructor functions 🔹 Why Prototypes Matter Prototypes make JavaScript extremely powerful and flexible. They enable code reuse and support a form of inheritance, where objects can be more specialized versions of other objects. 📌 For me, understanding prototypes wasn’t about memorizing syntax — it was about grasping how JavaScript thinks. And once you get that, so many concepts start making sense. Always learning, always refining ✨ #JavaScript #WebDevelopment #LearningInPublic #FrontendDevelopment #Prototypes #CodingJourney

Today I focused on strengthening my core understanding of JavaScript fundamentals: Functions in JavaScript In JavaScript, functions are not just blocks of reusable code — they are first-class objects. About Function : Functions can be stored in variables. They can be passed as arguments to other functions. They can be returned from functions. They can be stored inside objects. JavaScript provides multiple ways to define functions, and each behaves slightly differently in terms of hoisting, scope, and the handling of the this keyword.  How Objects Are Created in JavaScript An object in JavaScript is a collection of key-value pairs used to store structured data. Objects can be created using: Object literals Constructor functions Classes (ES6) Factory patterns Object.create() Regardless of the method used, internally JavaScript treats objects as reference types stored in memory. How Objects Work Internally (Memory Concept) Understanding memory allocation changes everything. JavaScript uses two main memory areas: • Stack • Heap Primitive values are stored directly in the stack. Objects, arrays, and functions are stored in the heap. When you assign an object to a variable, the variable does not store the object itself. Instead, it stores a reference (memory address) that points to the location in the heap.  Equality in JavaScript: == vs === JavaScript provides two main equality operators. == (Loose Equality): Compares values after performing type coercion. Automatically converts data types when needed. === (Strict Equality): Compares both value and data type. No type conversion happens. Grateful to Sheryians Coding School and Anshu Pandey for emphasizing fundamentals over shortcuts. Strong basics in JavaScript make frameworks much easier to understand later. Building depth before speed. #JavaScript #WebDevelopment #LearningInPublic #SheryiansCodingSchool #AnshuPandey #FrontendDevelopment #Programming #JSFundamentals #ExecutionContext

So JavaScript is getting some cool new tricks. It's evolving, and that's a good thing - we're seeing some experimental features pop up in the latest engines. They're not official yet, but they're worth checking out. And, honestly, it's pretty exciting to think about what we can do with them. For instance, have you heard of Top-Level Await? It's a game-changer - you can use await in modules without needing async functions, which can simplify your code and make it more readable. Then there's Private Class Fields, which is all about encapsulating class properties and making your code more secure. It's a big deal. Logical Assignment Operators are another feature that can help simplify coding patterns and reduce errors. And let's not forget about WeakRefs and FinalizationRegistry - these allow you to set references to objects that can be garbage-collected, which can help with memory management. But here's the thing: when you're working with experimental features, you need to stay on top of their current stage - proposed features can change, and that can break your existing code. So, be careful. To use these features safely, you should always check browser compatibility, use polyfills and transpilation for unsupported features, and test edge cases with frameworks like Jest or Mocha. It's all about being proactive and making sure your code is solid. Innovation is key here - we're talking about creativity and strategy in coding. And, if you want to learn more, I'd recommend checking out this article: https://lnkd.in/gCTchPu6 #JavaScript #ExperimentalFeatures #CodingStrategy

So, you're building projects with JavaScript - and that's awesome. But, let's get real, do you really understand how the "this" keyword works? It's tricky. Its value is all about how a function is called, not where it's defined - that's the key. You'll learn a lot: what "this" actually means, how it behaves in different situations, and some common mistakes to avoid. If you're just starting out or looking to refresh your JavaScript skills, this post is for you. It's like having a conversation with a friend - we'll break it down, and I'll share some insights. For instance, think of "this" like a pronoun - its meaning changes depending on the context, just like how "you" can refer to different people in different conversations. And, trust me, understandingthis will make a huge difference in your coding journey - it's a game-changer. Check out this resource for more info: https://lnkd.in/g-tn9CXj #JavaScript #Coding #WebDevelopment