5 Things I Wish I Knew When Starting JavaScript

*5 Things I Wish I Knew When Starting JavaScript 👨💻* Looking back, JavaScript was both exciting and confusing when I started. Here are 5 things I wish someone had told me earlier: *1. `var` is dangerous. Use `let` and `const`* – `var` is function-scoped and can lead to unexpected bugs. `let` and `const` are block-scoped and safer. *2. JavaScript is asynchronous* – Things like `setTimeout()` and `fetch()` don’t behave in a straight top-down flow. Understanding the *event loop* helps a lot. *3. Functions are first-class citizens* – You can pass functions as arguments, return them, and even store them in variables. It’s powerful once you get used to it. *4. The DOM is slow – avoid unnecessary access* – Repeated DOM queries and manipulations can hurt performance. Use `documentFragment` or batch changes when possible. *5. Don’t ignore array methods* – `map()`, `filter()`, `reduce()`, `find()`… they make code cleaner and more readable. I wish I started using them sooner. 💡 *Bonus Tip:* `console.log()` is your best friend during debugging! If you’re starting out with JS, save this. And if you're ahead in the journey — what do *you* wish you knew earlier? #JavaScript #WebDevelopment #CodingJourney #Frontend #LearnToCode #DeveloperTips

🚀 Day 30/50 – Function Currying in JavaScript Think of Function Currying like building a relationship. You don’t propose directly 😅 First comes the “Hi Hello 👋” phase → then friendship ☕ → and finally… the proposal ❤️ In JavaScript, instead of passing all arguments at once, Function Currying lets us pass them step by step, each step returning a new function until the final output is achieved. Here’s a simple code analogy from my video: function proposeTo(crush) { return function (timeSpent) { return function (gift) { return `Dear ${crush}, after ${timeSpent} of friendship, you accepted my ${gift}! 🥰`; }; }; } console.log(proposeTo("Sizuka")("3 months")("red rose 🌹")); Each function takes one argument and returns another function — making the code modular, flexible, and easy to reuse. 👉 This is Function Currying — one argument, one step, one perfect result. 🎥 Watch the full short video here: 🔗 https://lnkd.in/g-NkeYBc --- 💡 Takeaway: Function Currying isn’t just a JavaScript trick — it’s a powerful pattern for cleaner, more composable functions that enhance reusability and maintainability in modern frontend code. --- Would love to know: 👉 What’s your favorite JavaScript concept that clicked instantly when you saw it explained simply? #javascript #frontenddevelopment #webdevelopment #coding #programming #softwareengineering #learnjavascript #100daysofjavascript #techsharingan #developers #careergrowth

Understanding this in JavaScript this — one of the most misunderstood keywords in JavaScript. It’s simple in theory… until it suddenly isn’t 😅 Here’s what makes it tricky — this depends entirely on how a function is called, not where it’s written. Its value changes with context. Let’s look at a few examples 👇 const user = { name: "Sakura", greet() { console.log(`Hello, I am ${this.name}`); }, }; user.greet(); // "Sakura" ✅ const callGreet = user.greet; callGreet(); // undefined ❌ (context lost) const boundGreet = user.greet.bind(user); boundGreet(); // "Sakura" ✅ (context fixed) Key takeaways 🧠 ✅ this refers to the object that calls the function. ✅ Lose the calling object → lose the context. ✅ Use .bind(), .call(), or .apply() to control it. ✅ Arrow functions don’t have their own this — they inherit from the parent scope. These small details often trip up developers in interviews and real-world debugging sessions. Once you understand the context flow, this becomes a lot less scary to work with. 💪 🎥 I simplified this in my Day 28/50 JS short video— check it out here 👇 👉 https://lnkd.in/gyUnzuZA #javascript #webdevelopment #frontend #backend #programming #learnjavascript #softwaredevelopment #developerslife #techsharingan #50daysofjavascript

Day 3: Deepening JavaScript Skills with Counter Function Challenge! 🚀 Today, I tackled a classic problem — creating a flexible counter object that can increment, decrement, and reset — and it really sharpened my understanding of closures and object-oriented design in JavaScript. I implemented the createCounter function to accept an initial value and return an object with three methods: increment(): increases the value by 1 and returns it decrement(): decreases the value by 1 and returns it reset(): resets the value to the initial value and returns it This exercise reinforced how closures help maintain persistent state for each counter instance, making the code both clean and efficient. Here's a quick snippet: javascript const createCounter = (init) => { let n = init; return { increment() { return ++n; }, decrement() { return --n; }, reset() { n = init; return n; } }; }; Excited to keep pushing forward on this JavaScript journey! 💪 Let’s continue learning and sharing—feel free to share your progress or ask questions below. #JavaScript #30DaysOfJS #CodingJourney #Closure #WebDevelopment #LeetCode #ProblemSolving

Those little question marks in JavaScript? They finally make sense now. 😅 💡 Today I learned something subtle but super useful in JavaScript! Those little question marks ? and ?? actually do a lot more than I thought Here’s what clicked for me today ✅ ?? – Nullish Coalescing Operator Returns the right-hand value only if the left-hand side is null or undefined. So it helps you set true defaults without breaking valid falsy values like 0 or "". let count = 0; console.log(count || 10); // 10 (because 0 is falsy) console.log(count ?? 10); // 0 (because 0 is not null/undefined) ✅ || – Logical OR Operator Returns the right-hand side if the left-hand side is falsy (false, 0, "", null, undefined, NaN). It’s great for simple fallbacks - but not when 0 or an empty string are valid values. ✅ ?. – Optional Chaining Safely accesses nested properties without throwing an error. console.log(user?.profile?.email); ✅ ? : – Ternary Operator A clean one-liner for conditions: let age = 20; let status = age >= 18 ? "Adult" : "Minor"; I love how small syntax choices like "?? " vs || can make code both safer and more expressive. Feels like I leveled up my JavaScript brain today 😄 #JavaScript #TodayILearned #WebDevelopment #CodeTips #Frontend

