Constrain type based on array member member type

Constrain type based on array member type

When working with TypeScript, you may come across situations where you need to constrain a type based on the type of a member within an array. In this blog post, we will explore different solutions to this problem.

Solution 1: Using a type guard

One way to constrain a type based on an array member type is by using a type guard. A type guard is a function that returns a boolean value indicating whether a value is of a specific type.

function isStringArray(arr: unknown[]): arr is string[] {
  return arr.every((item) => typeof item === "string");
}

function processArray(arr: unknown[]): void {
  if (isStringArray(arr)) {
    // Process the array as a string array
    arr.forEach((item) => {
      // Process each string item
      console.log(item.toUpperCase());
    });
  } else {
    // Handle the case when the array is not a string array
    console.log("Invalid array type");
  }
}

const stringArray = ["apple", "banana", "cherry"];
const numberArray = [1, 2, 3];

processArray(stringArray); // Output: APPLE, BANANA, CHERRY
processArray(numberArray); // Output: Invalid array type

In this solution, we define a type guard function isStringArray that checks if every item in the array is of type string. If the type guard returns true, we can safely assume that the array is a string array and process it accordingly. Otherwise, we handle the case when the array is not a string array.

Solution 2: Using a generic type

Another way to constrain a type based on an array member type is by using a generic type. Generics allow us to create reusable components that can work with a variety of types.

function processArray(arr: T[]): void {
  arr.forEach((item) => {
    // Process each string item
    console.log(item.toUpperCase());
  });
}

const stringArray = ["apple", "banana", "cherry"];
const numberArray = [1, 2, 3];

processArray(stringArray); // Output: APPLE, BANANA, CHERRY
processArray(numberArray); // Error: Argument of type 'number[]' is not assignable to parameter of type 'string[]'

In this solution, we define a generic type T that extends string. This ensures that the processArray function only accepts arrays of strings. By using the generic type, we can safely assume that each item in the array is of type T, which in this case is string.

These are two possible solutions to constrain a type based on the type of a member within an array in TypeScript. Choose the solution that best fits your specific use case and enjoy the benefits of type safety in your code!