Summary  
This chapter covers how to constrain generic type parameters using the `extends` keyword so that they must satisfy specific structural requirements (for example, having a `length` property), improving type safety by catching mismatches at compile time.

General domain of usage  
Utility functions for handling collection-like data types (e.g., strings and arrays)

When working with generics in TypeScript, there are times when you need to ensure that a generic type meets certain requirements. You can achieve this by using the `extends` keyword to constrain the generic type. This approach allows you to specify that a generic type parameter must have a particular structure or inherit from a specific type. By constraining generics, you make your code more robust and help prevent runtime errors by catching type mismatches at compile time.

function logLength<T extends { length: number }>(item: T): void {
  console.log(`Length is: ${item.length}`);
}

logLength("hello"); // Output: Length is: 5
logLength([1, 2, 3]); // Output: Length is: 3
// logLength(42); // Error: Argument of type 'number' is not assignable to parameter of type '{ length: number; }'

By using `T extends { length: number }`, you ensure that the function only accepts arguments that have a `length` property, such as **strings** and **arrays**. This constraint means that if you try to call `logLength` with a value that does not have a `length` property, TypeScript will display a compile-time error. This improves **type safety** by preventing accidental misuse of the function. Constraints like these are especially useful when you want to write generic code that works with a family of related types, but not with every possible type.

Which of the following best describes the effect of adding `extends { length: number }` to a generic type parameter in a function?

A practical course on mastering interfaces and generics in TypeScript. Learn how to design robust type systems that make your code safer, cleaner, and easier to scale. From defining interfaces to building reusable generic patterns, this course provides a complete foundation for writing modern, type-safe applications.

Explore how interfaces define the structure of objects and enforce consistency in TypeScript projects. Understand how to extend, combine, and compare interfaces with type aliases to create clear and maintainable code architectures.

Unlock the flexibility of generics to write reusable and adaptable TypeScript code. Learn how to apply generics in functions, interfaces, and classes, and how to constrain them to build safer, more expressive types.

Combine interfaces and generics to design scalable, real-world type systems. Apply advanced patterns and follow best practices for creating clean, reusable, and maintainable TypeScript code.

Constraining Generics with Extends