Define a Typescript index signature that uses a separate generic type for each field

Define a TypeScript Index Signature with Separate Generic Types for Each Field

When working with TypeScript, you may come across situations where you need to define an index signature that uses a separate generic type for each field. This allows you to have more flexibility and control over the types of values that can be assigned to specific fields in an object.

In TypeScript, an index signature allows you to define the types of values that can be assigned to specific fields in an object using square brackets. By default, TypeScript allows you to use a single generic type for all fields in an index signature. However, if you need to use separate generic types for each field, you can achieve this by leveraging mapped types.

Let’s take a look at an example to better understand how to define a TypeScript index signature with separate generic types for each field:

type FieldName = 'name' | 'age' | 'email';

type FieldValue = T extends 'name' ? string :
  T extends 'age' ? number :
  T extends 'email' ? string :
  never;

type MyObject = {
  [K in FieldName]: FieldValue;
};

const obj: MyObject = {
  name: 'John Doe',
  age: 30,
  email: 'johndoe@example.com',
};

console.log(obj.name); // Output: John Doe
console.log(obj.age); // Output: 30
console.log(obj.email); // Output: johndoe@example.com

In the above example, we define a type FieldName that represents the possible field names in our object. We then define a type FieldValue that maps each field name to its corresponding generic type. We use the conditional type syntax to achieve this mapping.

Next, we define a type MyObject that uses the mapped types syntax to create an index signature with separate generic types for each field. The keys of the index signature are the field names defined in the FieldName type, and the values are the corresponding generic types defined in the FieldValue type.

Finally, we create an object obj that conforms to the MyObject type and assign values to each field. We can then access the values of each field using dot notation, and TypeScript will enforce the correct types for each field.

By defining a TypeScript index signature with separate generic types for each field, you can ensure type safety and provide more precise type information for your objects. This can be particularly useful when working with complex data structures or when you need to enforce specific types for different fields.

Overall, TypeScript’s flexibility and powerful type system allow you to define index signatures with separate generic types for each field, providing you with greater control and type safety in your code.