50 Most Useful TypeScript Snippets for Developers

Why Are TypeScript Snippets Essential for Developers?

Efficiency and productivity are the cornerstones of successful software development. TypeScript snippets, which are concise, reusable code blocks, play a crucial role in saving time, minimizing errors, and enhancing the coding process. For developers navigating complex data structures or aiming to simplify repetitive tasks, mastering the right snippets can be a game-changer.

In this article, we'll dive into 50 indispensable TypeScript snippets that every developer should incorporate into their toolkit. These snippets span various functionalities, from generating random numbers to array manipulation, empowering you to tackle diverse coding challenges with confidence.

How to Generate a Random Number

Generating random numbers is a frequent requirement in programming. This snippet simplifies the process:

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

How to Check for Empty Objects

It's vital to verify the emptiness of objects. This code snippet does just that:

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

How to Implement a Countdown Timer

Create a countdown timer effortlessly with this function:

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);
}

How to Sort an Array by Property

Sorting an array by a specific property is now straightforward:

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

How to Remove Duplicates from an Array

Ensure your array contains unique values with this snippet:

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

How to Truncate a String

Control string length effectively with this function:

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

How to Convert Strings to Title Case

Easily transform strings to title case:

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

How to Check for Value Existence in an Array

Verify the presence of a value in an array:

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

How to Reverse a String

Reverse strings with this simple function:

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

How to Increment All Elements in an Array

Increment all elements in a numeric array effortlessly:

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

How to Implement Debounce Function

Minimize excessive function calls with this debounce technique:

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;
}

How to Implement Throttle Function

Manage the execution rate of 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;
}

Conclusion

TypeScript snippets are indispensable tools that significantly boost coding efficiency and productivity. By integrating these 50 essential snippets into your development process, you'll be well-equipped to handle a broad spectrum of programming tasks more effectively. Experiment with these snippets and tailor them to suit your unique coding preferences.

Embrace these snippets in your projects and experience a remarkable improvement in your coding speed and efficiency.