JavaScript Throttling: Limiting Function Calls for Performance

#Interview Prep JavaScript array.sort() array.sort() is a JavaScript method used to arrange array elements in a specific order. By providing a compare function, we can control whether the sorting is ascending or descending. Example array Explanation ✅ arr = [6, 2, 4] arr.sort((a, b) => { return a - b; }) How TWO elements are chosen (visual angle) [ 6 , 2 , 4 ] ↑ ↑ a b JS picks neighbor elements a = 6 b = 2 Compare: 6 - 2 = 4 → swap After swap: [ 2 , 6 , 4 ] ▶️ Second pick [ 2 , 6 , 4 ] ↑ ↑ a b Now picks: a = 6 b = 4 Compare: 6 - 4 = 2 → swap After swap: [ 2 , 4 , 6 ] ▶️ Third (check) [ 2 , 4 , 6 ] ↑ ↑ a b Compare: 2 - 4 = -2 → no swap Array stays same ✅ JS always picks TWO values Assigns: first value → a second value → b It compares adjacent elements Moves forward like a sliding window [ a , b ] → compare → swap / no swap → move right 🔄 Same idea for descending arr.sort((a,b) => { return b - a }) [ 6 , 2 , 4 ] ↑ ↑ a b 2 - 6 = -4 → no swap → bigger stays first Result: [ 6 , 4 , 2 ] #JavaScript #Frontend #WebDevelopment #CodingTips #LinkedInLearning #ArrayMethods #Interview

Day 2/50 – JavaScript Interview Question? Question: What's the difference between call(), apply(), and bind()? Simple Answer: All three methods allow you to set the this context explicitly. call() invokes the function immediately with arguments passed individually, apply() invokes it with arguments as an array, and bind() returns a new function with this bound permanently. 🧠 Why it matters in real projects: These methods are crucial when working with object methods, event handlers, and callbacks where you need precise control over the this context. They're especially important in React class components and when borrowing methods between objects. 💡 One common mistake: Using bind() and expecting the function to execute immediately. Remember, bind() returns a new function—it doesn't invoke it! 📌 Bonus: const person = { name: 'Alice' }; function greet(greeting) { console.log(`${greeting}, ${this.name}`); } greet.call(person, 'Hello'); // "Hello, Alice" greet.apply(person, ['Hi']); // "Hi, Alice" const boundGreet = greet.bind(person); boundGreet('Hey'); // "Hey, Alice" #JavaScript #WebDevelopment #Frontend #LearnInPublic #InterviewQuestions #Programming #TechInterviews

Day 10/365 – JavaScript Interview Question 🔥 const fun = () => { try { return 1; } finally { return 3; } }; console.log(fun()); Output: 3 Why? The finally block always executes and overrides any return from try or catch. 👉 Interview Tip: If finally has a return, it will win—always. #javascript #interview #frontend #js #webdevelopment #jsinterview

COMPARISON OPERATORS (INTERVIEW FAVORITE) JavaScript comparison puzzle 👇 ✅ Output: true true false 🧠 Why this output comes? (Step-by-Step) 1️⃣ [] == false • [] → "" (toPrimitive) • "" → 0 • false → 0 ✅ 0 == 0 → true 2️⃣ [] == ![] • ![] → false (because objects are truthy) • Same conversion as above ✅ true 3️⃣ {} == false • {} → "[object Object]" • Converted to NaN • false → 0 ❌ NaN == 0 → false #JavaScript #InterviewQuestions #FrontendDeveloper #MERNStack #ReactJS #WebDevelopment

🤔 JavaScript behaves the way it does for a reason. Type coercion exists so different values can interact without throwing errors all the time. But if you don’t know the rules, it can feel unpredictable. 🧠 JavaScript interview question What is type coercion in JavaScript? ✅ Short answer • JavaScript automatically converts values between types when needed • This can happen implicitly or explicitly • Operators decide how and when conversion happens 🔍 A bit more detail • Implicit coercion Happens during operations like +, -, ==, or Boolean checks • Explicit coercion You force conversion using Number(), String(), Boolean() • The + operator If one side is a string, it concatenates Otherwise, it tries numeric addition • Equality == Tries to convert both sides to a common type before comparing "10" + 5 // "105" "10" - 5 // 5 0 == false // true "" == 0 // true null == undefined // true ⚠️ Small but important detail Only the empty string is false when converted to Boolean. "0" is a non empty string, so it is true. Boolean("") // false Boolean("0") // true I’m sharing one JavaScript interview style question every day so we can all build stronger fundamentals together. #javascript #frontend #webdevelopment #interviewprep

