Advanced TypeScript Types: Utility Types and Type Guards

TypeScript’s type system is incredibly powerful. Let’s explore advanced features that can make your code more type-safe and maintainable.

Utility Types

TypeScript provides several built-in utility types:

1. Partial<T>

Makes all properties optional:

interface User {
  name: string;
  email: string;
}

type PartialUser = Partial<User>;

2. Pick<T, K> and Omit<T, K>

Select or exclude specific properties:

• Pick - Select specific properties
• Omit - Exclude specific properties

3. Record<K, T>

Create an object type with specific key and value types:

type PageInfo = Record<string, { title: string; url: string }>;

Type Guards

Type guards help narrow down types at runtime:

typeof Type Guards

function isString(value: unknown): value is string {
  return typeof value === "string";
}

instanceof Type Guards

if (error instanceof Error) {
  console.log(error.message);
}

Conditional Types

Create types based on conditions:

type IsString<T> = T extends string ? true : false;

Mapped Types

Transform properties of existing types:

type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};

Template Literal Types

Create types from string templates:

type EventName = `on${Capitalize<string>}`;

Best Practices

1. Use utility types to avoid code duplication
2. Implement type guards for runtime type safety
3. Leverage conditional types for complex type logic
4. Keep types simple and readable

Conclusion

Advanced TypeScript types provide powerful tools for creating type-safe applications. Mastering these features will make your code more robust and maintainable.