Is there a way to inform TypeScript that an object can only return properties from values found within an array?

Question

Is there a way to inform TypeScript that an object can only return properties from values found within an array?

I am trying to ensure that the return object from a function in TypeScript only allows keys that correspond to string values present in an array passed as an argument to the function. The returned object should contain a subset of keys from a list of valid strings based on the input array. I am struggling with referencing the actual values provided to 'myArr'.

declare type ListOfStrings = 'apple' | 'banana' | 'car';
function doSomething(myArr: ListOfStrings[]) {
    const returnObj: { [Properties in ListOfStrings]?: number } = {}; 
    for (const entry of myArr) returnObj[entry] = Math.random();
    return returnObj;
}

const finalObj = doSomething(['banana', 'car']);
console.log(finalObj.apple); // This does not generate a TypeScript error, which is what I want help with.

Any advice would be greatly appreciated!

typescript

Answer 1

Answer №1

If you want to ensure the correct structure of your object, consider making your function generic

function createObject<T extends ArrayOfStrings>(myArr:T[] ) {
    const resultObj: { [Property in T]?: number } = {}; 
    for (const item of myArr) resultObj[item] = Math.random();
    return resultObj;
}

This approach will guarantee that the resulting object follows the desired format

const newObj = createObject(['apple', 'truck']);
const newObj: {
   apple?: number | undefined;
   truck?: number | undefined;
}

Answer 2

If you want to ensure the correct structure of your object, consider making your function generic

function createObject<T extends ArrayOfStrings>(myArr:T[] ) {
    const resultObj: { [Property in T]?: number } = {}; 
    for (const item of myArr) resultObj[item] = Math.random();
    return resultObj;
}

This approach will guarantee that the resulting object follows the desired format

const newObj = createObject(['apple', 'truck']);
const newObj: {
   apple?: number | undefined;
   truck?: number | undefined;
}

Answer 3

Answer №2

Employ Generics in tandem with Mapped Types.

type ListOfFruits = 'apple' | 'banana' | 'car';

function processItems<
    T extends ListOfFruits,             // Ensure the items in `arr` are part of this union.
    K extends Extract<ListOfFruits, T>  // Extract only the values included in the `arr`.
>(arr: T[]){
    const result = {} as { [k in K]: number }; // Map union `K` to return value properties.

    for (const entry of arr){
        result[entry as K] = Math.random();    // Indicate to the compiler that the value of `arr` is one of K.
    }

    return result;
}

const valid = processItems(['banana', 'car']);  // valid
valid.banana; // valid
valid.orange; // error

const invalid = processItems(['banana', 'orange']);  // error

See Demo in playground.

Answer 4

Employ Generics in tandem with Mapped Types.

type ListOfFruits = 'apple' | 'banana' | 'car';

function processItems<
    T extends ListOfFruits,             // Ensure the items in `arr` are part of this union.
    K extends Extract<ListOfFruits, T>  // Extract only the values included in the `arr`.
>(arr: T[]){
    const result = {} as { [k in K]: number }; // Map union `K` to return value properties.

    for (const entry of arr){
        result[entry as K] = Math.random();    // Indicate to the compiler that the value of `arr` is one of K.
    }

    return result;
}

const valid = processItems(['banana', 'car']);  // valid
valid.banana; // valid
valid.orange; // error

const invalid = processItems(['banana', 'orange']);  // error

See Demo in playground.

Answer 5

Answer №3

Not flawless, but it should do the job

function performAction<Keys extends string>(keys: Keys[]): Partial<Record<Keys, number>> {
    const returnObject: Partial<Record<Keys, number>> = {};
    for (const item of keys) {
        returnObject[item] = Math.random();
    }
    return returnObject;
}

const result = performAction(['alpha', 'beta']);
result.c // error

TypeScript Playground Link

Answer 6

Not flawless, but it should do the job

function performAction<Keys extends string>(keys: Keys[]): Partial<Record<Keys, number>> {
    const returnObject: Partial<Record<Keys, number>> = {};
    for (const item of keys) {
        returnObject[item] = Math.random();
    }
    return returnObject;
}

const result = performAction(['alpha', 'beta']);
result.c // error

TypeScript Playground Link

Is there a way to inform TypeScript that an object can only return properties from values found within an array?

Answer №1

Answer №2

Answer №3

Similar questions

Easy Steps to Simplify Your Code for Variable Management

Fixing the "Cannot find name" error by targeting ES6 in the tsconfig.json file

Using TypeScript with Watermelondb

How do I manage 'for' loops in TypeScript while using the 'import * as' syntax?

Utilizing Typescript's baseUrl compiler configuration for node development

Checking a sequence using a list of strings

Dealing with server-side errors while utilizing react-query and formik

Ways to "Compile out" log commands

Tips for setting up a full-size image with nextJS and the <Image /> component

What is the best way for a parent process to interrupt a child_process using a command?

Determine whether there is only one array in the object that contains values

Updating a subscribed observable does not occur when pushing or nexting a value from an observable subject

Can TypeScript automatically deduce keys from a changing object structure?

Experiencing unexpected output from Angular model class method

What is the best way to map elements when passing props as well?

Ways to import a library in JavaScript/TypeScript on a web browser?

Altering a public variable of a component from a sibling component

Using TypeScript to automatically deduce the output type of a function by analyzing the recursive input type

Error in TypeScript on SendGrid API: Invalid HttpMethod

What is the best way to perform an AJAX request in Typescript with JSON data?