50 Most Useful JavaScript Snippets

let randomNum = Math.floor(Math.random() * maxNum);

function isEmptyObject(obj) { 
  return Object.keys(obj).length === 0; 
}

function countdownTimer(minutes) { 
  let seconds = minutes * 60;
  let interval = setInterval(() => {
    if (seconds <= 0) {
      clearInterval(interval);
      console.log("Time's up!");
    } else {
      console.log(`${Math.floor(seconds / 60)}:${seconds % 60}`);
      seconds--;
    }
  }, 1000);
}

function sortByProperty(arr, property) { 
  return arr.sort((a, b) => (a[property] > b[property]) ? 1 : -1); 
}

let uniqueArr = [...new Set(arr)];

function truncateString(str, num) { 
  return str.length > num ? str.slice(0, num) + "..." : str; 
}

function toTitleCase(str) { 
  return str.replace(/\b\w/g, txt => txt.toUpperCase()); 
}

let isValueInArray = arr.includes(value);

let reversedStr = str.split("").reverse().join("");

let newArr = oldArr.map(item => item + 1);

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

function throttle(func, limit) { 
  let lastFunc; 
  let lastRan; 
  return function(...args) { 
    if (!lastRan) { 
      func.apply(this, args); 
      lastRan = Date.now(); 
    } else { 
      clearTimeout(lastFunc); 
      lastFunc = setTimeout(function() { 
        if ((Date.now() - lastRan) >= limit) { 
          func.apply(this, args); 
          lastRan = Date.now(); 
        } 
      }, limit - (Date.now() - lastRan)); 
    } 
  }; 
}

const cloneObject = (obj) => ({ ...obj });

const mergeObjects = (obj1, obj2) => ({ ...obj1, ...obj2 });

function isPalindrome(str) { 
  const cleanedStr = str.replace(/[^A-Za-z0-9]/g, '').toLowerCase(); 
  return cleanedStr === cleanedStr.split('').reverse().join(''); 
}

const countOccurrences = (arr) => 
  arr.reduce((acc, val) => (acc[val] ? acc[val]++ : acc[val] = 1, acc), {});

const dayOfYear = date => 
  Math.floor((date - new Date(date.getFullYear(), 0, 0)) / 1000 / 60 / 60 / 24);

const uniqueValues = arr => [...new Set(arr)];

const degreesToRads = deg => (deg * Math.PI) / 180;

const defer = (fn, ...args) => setTimeout(fn, 1, ...args);

const flattenArray = arr => arr.flat(Infinity);

const randomItem = arr => arr[Math.floor(Math.random() * arr.length)];

const capitalize = str => str.charAt(0).toUpperCase() + str.slice(1);

const maxVal = arr => Math.max(...arr);

const minVal = arr => Math.min(...arr);

function shuffleArray(arr) { 
  return arr.sort(() => Math.random() - 0.5); 
}

const removeFalsy = arr => arr.filter(Boolean);

const range = (start, end) => Array.from({ length: end - start + 1 }, (_, i) => i + start);

const arraysEqual = (a, b) => 
  a.length === b.length && a.every((val, i) => val === b[i]);

const isEven = num => num % 2 === 0;

const isOdd = num => num % 2 !== 0;

const removeSpaces = str => str.replace(/\s+/g, '');

function isJSON(str) { 
  try { 
    JSON.parse(str); 
    return true; 
  } catch { 
    return false; 
  } 
}

const deepClone = obj => JSON.parse(JSON.stringify(obj));

function isPrime(num) {
  if (num <= 1) return false;
  for (let i = 2; i <= Math.sqrt(num); i++) {
    if (num % i === 0) return false;
  }
  return true;
}

const factorial = num => 
  num <= 1 ? 1 : num * factorial(num - 1);

const timestamp = Date.now();

const formatDate = date => date.toISOString().split('T')[0];

const uuid = () => 
  'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
    const r = Math.random() * 16 | 0;
    const v = c === 'x' ? r : (r & 0x3 | 0x8);
    return v.toString(16);
  });

const hasProp = (obj, key) => key in obj;

const getQueryParams = url => 
  Object.fromEntries(new URLSearchParams(new URL(url).search));

const escapeHTML = str => 
  str.replace(/[&<>'"]/g, tag => ({
    '&':'&amp;','<':'&lt;','>':'&gt;',
    "'":'&#39;', '"':'&quot;'
  }[tag]));

const unescapeHTML = str => 
  str.replace(/&(amp|lt|gt|#39|quot);/g, match => ({
    '&amp;':'&','&lt;':'<','&gt;':'>',
    '&#39;':"'", '&quot;':'"'
  }[match]));

const sleep = ms => new Promise(res => setTimeout(res, ms));

const sumArray = arr => arr.reduce((a, b) => a + b, 0);

const avgArray = arr => arr.reduce((a, b) => a + b, 0) / arr.length;

const intersection = (arr1, arr2) => arr1.filter(x => arr2.includes(x));

const difference = (arr1, arr2) => arr1.filter(x => !arr2.includes(x));

const allEqual = arr => arr.every(val => val === arr[0]);

const randomHexColor = () => 
  '#' + Math.floor(Math.random()*16777215).toString(16);