JavaScript Coding Questions

Write a function that reverses a string.

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

Return true if a string is a palindrome (ignore case and non-alphanumeric).

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

Return the largest number in an array.

function findLargest(numbers) {
  return Math.max(...numbers);
}

Remove duplicate values from an array.

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

Count vowels in a string.

function countVowels(str) {
  return str.match(/[aeiou]/gi)?.length || 0;
}

Print Fizz, Buzz, or FizzBuzz for multiples of 3 and 5.

function fizzBuzz(n) {
  for (let i = 1; i <= n; i++) {
    if (i % 15 === 0) console.log("FizzBuzz");
    else if (i % 3 === 0) console.log("Fizz");
    else if (i % 5 === 0) console.log("Buzz");
    else console.log(i);
  }
}

Compute factorial recursively.

function factorial(n) {
  if (n === 0) return 1;
  return n * factorial(n - 1);
}

Return the first n Fibonacci numbers.

function fibonacci(n) {
  const result = [0, 1];
  for (let i = 2; i < n; i++) {
    result.push(result[i - 1] + result[i - 2]);
  }
  return result.slice(0, n);
}

Fully flatten a nested array.

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

Deep clone a plain object/array value.

function deepClone(value) {
  return structuredClone(value);
}

Implement debounce.

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

Implement throttle.

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

Memoize a unary function.

function memoize(fn) {
  const cache = {};
  return function (value) {
    if (cache[value] !== undefined) return cache[value];
    cache[value] = fn(value);
    return cache[value];
  };
}

Curry a simple add function.

function curryAdd(a) {
  return function (b) {
    return a + b;
  };
}

Group objects by a property key.

function groupBy(items, key) {
  return items.reduce((result, item) => {
    const group = item[key];
    if (!result[group]) result[group] = [];
    result[group].push(item);
    return result;
  }, {});
}

Implement Array.prototype.customMap.

Array.prototype.customMap = function (callback) {
  const result = [];
  for (let i = 0; i < this.length; i++) {
    result.push(callback(this[i], i, this));
  }
  return result;
};

Implement Array.prototype.customFilter.

Array.prototype.customFilter = function (callback) {
  const result = [];
  for (let i = 0; i < this.length; i++) {
    if (callback(this[i], i, this)) result.push(this[i]);
  }
  return result;
};

Implement Array.prototype.customReduce.

Array.prototype.customReduce = function (callback, initialValue) {
  let accumulator = initialValue;
  for (let i = 0; i < this.length; i++) {
    accumulator = callback(accumulator, this[i], i, this);
  }
  return accumulator;
};

Implement a Promise.all-like helper.

function promiseAll(promises) {
  return new Promise((resolve, reject) => {
    const results = [];
    let completed = 0;
    promises.forEach((promise, index) => {
      Promise.resolve(promise)
        .then((value) => {
          results[index] = value;
          completed++;
          if (completed === promises.length) resolve(results);
        })
        .catch(reject);
    });
  });
}

Build a minimal EventEmitter.

class EventEmitter {
  constructor() {
    this.events = {};
  }
  on(event, callback) {
    if (!this.events[event]) this.events[event] = [];
    this.events[event].push(callback);
  }
  emit(event, data) {
    (this.events[event] || []).forEach((callback) => callback(data));
  }
}

Check if two strings are anagrams.

function isAnagram(a, b) {
  return a.split("").sort().join("") === b.split("").sort().join("");
}

Capitalize the first letter of each word.

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

Find the missing number from 1..n.

function findMissingNumber(arr, n) {
  const expected = (n * (n + 1)) / 2;
  const actual = arr.reduce((sum, num) => sum + num, 0);
  return expected - actual;
}

Count occurrences of each value.

function countOccurrences(arr) {
  return arr.reduce((result, item) => {
    result[item] = (result[item] || 0) + 1;
    return result;
  }, {});
}

Shallow-merge two objects.

function mergeObjects(a, b) {
  return { ...a, ...b };
}

Parse JSON safely and return null on failure.

function safeJsonParse(text) {
  try {
    return JSON.parse(text);
  } catch {
    return null;
  }
}

Retry an async function N times.

async function retry(fn, attempts) {
  for (let i = 0; i < attempts; i++) {
    try {
      return await fn();
    } catch (error) {
      if (i === attempts - 1) throw error;
    }
  }
}

Create a delay promise.

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

Toggle an active class on an element.

function toggleActive(element) {
  element.classList.toggle("active");
}

Validate a simple email pattern.

function validateEmail(email) {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}