JavaScript Array Methods: Slice vs Splice Behavior

🚀 Day 6 – Daily Tech Dose (JavaScript) 💡 Today’s Topic: JavaScript Hoisting Quick Question 👇 What will be the output? console.log(a); var a = 10; ✅ Answer: undefined 🧠 Why? • JavaScript hoists variable declarations (not initializations). • var a is moved to the top, but = 10 stays where it is. • So at console.log(a), a exists but has no value yet → undefined. ⚠️ Try the same with let or const and you’ll get a ReferenceError. 💬 Interview Tip • Hoisting applies to functions too (function declarations are fully hoisted). • Prefer let / const to avoid confusing bugs. ⸻ 🔖 Hashtags #JavaScript #WebDevelopment #Frontend #Programming #CodingInterview #LearnJS #TechDaily #100DaysOfCode #VivekVishwakarma Want Day 7 next? 😄

🧠 This JavaScript Function Call Looks Normal… But Think Carefully 👀 Most people focus on the value. Very few notice how the function is called 😄 function show() { return "Hello"; } console.log(show); console.log(show()); Same function. Two console logs. Completely different outputs. 🤔 Why this question is interesting Tests function reference vs function execution Very common beginner confusion Asked indirectly in interviews Looks simple → answers vary a lot Almost everyone comments confidently 💬 Your Turn Comment your answers like this 👇 Line 1 → Line 2 → Why? → ⚠️ Don’t run the code. Answer based on understanding. I Will post the correct output + simple explanation in the evening. 📌 This post is to understand JavaScript behavior, not to trick anyone. #JavaScript #LearnJS #FrontendDevelopment #CodingInterview #TechWithVeera #WebDevelopment

⚡ There’s an invisible engine inside JavaScript Quietly deciding what runs first and what has to wait. That engine is the Event Loop. Most developers use promises, async/await, and setTimeout every day. But very few actually understand how the execution order is decided. That’s why: Logs appear in the “wrong” order Async bugs feel random Event loop questions confuse even experienced devs In Part 6 of the JavaScript Confusion Series, I break down the Event Loop with a simple visual mental model— so you understand it once, and never forget it. Read it here: https://lnkd.in/d_KnvPeV 💬 Comment “LOOP” and I’ll send the next part. 🔖 Save it for interview prep. 🔁 Share with a developer who still fears async code. #javascript #webdevelopment #frontend #programming #reactjs #learnjavascript #softwareengineering

A single typo broke my entire progress bar today… and that’s how I revised JavaScript fundamentals. I’m starting to learn in public to stay accountable and consistent. Today I focused on strengthening my JavaScript fundamentals by building two small but practical implementations: 🔹 Email & Password Form Validator •Validated email using regex •Added password length & basic constraints •Prevented form submission on invalid input •Displayed real-time error messages 🔹 Download Progress Simulation •Used setInterval() to simulate progress •Dynamically updated width using DOM manipulation •Updated percentage text in real time •Controlled execution with clearInterval() While building this, I made a small mistake — wrote Style instead of style. That one typo stopped the entire progress bar. A good reminder that: JavaScript is case-sensitive. Debugging is part of the learning process. Strong fundamentals matter. Building step by step toward becoming a better Frontend Developer. What JavaScript concept took you the longest to understand? #JavaScript #FrontendDevelopment #LearnInPublic #WebDevelopment #Consistency

Intercept, Control, Reflect: Power Tools Hidden in JavaScript 🪞 Learned about the Proxy pattern in JavaScript and how it works closely with the Reflect object. Explored how Proxies allow interception of operations like: -Property access -Assignment -Validation -Logging or access control And how Reflect provides a clean, predictable way to forward those operations while preserving default behavior. Key takeaway: Proxies are powerful but sharp tools. They enable elegant abstractions, yet can hurt readability and debugging if overused. Reflect helps keep proxy logic explicit and intention-revealing. Understanding these internals deepens how JS really works under the hood. #JavaScript #DesignPatterns #ProxyPattern #FrontendDevelopment #WebDevelopment #LearnInPublic