💡 Why this JavaScript code works even without let — but you shouldn’t do it! function greet(i) { console.log("hello " + i); } for (i = 0; i < 5; i++) { greet(i); } At first glance, it looks fine — and yes, it actually runs without any error! But here’s what’s really happening 👇 🧠 Explanation: If you don’t declare a variable using let, const, or var, JavaScript (in non-strict mode) automatically creates it as a global variable named i. That’s why your code works —  but it’s not a good practice! ✅ Correct and recommended way: for (let i = 0; i < 5; i++) { greet(i); } ⚠️ Why it’s important: -Without let, i leaks into the global scope (can cause bugs later). -In 'use strict' mode, this will throw an error: i is not defined. -let keeps i limited to the loop block — safer and cleaner! 👉 In short: -It works because JavaScript is lenient. -But always use let — it’s safer, cleaner, and professional. 👩💻 Many beginners get confused when this code still works without using let! ........understand these small but important JavaScript concepts 💻✨ #JavaScript #Frontend #WebDevelopment #CodingTips #LearnToCode #Developers

🚀 Day 2 — Mastering Closures in JavaScript Today I explored one of the most powerful concepts in JavaScript — Closures. It’s amazing how a function can “remember” the variables from its outer scope even after that outer function has finished executing! 🧠 Here’s what I learned and understood today: 🔍 What is a Closure: A closure is formed when an inner function remembers and accesses variables from its outer function — even after the outer function has returned. 🧩 Lexical Scope: JavaScript uses lexical scoping — meaning, a function’s scope is determined by where it is defined, not where it’s called. ⚙️ Closure Use Cases: Used for data privacy, maintaining state, creating function factories, and managing async operations elegantly. 🔁 Closures in Loops: I learned how closures help capture the correct variable values inside loops — especially when using var, let, and asynchronous code. 🔒 Private Variables with Closures: Closures can hide data from the global scope, allowing us to create private variables and methods, just like in OOP. 📦 Module Pattern with Closures: The module pattern uses closures to bundle related functionality together, providing encapsulation and privacy — the backbone of reusable JS design. 🧮 Memory Implications: Since closures keep references to outer variables, understanding memory management is crucial to prevent leaks in long-running applications. I learn how JavaScript manages scope, memory, and data privacy behind the scenes. #JavaScript #Closures #WebDevelopment #Frontend #Day2 #Coding #LearningJourney

How JS Converts [] + {} to [object Object] —🤯 JavaScript can be weirdly magical sometimes. Ever tried this in your console? 👇 [] + {} // Output: "[object Object]" At first glance, it looks confusing — why does an empty array and an empty object become a string? Let’s decode the magic 🪄 1️⃣ + Operator in JS The + operator doesn’t just add numbers — it can also concatenate strings. 2️⃣ Type Conversion Happens! [] (empty array) → when converted to string becomes "" (empty string). {} (empty object) → when converted to string becomes "[object Object]". 3️⃣ Final Expression So JS actually does: "" + "[object Object]" → "[object Object]" ✅ Bonus twist: Try reversing it: {} + [] Now it gives 0 because {} is treated as an empty block,not an object. 🤯 JavaScript — where logic meets magic ✨ 🔹 Follow Prashansa Sinha for more fun JS mysteries and simple explanations 👩💻 #JavaScript #WebDevelopment #Coding #Frontend #JS #LearnToCode #Programming #TechCommunity #Developers #CodeNewbie #WebDev

💡Amazing JavaScript Facts Every Learner Should Know! When I started learning JavaScript, I used loops, functions, and arrays almost every day — but later I realized there are some shocking little facts hidden inside them 👀👇 1️⃣ Functions are also objects! You can assign them to variables, pass them as arguments, or even return them from another function. 👉 Example: function greet() { return "Hello"; } greet.message = "Hi from function!"; console.log(greet.message); // Hi from function! 2️⃣ You can loop through arrays in different ways — and they behave differently! 👉 for...of gives values, but for...in gives indexes! const arr = ['a', 'b', 'c']; for (let i in arr) console.log(i); // 0,1,2 for (let val of arr) console.log(val); // a,b,c 3️⃣ Arrays are special objects in disguise! That’s why typeof [] returns "object" 😄 console.log(typeof []); // "object" 4️⃣ Functions inside loops can surprise you! If you use var, all functions share the same variable; but let creates a new one each time. 👉 Small change, big difference! 5️⃣Arrays don’t always behave like “normal arrays”! const arr = [1, 2, 3]; arr[10] = 99; console.log(arr.length); // 11 😳 Yes — JavaScript fills the gap with empty slots, not undefined! 💬 Which one did you already know — and which surprised you the most? Let’s see how many JS lovers spot all 😎 #JavaScript #CodingJourney #FrontendDevelopment #DeveloperTips #LearnByDoing