Reversing an array in JavaScript: a timeless logic challenge

🔄 Day 164 of #200DaysOfCode Today, I revisited another classic JavaScript problem — removing duplicates from an array without using Set() or advanced methods. 💡 While there are modern one-liners that can handle this task in seconds, manually writing the logic helps build a deeper understanding of how arrays, loops, and conditions work together. This small challenge reinforced two key lessons: 1️⃣ Efficiency matters — Writing logic by hand makes you think about time complexity and performance. 2️⃣ Simplicity is strength — The most effective solutions are often the ones built from fundamental principles. 🔁 As developers, it’s not just about knowing shortcuts — it’s about understanding the why behind every concept. Revisiting such basic problems sharpens logical thinking and improves our ability to write cleaner, more optimized code. 🌱 Mastering the basics is not a step backward — it’s the foundation for everything advanced. #JavaScript #CodingChallenge #BackToBasics #164DaysOfCode #LearnInPublic #DeveloperMindset #WebDevelopment #ProblemSolving #CodingJourney

Day 4 of #30DaysOfJavaScript: Mastering Array Transformations Without .map() 🚀 Today’s task was about thinking beyond built-in methods by writing a custom function to transform every element of an array, similar to how .map() works in JavaScript — but doing it all manually! My solution involved iterating over the input array and applying a transformation function to each element, building up a new array with the results: What I learned today: Reinforced fundamentals of array traversal and callback functions. Understood how helpful built-in methods like .map() are—and exactly how they work under the hood. Practiced writing cleaner, modular, and reusable code. Challenging myself with these basics is already making my JavaScript much stronger! On to Day 5 🔥 Are you also on a coding challenge journey? Let’s connect and learn together! #JavaScript #CodingChallenge #WebDevelopment #LearningByDoing #LeetCode #ProblemSolving #TechCommunity

8 JavaScript topics that actually matter Been coding for a while now, these keep coming up: → Closures Functions that remember their context. Used everywhere in React hooks and callbacks. → Promises & Async/Await Writing code that waits without freezing. Essential for API calls. → Array Methods map(), filter(), reduce(). Clean data manipulation. → Event Loop How JavaScript handles async ops. Makes everything click once you get it. → Destructuring Cleaner way to pull values from objects and arrays. Saves a lot of lines. → Spread/Rest Operators Copy arrays, merge objects, handle function params. Super useful. → Prototypes & Inheritance How objects actually work under the hood. Important for interviews. → Module Systems Import/export between files. Keeps code organized. These aren't flashy. But knowing them makes everything easier. What topic gave you the most trouble when learning JS? #JavaScript #Coding #WebDevelopment #100DaysOfCode #LearnToCode #FrontendDevelopment #MERNStack #DeveloperTips

Day 5 of #30DaysOfJavaScript: Creating My Own Filter Function from Scratch! 🎯 Today, I tackled a great exercise that challenged me to build a custom filter function without using JavaScript’s built-in .filter() method. This involved iterating over an array and using a callback function to decide which elements to keep based on truthy values. Here’s a peek at the solution I wrote: Key takeaways from this challenge: Deepened my understanding of higher-order functions and callback usage. Learned how to evaluate truthy and false values in JavaScript more effectively. Gained appreciation for the power and convenience of built-in array methods by implementing one manually. This hands-on approach is helping me grasp fundamental JavaScript concepts in detail while preparing for real-world coding challenges. Excited to keep growing and solving more problems along the way! Let’s connect and share knowledge. #JavaScript #CodingChallenge #WebDevelopment #LeetCode #ArrayMethods #LearningByBuilding #DeveloperJourney

✨ Mastering JavaScript means understanding not just 𝘸𝘩𝘢𝘵 works - but 𝘸𝘩𝘺 it works. In our new blog post, “𝙁𝙧𝙤𝙢 𝙄𝙣𝙩𝙪𝙞𝙩𝙞𝙤𝙣 𝙩𝙤 𝙋𝙧𝙤𝙛𝙞𝙘𝙞𝙚𝙣𝙘𝙮: 𝙁𝙪𝙣𝙘𝙩𝙞𝙤𝙣 𝙏𝙧𝙖𝙣𝙨𝙛𝙤𝙧𝙢𝙖𝙩𝙞𝙤𝙣𝙨 𝙞𝙣 𝙅𝙖𝙫𝙖𝙎𝙘𝙧𝙞𝙥𝙩”, Anju Karanji unpacks that mindset beautifully. 💜🧠 If 𝗣𝗮𝗿𝘁 𝟮 was about chaining and composing functions, 𝗣𝗮𝗿𝘁 𝟯 dives into how functions themselves can evolve - transforming behavior, optimizing performance, and reshaping how we think about logic. ⚙️💭 Anju takes you on a journey from simple wrappers → to once-only execution patterns → to building your own memoization utility that makes code both elegant and efficient. 🧩✨ 🔍 𝗪𝗵𝗮𝘁 𝘆𝗼𝘂’𝗹𝗹 𝗹𝗲𝗮𝗿𝗻: 🎯 How higher-order functions reshape behavior 🧱 Building a once() wrapper from scratch ⚡ Implementing memoization for smarter performance 💡 When (and why) to use these transformations in real-world frontend code If you’re diving deeper into React, TypeScript, or just love exploring JavaScript patterns that scale, this post is packed with hands-on insights and aha moments. 📰 Read the full article: https://lnkd.in/dqbuHGq3 💌 Subscribe for more updates: https://lnkd.in/gDA5t-yP #FrontendQueens #WomenInTech #JavaScript #FunctionalProgramming #React #WebDevelopment #TechBlog