⚡ JavaScript Event Loop — The Concept That Makes JS Feel “Fast.” Ever wondered how JavaScript handles multiple tasks even though it’s single-threaded? Here are the key things to understand: 🧩 Call Stack Runs your code line by line (one task at a time). 🌐 Web APIs (Browser) Handles slow tasks like setTimeout, fetch, DOM events, etc. 📥 Callback Queue (Task Queue) Stores callbacks waiting to run after the stack is empty. ⚡ Job Queue (Microtask Queue) Promises go here — and it runs before the callback queue ✅ 🔁 Event Loop Continuously checks if the call stack is empty, then pushes queued tasks back to execution. Understanding this helps you: ✅ predict async output order ✅ fix “why is this logging first?” confusion ✅ write better Promise/async-await code ✅ understand sequence vs parallel vs race I wrote a beginner-friendly breakdown with examples. Link in the comments 👇 #JavaScript #WebDevelopment #Frontend #Programming #LearnJavaScript #SoftwareEngineering #Async #EventLoop

🧠 Most JavaScript devs get this wrong 👀 Especially those with 1–2 years of experience. No frameworks. No libraries. Just core JavaScript fundamentals. 🧩 Output-Based Question (Hoisting) var a = 10; (function () { console.log(a); var a = 20; })(); ❓ What will be printed? (Don’t run the code ❌) A. 10 B. 20 C. undefined D. Throws an error 👇 Drop your answer in the comments Why this matters JavaScript doesn’t behave the way we expect — it behaves the way it’s defined. This question tests: hoisting variable scope shadowing how var really works When fundamentals aren’t clear: we predict the wrong output bugs feel random debugging turns into guesswork Good developers don’t just write code. They understand the language. 💡 I’ll pin the explanation after a few answers. #JavaScript #CodingFundamentals #Hoisting #VariableScope #JavaScriptTips #DeveloperEducation #CodeDebugging #ProgrammingMistakes #LearnToCode #SoftwareDevelopment

Most developers don’t struggle with JavaScript. They struggle with this. Same function. Different call. Completely different value. That’s why: Code works in one place Breaks in another And interviews get awkward 😅 In Part 8 of the JavaScript Confusion Series, I break down this into 3 simple rules you’ll never forget. No textbook theory. Just a clean mental model. 👉 Read it here: https://lnkd.in/gvc_nG37 💬 Comment THIS if you’ve ever been confused by it. 🔖 Save it for interviews. 🔁 Share with a developer who still avoids this. #javascript #webdevelopment #frontend #programming #reactjs #learnjavascript

Day 6/30 – Build Your Own Filter Function in JavaScript 🧠 | No Array.filter() 🧠 Problem: Implement a filtering function without using Array.filter(). The function should: Take an array arr Use a function fn(value, index) Return a new array containing only truthy results ➡️ filteredArr includes elements where Boolean(fn(arr[i], i)) === true ✨ This challenge helped me deeply understand: Truthy vs Falsy values Conditional array processing How JavaScript array methods work internally Rebuilding core methods = stronger fundamentals 💪 💬 Share your approach or optimize mine in the comments! #JavaScript #30DaysOfJavaScript #CodingChallenge #ArrayFilter #JSLogic #LeetCode #WebDevelopment #LearnToCode #CodeEveryday #DeveloperJourney #Programming #TechCommunity JavaScript custom filter Implement filter without filter Truthy and falsy JavaScript JavaScript array filtering logic LeetCode JavaScript solution JS interview preparation Beginner JavaScript practice Daily coding challenge

🧠 99% of JavaScript devs fall into this trap 👀 (Even with years of experience) No frameworks. No libraries. Just core JavaScript fundamentals. 🧩 Output-Based Question (parseInt + map) console.log(["1", "2", "3"].map(parseInt)); ❓ What will be printed? ❌ Don’t run the code 🧠 Think like the JavaScript engine A. [1, 2, 3] B. [1, NaN, NaN] C. [1, 2, NaN] D. Throws an error 👇 Drop ONE option in the comments Why this matters Most developers assume: parseInt only takes one argument map passes only the value Both assumptions are wrong. When fundamentals aren’t clear: bugs slip into production data parsing breaks silently debugging turns into guesswork Strong JavaScript developers don’t guess. They understand how functions are actually called. 💡 I’ll pin the full explanation after a few answers. #JavaScript #JSFundamentals #CodingInterview #WebDevelopment #FrontendDeveloper #FullStackDeveloper #DevelopersOfLinkedIn #DevCommunity #JavaScriptTricks #VibeCode