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!
Leave a Reply