Can I define a string to correspond to a property name in an interface using TypeScript?

Question

Can I define a string to correspond to a property name in an interface using TypeScript?

I have the following interface as an example:

interface Account {
    email: string;
    enabled: boolean;
}

I want to create a method that will return default values for the fields in this interface. This is what I have so far:

function defaultValue(propName:string) {
    if (propName === 'email') return '';
    if (propName === 'enabled') return true;
}

While this method works fine, it's not foolproof. If any property within Account changes, the defaultValue() method may still compile correctly even though it's now incorrect.

Is there a way to specify that propName should match the type of a property name in Account? Or is there another effective pattern I can implement to ensure type checking in this scenario?

typescript interface

Answer 1

Answer №1

To ensure that a variable is never at the end of if statements, you can create a function and use keyof T to obtain a union of keys:

function assertNever(v: never): never {
  throw new Error("Should never happen!");
}

function defaultValue(propName:keyof Account) {
    if (propName === 'email') return '';
    if (propName === 'enabled') return true;
    assertNever(propName);
}

Playground Link

You can enhance the function by making it generic for better caller experience, but this may require type assertions in the implementation.


function defaultValue<K extends keyof Account>(propName:K): Account[K] {
    if (propName === 'email') return '' as Account[K];
    if (propName === 'enabled') return true as Account[K];
    assertNever(propName);
}

let email = defaultValue('email') // string
let enabled = defaultValue('enabled') // boolean

Playground Link

Answer 2

To ensure that a variable is never at the end of if statements, you can create a function and use keyof T to obtain a union of keys:

function assertNever(v: never): never {
  throw new Error("Should never happen!");
}

function defaultValue(propName:keyof Account) {
    if (propName === 'email') return '';
    if (propName === 'enabled') return true;
    assertNever(propName);
}

Playground Link

You can enhance the function by making it generic for better caller experience, but this may require type assertions in the implementation.


function defaultValue<K extends keyof Account>(propName:K): Account[K] {
    if (propName === 'email') return '' as Account[K];
    if (propName === 'enabled') return true as Account[K];
    assertNever(propName);
}

let email = defaultValue('email') // string
let enabled = defaultValue('enabled') // boolean

Playground Link

Answer 3

Answer №2

To achieve this, consider specifying a more precise string type for the propName parameter. Utilize a switch statement to enable smart type inference, ensuring that you return a value matching the return type for each potential branch within the function.

interface Account {
    email: string;
    enabled: boolean;
    shouldError: boolean;
}

function defaultValue(propName: keyof Account): Account[keyof Account] { // indicates error if not all paths return a value
    switch (propName) {
        case "email":
            return "";
        case "enabled":
            return true;
        // Uncomment the following code block to rectify the error
        // case "shouldError":
        //     return true;
    }
}

TypeScript Playground Link

Answer 4

To achieve this, consider specifying a more precise string type for the propName parameter. Utilize a switch statement to enable smart type inference, ensuring that you return a value matching the return type for each potential branch within the function.

interface Account {
    email: string;
    enabled: boolean;
    shouldError: boolean;
}

function defaultValue(propName: keyof Account): Account[keyof Account] { // indicates error if not all paths return a value
    switch (propName) {
        case "email":
            return "";
        case "enabled":
            return true;
        // Uncomment the following code block to rectify the error
        // case "shouldError":
        //     return true;
    }
}

TypeScript Playground Link

Can I define a string to correspond to a property name in an interface using TypeScript?

Answer №1

Answer №2

Similar questions

Guide to implementing a specified directive value across various tags in Angular Material

What is the proper way to designate a data type for a variable?

Why is a method for animation in Three.js + TypeScript only executed once?

The change handler of the TS RadioGroup component, instead of returning an array of possible strings, returns a unique

Invoking a functionality within a stream of events through an observable's subscribe

When using string as a primitive type in Vue 3, what distinguishes the usage of PropType in props from not using it?

Discovering errors within a reactive form in Angular using a loop to iterate through the FormArray

The type 'number' cannot be assigned to the type 'Element'

Discover how to modify the URL in Angular

Is it possible for the ComponentRef.destroy() function to also handle unsubscription of the Components Event Emitters?

Using React.lazy, Suspense, and react-router-dom for code splitting in React does not function as intended

Issue during Docker build: npm WARN EBADENGINE Detected unsupported engine version

Enhance your TypeScript module with parcel augmentation

"Embedding a JSON object within a script tag in NextJS: A step-by-step

With each click on "add to cart," a duplicate of the component will appear

Guide to Angular Interface Styling - Ambiguous Suggestions

Invoke a component's function in a different component

Using Angular 2, you can pass an object as a parameter to a function

Tips for bringing in a feature that is available in JavaScript but missing in TypeScript definitions and troubleshooting any resulting errors

The issue with ag-grid not displaying data when the column configurations are changed dynamically