Top 311 JavaScript interview questions

function reverseString(text) {
  return text.split("").reverse().join("");
}

function reverseSpread(text) {
  return [...text].reverse().join("");
}

reverseString("hello"); // "olleh"

function reverseNumber(n) {
  const sign = Math.sign(n);
  const reversed = Number(String(Math.abs(n)).split("").reverse().join(""));
  return sign * reversed;
}

function reverseNumberMath(n) {
  const sign = n < 0 ? -1 : 1;
  let x = Math.abs(n);
  let out = 0;
  while (x > 0) {
    out = out * 10 + (x % 10);
    x = Math.floor(x / 10);
  }
  return sign * out;
}

reverseNumber(1234); // 4321
reverseNumber(-90);  // -9

function isPalindrome(text) {
  const clean = text.toLowerCase().replace(/[^a-z0-9]/g, "");
  return clean === [...clean].reverse().join("");
}

function isPalindromePointers(text) {
  const s = text.toLowerCase();
  let i = 0;
  let j = s.length - 1;
  while (i < j) {
    if (s[i] !== s[j]) return false;
    i++;
    j--;
  }
  return true;
}

isPalindrome("Level"); // true
isPalindrome("js");    // false

function isPalindromeNumber(n) {
  if (n < 0) return false;
  return n === Number(String(n).split("").reverse().join(""));
}

isPalindromeNumber(121);  // true
isPalindromeNumber(-121); // false

function isAnagram(a, b) {
  const norm = (s) => s.toLowerCase().split("").sort().join("");
  return norm(a) === norm(b);
}

function isAnagramCount(a, b) {
  if (a.length !== b.length) return false;
  const counts = new Map();
  for (const ch of a.toLowerCase()) counts.set(ch, (counts.get(ch) ?? 0) + 1);
  for (const ch of b.toLowerCase()) {
    const next = (counts.get(ch) ?? 0) - 1;
    if (next < 0) return false;
    counts.set(ch, next);
  }
  return true;
}

isAnagram("listen", "silent"); // true

function fizzBuzz(n) {
  if (n % 15 === 0) return "FizzBuzz";
  if (n % 3 === 0) return "Fizz";
  if (n % 5 === 0) return "Buzz";
  return n;
}

for (let i = 1; i <= 15; i++) console.log(fizzBuzz(i));

function factorial(n) {
  let result = 1;
  for (let i = 2; i <= n; i++) result *= i;
  return result;
}

function factorialRec(n) {
  if (n <= 1) return 1;
  return n * factorialRec(n - 1);
}

factorial(5); // 120

function fib(n) {
  if (n <= 1) return n;
  let a = 0;
  let b = 1;
  for (let i = 2; i <= n; i++) {
    const next = a + b;
    a = b;
    b = next;
  }
  return b;
}

fib(7); // 13

function countVowels(text) {
  return [...text.toLowerCase()].filter((ch) => "aeiou".includes(ch)).length;
}

countVowels("JavaScript"); // 3

function max(arr) {
  if (arr.length === 0) return undefined;
  let best = arr[0];
  for (const n of arr) if (n > best) best = n;
  return best;
}

max([3, 9, 2]); // 9

function unique(arr) {
  return [...new Set(arr)];
}

unique([1, 2, 2, 3, 1]); // [1, 2, 3]

function flatten(arr) {
  return arr.flat(Infinity);
}

function flattenRec(arr) {
  return arr.reduce(
    (out, item) => out.concat(Array.isArray(item) ? flattenRec(item) : item),
    [],
  );
}

flatten([1, [2, [3, 4]], 5]); // [1, 2, 3, 4, 5]

function twoSum(nums, target) {
  const seen = new Map();
  for (let i = 0; i < nums.length; i++) {
    const need = target - nums[i];
    if (seen.has(need)) return [seen.get(need), i];
    seen.set(nums[i], i);
  }
}

twoSum([2, 7, 11, 15], 9); // [0, 1]

