50 Most Useful TypeScript Snippets

1. Generate a Random Number

function getRandomNumber(max: number): number {
  return Math.floor(Math.random() * max);
}

2. Check If an Object Is Empty

function isEmptyObject(obj: Record<string, unknown>): boolean {
  return Object.keys(obj).length === 0;
}

3. Create a Countdown Timer

function countdownTimer(minutes: number): void {
  let seconds = minutes * 60;
  const interval = setInterval(() => {
    console.log(`${Math.floor(seconds / 60)}:${seconds % 60}`);
    if (--seconds < 0) clearInterval(interval);
  }, 1000);
}

4. Sort Array of Objects by Property

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

5. Remove Duplicates from an Array

function removeDuplicates<T>(arr: T[]): T[] {
  return [...new Set(arr)];
}

6. Truncate a String

function truncateString(str: string, length: number): string {
  return str.length > length ? `${str.slice(0, length)}...` : str;
}

7. Convert String to Title Case

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

8. Check if Value Exists in Array

function valueExists<T>(arr: T[], value: T): boolean {
  return arr.includes(value);
}

9. Reverse a String

function reverseString(str: string): string {
  return str.split('').reverse().join('');
}

10. Increment Numbers in an Array

function incrementArray(arr: number[]): number[] {
  return arr.map(num => num + 1);
}

11. Debounce a Function

function debounce<F extends (...args: any[]) => void>(func: F, delay: number): F {
  let timeout: ReturnType<typeof setTimeout>;
  return function(this: any, ...args: any[]) {
    clearTimeout(timeout);
    timeout = setTimeout(() => func.apply(this, args), delay);
  } as F;
}

12. Throttle a Function

function throttle<F extends (...args: any[]) => void>(func: F, limit: number): F {
  let lastRun = 0;
  return function(this: any, ...args: any[]) {
    const now = Date.now();
    if (now - lastRun >= limit) {
      func.apply(this, args);
      lastRun = now;
    }
  } as F;
}

13. Clone an Object

function cloneObject<T>(obj: T): T {
  return { ...obj };
}

14. Merge Two Objects

function mergeObjects<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

15. Check for Palindrome String

function isPalindrome(str: string): boolean {
  const cleaned = str.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
  return cleaned === cleaned.split('').reverse().join('');
}

16. Count Occurrences in an Array

function countOccurrences<T>(arr: T[]): Record<string, number> {
  return arr.reduce((acc, val) => {
    const key = String(val);
    acc[key] = (acc[key] || 0) + 1;
    return acc;
  }, {} as Record<string, number>);
}

17. Get Day of the Year

function getDayOfYear(date: Date): number {
  const start = new Date(date.getFullYear(), 0, 0);
  const diff = date.getTime() - start.getTime();
  return Math.floor(diff / (1000 * 60 * 60 * 24));
}

18. Filter Unique Values from Array

function getUniqueValues<T>(arr: T[]): T[] {
  return [...new Set(arr)];
}

19. Convert Degrees to Radians

function degreesToRadians(degrees: number): number {
  return (degrees * Math.PI) / 180;
}

20. Delay Function Execution

function defer(fn: (...args: any[]) => void, ...args: any[]): void {
  setTimeout(() => fn(...args), 1);
}

21. Capitalize First Letter

function capitalizeFirstLetter(str: string): string {
  return str.charAt(0).toUpperCase() + str.slice(1);
}

22. Convert Array to Chunked Groups

function chunkArray<T>(arr: T[], size: number): T[][] {
  return Array.from({ length: Math.ceil(arr.length / size) }, (_, i) =>
    arr.slice(i * size, i * size + size)
  );
}

23. Flatten Nested Arrays

function flattenArray<T>(arr: any[]): T[] {
  return arr.flat(Infinity) as T[];
}

24. Get Random Element from Array

function randomElement<T>(arr: T[]): T {
  return arr[Math.floor(Math.random() * arr.length)];
}

25. Shuffle an Array

function shuffleArray<T>(arr: T[]): T[] {
  return arr.sort(() => Math.random() - 0.5);
}

26. Find Max in Array

function arrayMax(arr: number[]): number {
  return Math.max(...arr);
}

27. Find Min in Array

function arrayMin(arr: number[]): number {
  return Math.min(...arr);
}

28. Remove Null and Undefined

function removeEmpty<T>(arr: (T | null | undefined)[]): T[] {
  return arr.filter((x): x is T => x != null);
}

29. Format Date as YYYY-MM-DD

function formatDate(date: Date): string {
  return date.toISOString().split('T')[0];
}

30. Round to N Decimal Places

function roundTo(num: number, decimals: number): number {
  return parseFloat(num.toFixed(decimals));
}

31. Generate Random UUID

function generateUUID(): string {
  return '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);
  });
}

32. Check if Number is Even

function isEven(num: number): boolean {
  return num % 2 === 0;
}

33. Check if Number is Odd

function isOdd(num: number): boolean {
  return num % 2 !== 0;
}

34. Sleep / Delay

function sleep(ms: number): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms));
}

35. Retry a Function

async function retry<T>(fn: () => Promise<T>, retries: number): Promise<T> {
  let lastError: any;
  for (let i = 0; i < retries; i++) {
    try {
      return await fn();
    } catch (err) {
      lastError = err;
    }
  }
  throw lastError;
}

36. Get Query Parameters from URL

function getQueryParams(url: string): Record<string, string> {
  return Object.fromEntries(new URL(url).searchParams.entries());
}

37. Generate Random Boolean

function randomBoolean(): boolean {
  return Math.random() >= 0.5;
}

38. Convert Object to Query String

function toQueryString(params: Record<string, any>): string {
  return new URLSearchParams(params).toString();
}

39. Deep Clone Object

function deepClone<T>(obj: T): T {
  return JSON.parse(JSON.stringify(obj));
}

40. Remove Falsey Values from Array

function compact<T>(arr: T[]): T[] {
  return arr.filter(Boolean);
}

41. Check if String is JSON

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

42. Generate Random Hex Color

function randomHexColor(): string {
  return `#${Math.floor(Math.random() * 16777215).toString(16)}`;
}

43. Convert Bytes to Human Readable

function formatBytes(bytes: number): string {
  if (bytes === 0) return '0 Bytes';
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
  const i = Math.floor(Math.log(bytes) / Math.log(1024));
  return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${sizes[i]}`;
}

44. Check if String Contains Substring

function contains(str: string, substr: string): boolean {
  return str.includes(substr);
}

45. Pluck Property Values from Array

function pluck<T, K extends keyof T>(arr: T[], key: K): T[K][] {
  return arr.map(item => item[key]);
}

46. Intersection of Two Arrays

function intersect<T>(a: T[], b: T[]): T[] {
  return a.filter(value => b.includes(value));
}

47. Difference of Two Arrays

function difference<T>(a: T[], b: T[]): T[] {
  return a.filter(value => !b.includes(value));
}

48. Zip Two Arrays

function zip<T, U>(a: T[], b: U[]): [T, U][] {
  return a.map((val, i) => [val, b[i]]);
}

49. Unzip Array

function unzip<T, U>(arr: [T, U][]): [T[], U[]] {
  return arr.reduce(([a, b], [x, y]) => [[...a, x], [...b, y]], [[], []] as [T[], U[]]);
}

50. Unique by Property

function uniqueBy<T>(arr: T[], key: keyof T): T[] {
  const seen = new Set();
  return arr.filter(item => {
    const val = item[key];
    if (seen.has(val)) return false;
    seen.add(val);
    return true;
  });
}

Comments

[Baptiste Firket]

Are you sure checking for palindrome is really useful?