JavaScript fundamentals like closures, promises, async/await, the event loop, hoisting, and more are the backbone of a strong frontend developer. Mastering these concepts doesn’t just help in interviews it makes you a better problem solver and a more confident developer. 🚀 Keep learning. Keep building. #JavaScript #FrontendDevelopment #WebDevelopment #LearnJavaScript #JavaScriptConcepts #AsyncAwait #Promises #EventLoop #GrowAsDeveloper

There are plenty of JavaScript fundamentals that a lot of developers don’t know about, but they are the backbone of JS, and it is imperative for any senior developer to know them by heart.

Day 5/365 - JavaScript Interview Question🔥 const obj1 = { value: 10 }; const obj2 = { value: 10 }; console.log(obj1 == obj2); // false console.log(obj1 === obj2); // false Why is the output false for both? In javascript objects are compared by reference, not by value. obj1 and obj2 are stored in different memory locations, so even though they look identical, they are not the same object. So: == → checks reference for objects === → also checks reference (and type) Since both references are different → result is false. 🔥This is one of the most common JavaScript interview traps for frontend developers. #javascript #frontend #coding #jsinterview #interview #365daysofjs #js

JavaScript Interview Question: Que: What is difference between == and === ? Ans: == (loose equality) compares values after converting them to a common type (type coercion), while === (strict equality) compares both the value and the data type without any conversion, returning false if types differ, making it stricter and generally preferred for predictable code, especially in JavaScript. For instance, 5 == '5'is true (string coerced to number), but 5 === '5' is false (different types). == (Loose Equality) * Compares: Value only, after type coercion. * Behavior: Attempts to convert operands to a common type before comparing. * Example: 42 == '42' results in truebecause '42' is converted to the number 42. * Common Cases: null == undefined is true, but null === undefined is false. === (Strict Equality) * Compares: Both value and data type. * Behavior: No type conversion occurs; if types differ, it immediately returns false. * Example: 42 === '42' results in falsebecause one is a number and the other a string. #javascript #doubleEqualsTo #tripleEqualsTo #conceptsOfJavaScript #freeLancer #reactJs #frontend #softwareDeveloper #nodeJs #backend #fullStack #interviewQuestion

Day 20/50 – JavaScript Interview Question? Question: What is prototypal inheritance in JavaScript? Simple Answer: Prototypal inheritance is JavaScript's mechanism for objects to inherit properties and methods from other objects through the prototype chain. When you access a property, JavaScript first checks the object itself, then walks up the prototype chain until it finds the property or reaches null. 🧠 Why it matters in real projects: Understanding prototypes is fundamental to JavaScript's object model. It's how classes work under the hood, how built-in methods like Array.prototype.map() are available, and how you can extend native objects or create efficient object hierarchies. 💡 One common mistake: Confusing __proto__ (the actual link) with prototype (the property on constructor functions). Also, modifying built-in prototypes like Array.prototype in production code is considered a bad practice. 📌 Bonus: // Constructor function function Person(name) { this.name = name; } // Add method to prototype (shared by all instances) Person.prototype.greet = function() { return `Hello, I'm ${this.name}`; }; const alice = new Person('Alice'); alice.greet(); // "Hello, I'm Alice" // Prototype chain alice.hasOwnProperty('name'); // true (own property) alice.hasOwnProperty('greet'); // false (inherited) alice.__proto__ === Person.prototype; // true // Modern ES6 class syntax (same prototype underneath) class Employee extends Person { constructor(name, title) { super(name); this.title = title; } } const bob = new Employee('Bob', 'Developer'); console.log(bob.greet()); // Inherits from Person #JavaScript #WebDevelopment #Frontend #LearnInPublic #InterviewQuestions #Programming #TechInterviews #Prototypes #OOP