function firstUnique(text) {
  const counts = new Map();
  for (const ch of text) counts.set(ch, (counts.get(ch) ?? 0) + 1);
  for (const ch of text) if (counts.get(ch) === 1) return ch;
}

firstUnique("aabbcde"); // "c"

function titleCase(text) {
  return text
    .split(" ")
    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
    .join(" ");
}

titleCase("learn javascript now"); // "Learn Javascript Now"

function frequencies(text) {
  const map = new Map();
  for (const ch of text) map.set(ch, (map.get(ch) ?? 0) + 1);
  return map;
}

function reverseWordOrder(text) {
  return text.trim().split(/\s+/).reverse().join(" ");
}

function reverseEachWord(text) {
  return text
    .split(" ")
    .map((word) => [...word].reverse().join(""))
    .join(" ");
}

reverseWordOrder("I love JS"); // "JS love I"

function isPrime(n) {
  if (n < 2) return false;
  if (n === 2) return true;
  if (n % 2 === 0) return false;
  for (let d = 3; d * d <= n; d += 2) {
    if (n % d === 0) return false;
  }
  return true;
}

function sumDigits(n) {
  let sum = 0;
  let x = Math.abs(n);
  while (x > 0) {
    sum += x % 10;
    x = Math.floor(x / 10);
  }
  return sum;
}

sumDigits(405); // 9

function missingNumber(nums) {
  const n = nums.length;
  const expected = (n * (n + 1)) / 2;
  const actual = nums.reduce((a, b) => a + b, 0);
  return expected - actual;
}

function chunk(arr, size) {
  const out = [];
  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
  return out;
}

chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]

function rotateRight(arr, k) {
  const n = arr.length;
  if (n === 0) return arr;
  k %= n;
  return arr.slice(-k).concat(arr.slice(0, -k));
}

rotateRight([1, 2, 3, 4, 5], 2); // [4, 5, 1, 2, 3]

function secondLargest(arr) {
  let first = -Infinity;
  let second = -Infinity;
  for (const n of arr) {
    if (n > first) {
      second = first;
      first = n;
    } else if (n < first && n > second) {
      second = n;
    }
  }
  return second === -Infinity ? undefined : second;
}

function isBalanced(text) {
  const pairs = { ")": "(", "]": "[", "}": "{" };
  const stack = [];
  for (const ch of text) {
    if ("([{".includes(ch)) stack.push(ch);
    else if (pairs[ch]) {
      if (stack.pop() !== pairs[ch]) return false;
    }
  }
  return stack.length === 0;
}

isBalanced("{[()]}"); // true

const copy = structuredClone({ user: { name: "Ada" }, tags: [1, 2] });

function deepClone(value, seen = new WeakMap()) {
  if (value === null || typeof value !== "object") return value;
  if (seen.has(value)) return seen.get(value);
  const out = Array.isArray(value) ? [] : {};
  seen.set(value, out);
  for (const key of Object.keys(value)) out[key] = deepClone(value[key], seen);
  return out;
}

function debounce(fn, ms) {
  let timer;
  return function (...args) {
    clearTimeout(timer);
    timer = setTimeout(() => fn.apply(this, args), ms);
  };
}

const onType = debounce((q) => console.log("search", q), 300);

function throttle(fn, ms) {
  let last = 0;
  return function (...args) {
    const now = Date.now();
    if (now - last >= ms) {
      last = now;
      fn.apply(this, args);
    }
  };
}

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) return fn.apply(this, args);
    return (...rest) => curried(...args, ...rest);
  };
}

const add = (a, b, c) => a + b + c;
const curriedAdd = curry(add);
curriedAdd(1)(2)(3); // 6

Function.prototype.myBind = function (thisArg, ...boundArgs) {
  const fn = this;
  return function (...args) {
    return fn.apply(thisArg, [...boundArgs, ...args]);
  };
};