Day 8 of #30DaysOfJavaScript: Counting Function Arguments with Rest Parameters! 🎯 Solved an interesting and fundamental problem today—writing a function that returns the count of arguments passed to it. This challenge sharpened my understanding of JavaScript’s rest parameters and how they simplify working with variable numbers of arguments. Here’s my solution: javascript var argumentsLength = function(...args) { return args.length; }; Key insights gained: rest parameters allow capturing an indefinite number of arguments in an array-like structure. This approach is cleaner and more intuitive than using the legacy arguments object. Mastering these basics is essential for writing flexible, reusable functions in JavaScript. Excited to keep progressing on this learning journey and uncovering more of JavaScript’s powerful features every day! If you’re also working through JavaScript fundamentals or coding challenges, let’s connect and share tips. #JavaScript #RestParameters #CodingChallenge #LeetCode #WebDev #LearningByDoing #SoftwareDevelopment

🚀 Starting My JavaScript Revision Journey! Body: Yesterday, I went back to the basics of JavaScript to strengthen my foundation. Here’s what I revised: 🟡 Variables — var, let, and const and when to use them 🟡 Scope — Global variables (accessible everywhere) — Local variables (accessible within a function/block) 🟡 Data Types — Primitive: string, number, boolean, null, undefined, symbol, bigint — Non-Primitive: objects, arrays, functions It’s amazing how revisiting fundamentals clears a lot of confusion! What JavaScript concept took you time to understand when starting out? #JavaScript #BackendDevelopment #LearningJourney #Coding

✨ Day 10 — How JavaScript Code Works Behind The Scenes! ✨ Today, I went beyond the syntax to understand how JavaScript actually executes code behind the scenes — the hidden engine that makes everything run! ⚙️💻 I began by learning about the Execution Context — the environment where JavaScript code runs — and how it’s created in two key phases: Memory Allocation and Execution. 🧠 Then, I explored how Function Call Execution Contexts are formed and managed using the Call Stack and Heap, helping me visualize how JavaScript handles both primitive values and objects in memory. 📚 I also dived deep into Hoisting, understanding why variables declared with var show up as undefined, and how let & const behave differently due to the Temporal Dead Zone. ⚡ Finally, I wrapped up by studying Function Expressions, Hoisting mechanics, and how the JavaScript Interpreter runs code step by step — truly connecting all the dots behind execution! 🚀 This session gave me a crystal-clear understanding of what happens before a single line of JavaScript runs — the real “magic” behind the language! ✨ #Day10 #JavaScript #WebDevelopment #100DaysOfCode #LearningEveryday #CodingJourney #FrontendDevelopment #Hoisting #ExecutionContext #JSBehindTheScenes

🎯 Day 1 — Deep Dive into JavaScript Fundamentals Today I started my journey to strengthen the core of JavaScript, and it’s amazing how much depth lies behind the basics! 🚀 Here’s what I learned today: 🧩 Primitive vs Reference Types 🧠 typeof Operator Behavior ⚖️ Difference Between null and undefined 🪄 var vs let vs const and Variable Hoisting ⛔ Temporal Dead Zone (TDZ) 📦 Block Scope vs Function Scope 🔄 Implicit vs Explicit Type Conversion ✅ Truthy and Falsy Values 🔍 Comparison Operators & Type Coercion 🔧 Object to Primitive Conversion (valueOf, toString) 👇 Understanding this in Different Contexts: Global Context Object Methods Constructor Functions Arrow Functions Event Handlers Explicit & Implicit Bindings new Keyword Every topic connected like a puzzle — learning how JavaScript really works behind the scenes makes it even more exciting to code. 💻 #JavaScript #WebDevelopment #Day1 #LearningJourney #Frontend #Coding