function greet(hi) {
  return hi + " " + this.name;
}
greet.myBind({ name: "Ada" }, "Hi")(); // "Hi Ada"

function map(arr, fn) {
  const out = [];
  for (let i = 0; i < arr.length; i++) {
    if (i in arr) out.push(fn(arr[i], i, arr));
  }
  return out;
}

map([1, 2, 3], (n) => n * 2); // [2, 4, 6]

function filter(arr, fn) {
  const out = [];
  for (let i = 0; i < arr.length; i++) {
    if (i in arr && fn(arr[i], i, arr)) out.push(arr[i]);
  }
  return out;
}

function reduce(arr, fn, initial) {
  let i = 0;
  let acc = initial;
  if (arguments.length < 3) {
    if (arr.length === 0) throw new TypeError("Reduce of empty array");
    acc = arr[0];
    i = 1;
  }
  for (; i < arr.length; i++) acc = fn(acc, arr[i], i, arr);
  return acc;
}

function promiseAll(items) {
  return new Promise((resolve, reject) => {
    const list = [...items];
    if (list.length === 0) return resolve([]);
    const results = [];
    let left = list.length;
    list.forEach((item, i) => {
      Promise.resolve(item).then((value) => {
        results[i] = value;
        left -= 1;
        if (left === 0) resolve(results);
      }, reject);
    });
  });
}

function binarySearch(arr, target) {
  let lo = 0;
  let hi = arr.length - 1;
  while (lo <= hi) {
    const mid = Math.floor((lo + hi) / 2);
    if (arr[mid] === target) return mid;
    if (arr[mid] < target) lo = mid + 1;
    else hi = mid - 1;
  }
  return -1;
}

function bubbleSort(arr) {
  const a = [...arr];
  for (let i = 0; i < a.length; i++) {
    for (let j = 0; j < a.length - 1 - i; j++) {
      if (a[j] > a[j + 1]) [a[j], a[j + 1]] = [a[j + 1], a[j]];
    }
  }
  return a;
}

let a = 3;
let b = 7;
[a, b] = [b, a];
// a === 7, b === 3

function gcd(a, b) {
  a = Math.abs(a);
  b = Math.abs(b);
  while (b) [a, b] = [b, a % b];
  return a;
}

function lcm(a, b) {
  return Math.abs(a * b) / gcd(a, b);
}

function isArmstrong(n) {
  const digits = String(n).split("").map(Number);
  const p = digits.length;
  const sum = digits.reduce((acc, d) => acc + d ** p, 0);
  return sum === n;
}

function intersection(a, b) {
  const setB = new Set(b);
  return [...new Set(a.filter((item) => setB.has(item)))];
}

function mergeSorted(a, b) {
  const out = [];
  let i = 0;
  let j = 0;
  while (i < a.length && j < b.length) {
    if (a[i] <= b[j]) out.push(a[i++]);
    else out.push(b[j++]);
  }
  return out.concat(a.slice(i), b.slice(j));
}

function longestWord(text) {
  return text.split(" ").reduce((best, word) => (word.length > best.length ? word : best), "");
}

longestWord("a lovely javascript"); // "javascript"

function count(arr, value) {
  return arr.reduce((n, item) => n + (Object.is(item, value) ? 1 : 0), 0);
}

function shuffle(arr) {
  const a = [...arr];
  for (let i = a.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [a[i], a[j]] = [a[j], a[i]];
  }
  return a;
}

function memoize(fn) {
  const cache = new Map();
  return function (...args) {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const value = fn.apply(this, args);
    cache.set(key, value);
    return value;
  };
}

function delay(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function demo() {
  await delay(200);
  console.log("later");
}

async function retry(fn, attempts = 3) {
  let lastError;
  for (let i = 0; i < attempts; i++) {
    try {
      return await fn();
    } catch (err) {
      lastError = err;
    }
  }
  throw lastError;
}

function groupBy(arr, key) {
  return arr.reduce((acc, item) => {
    const k = item[key];
    (acc[k] ??= []).push(item);
    return acc;
  }, {});
}

function deepEqual(a, b) {
  if (Object.is(a, b)) return true;
  if (typeof a !== "object" || typeof b !== "object" || !a || !b) return false;
  const keysA = Object.keys(a);
  const keysB = Object.keys(b);
  if (keysA.length !== keysB.length) return false;
  return keysA.every((key) => deepEqual(a[key], b[key]));
}

function range(start, end) {
  const out = [];
  for (let n = start; n <= end; n++) out.push(n);
  return out;
}

typeof "Ada";          // "string"
typeof 42;             // "number"
typeof 10n;            // "bigint"
typeof true;           // "boolean"
typeof undefined;      // "undefined"
typeof Symbol("id");   // "symbol"
typeof null;           // "object"  ← historic bug
typeof [];             // "object"
typeof function () {}; // "function"

"hi".length; // 2 — engine briefly boxes the primitive as a String object

let a = 10;
let b = a;
b = 20;
console.log(a, b); // 10 20  — copied by value

const user = { name: "Ada" };
const alias = user;
alias.name = "Bea";
console.log(user.name); // "Bea" — same object

function rename(obj) {
  obj.name = "Cara";   // mutates the caller's object
  obj = { name: "Dee" }; // rebinding does not
}
rename(user);
console.log(user.name); // "Cara"

typeof [];            // "object"
Array.isArray([]);    // true
typeof null;          // "object"
null === null;        // true — check null this way
typeof new Date();    // "object"
new Date() instanceof Date; // true

typeof notDeclared;   // "undefined" (does not throw)

let score;                 // undefined
const user = { city: null }; // intentional empty

function greet(name) {
  return name ?? "friend";
}
greet();          // "friend"
greet(undefined); // "friend"
greet(null);      // "friend"
greet("");        // ""

JSON.stringify({ a: undefined, b: null }); // '{"b":null}'

function demo() {
  if (true) {
    var hidden = 1;
    let block = 2;
    const frozen = 3;
  }
  console.log(hidden); // 1 — function scoped
  // console.log(block); // ReferenceError
}

const user = { name: "Ada" };
user.name = "Bea";     // ok — mutation
// user = {};          // TypeError — reassignment

console.log(a); // undefined
var a = 1;

console.log(add(2, 3)); // 5 — declaration is hoisted
function add(x, y) {
  return x + y;
}

// console.log(n); // ReferenceError (TDZ)
let n = 10;

// double(2); // TypeError: double is not a function
const double = function (x) {
  return x * 2;
};

{
  // console.log(count); // ReferenceError: cannot access before initialization
  let count = 0;
  console.log(count); // 0
}

console.log(typeof missing); // "undefined" — undeclared
{
  // console.log(typeof boxed); // ReferenceError — TDZ, not undeclared
  let boxed = 1;
}

5 == "5";   // true  — coerced
5 === "5";  // false — different types

null == undefined;  // true
null === undefined; // false

NaN === NaN;        // false
Object.is(NaN, NaN); // true
Object.is(0, -0);    // false
0 === -0;            // true

"2" + 2;   // "22"
"2" * 3;   // 6
true + 1;  // 2
Number("08"); // 8
Number("10px"); // NaN
Boolean("");  // false
!!"Ada";      // true

Boolean(0);          // false
Boolean("");         // false
Boolean(null);       // false
Boolean([]);         // true
Boolean("0");        // true
Boolean(new Boolean(false)); // true — it's an object

const items = [];
if (items) console.log("runs even when empty");
if (items.length) console.log("use length instead");

Number("oops");     // NaN
0 / 0;              // NaN
NaN === NaN;        // false
Number.isNaN(NaN);  // true
Number.isNaN("foo"); // false
isNaN("foo");        // true — coerces first
Number.isFinite(10); // true
Number.isFinite(NaN); // false

1 / 0;                    // Infinity
-1 / 0;                   // -Infinity
Number.isFinite(1 / 0);   // false
JSON.stringify(Infinity); // "null"

let best = -Infinity;
for (const n of [3, 9, 2]) best = Math.max(best, n);
console.log(best); // 9

function bumpNumber(n) {
  n = n + 1;
}
let score = 10;
bumpNumber(score);
console.log(score); // 10 — primitive copy

function bumpUser(user) {
  user.score += 1;
}
const player = { score: 10 };
bumpUser(player);
console.log(player.score); // 11 — same object, mutated

function replaceUser(user) {
  user = { score: 0 };
}
replaceUser(player);
console.log(player.score); // 11 — reassignment stayed local

const original = { user: { name: "Ada" }, tags: ["js"] };

// new object, same nested refs (shallow)
const shallow = { ...original, tags: [...original.tags, "css"] };

// deep copy of data
const deep = structuredClone(original);
deep.user.name = "Bea";
console.log(original.user.name); // "Ada"

const frozen = Object.freeze({ n: 1, nested: { n: 2 } });
// frozen.n = 5;           // throws in strict mode
frozen.nested.n = 9;       // still mutates — freeze is shallow

"use strict";

function demo() {
  // x = 1; // ReferenceError — no accidental global
  console.log(this); // undefined, not window
}

const obj = {};
Object.defineProperty(obj, "id", { value: 1, writable: false });
// obj.id = 2; // TypeError in strict mode (silent fail in sloppy)

demo();

globalThis.setTimeout; // works in browser and Node
globalThis.JSON.stringify({ ok: true });

// avoid this:
// window.appData = {};

const app = { version: 1 }; // keep your state in a module instead

const name = "Ada";
const score = 12;
const msg = `Hello, ${name}. Score: ${score}`;
// "Hello, Ada. Score: 12"

const html = `
<ul>
  <li>${name}</li>
</ul>
`;

console.log(String.raw`C:\temp\file`); // keeps backslashes

"2" + 2;     // "22"
2 + 2;       // 4
+"2" + 2;    // 4
Number("2") + 2; // 4
[] + {};     // "[object Object]"
true + true; // 2

const user = { profile: { city: "Pune" } };
user.profile?.city;     // "Pune"
user.address?.city;     // undefined — no throw
user.save?.();          // undefined if save missing
user.tags?.[0];         // undefined

const city = user.address?.city ?? "Unknown";

0 || 10;   // 10 — 0 is falsy
0 ?? 10;   // 0  — 0 is not nullish
"" || "n/a"; // "n/a"
"" ?? "n/a"; // ""

const page = 0;
const current = page ?? 1; // 0
const fallback = page || 1; // 1 — wrong if 0 is valid

const name = "" || "guest"; // "guest"
const first = "Ada" && "Lovelace"; // "Lovelace"

const user = { admin: true };
user.admin && console.log("show admin tools");

const settings = { volume: 0 };
settings.volume || 5;  // 5 — bug if 0 is allowed
settings.volume ?? 5;  // 0

function label(status) {
  switch (status) {
    case "ok":
      return "All good";
    case "warn":
    case "info":
      return "Check logs"; // fall-through
    default:
      return "Unknown";
  }
}

label("warn"); // "Check logs"
label("nope"); // "Unknown"

const nums = [10, 20, 30];

for (let i = 0; i < nums.length; i++) console.log(i, nums[i]);

for (const n of nums) console.log(n);        // values
for (const key in nums) console.log(key);    // "0" "1" "2" (keys)

nums.forEach((n) => console.log(n));
// cannot break or await inside forEach easily

for (let i = 0; i < 5; i++) {
  if (i === 1) continue; // skip 1
  if (i === 4) break;    // stop before 4
  console.log(i);
}
// 0 2 3

const nums = [1, 2, 9, 3];
const hasBig = nums.some((n) => n > 5); // true — stops early