Verify in TypeScript whether a property of an object is a function with a specified signature

Question

Verify in TypeScript whether a property of an object is a function with a specified signature

I am facing an issue with a function that retrieves a property from an object.

// Utils.ts
export function getProperty<T, K extends keyof T>(obj: T, key: string): T[K] {
    if (key in obj) { return obj[key as K]; }
    throw new Error(`Invalid object member "${key}"`);
}

My aim is to verify if the returned property is a function with a specific signature and then proceed to call this property with a provided parameter.

The function getProperty() is utilized for dynamically fetching one of the object's methods and invoking it. I attempted the following:

let property: this[keyof this] = utils.getProperty(this, name);
if (typeof property === 'function') ) { property(conf); }

However, I encountered an error stating "Cannot invoke an expression whose type lacks a call signature. Type 'any' has no compatible call signatures." I acknowledge that the property retrieved by getProperty() can technically be of any type, but how can I ensure that it specifically conforms to a function with the signature (conf: {}): void?

typescript typechecking function-signature

Answer 1

Answer №1

Unfortunately, there are no typeof type guards available for function types as per design decisions mentioned in microsoft/TypeScript#2072. While there are no built-in options, TypeScript does support user-defined type guards, allowing you to define functions that can narrow down the type of their arguments.

Once TypeScript code is compiled into JavaScript, the static type system gets erased. This means that at runtime, information about parameters like (conf: {}) => void isn't retained and cannot be directly accessed. Testing if a value is a function using

typeof x === "function"

only confirms it's a function without revealing details about its parameters or types. Alternative checks such as x.length === 1 have limitations due to factors like rest parameters and default parameters.

At runtime, any specifics about function parameter types are lost, especially if the functions originated from non-TypeScript sources. The ability to test functions by calling them with sample parameters exists but poses risks of unwanted side effects. The challenge lies in validating a function's correct type before utilizing it in operations.

If you're willing to accept these constraints, one approach is to consider a function valid if its length property equals 1. Alternatively, you may implement additional tests like setting a custom property named isOfRightType to validate specific functions. Creating a type guard based on your runtime tests provides a way to discern suitable functions:

function isFunctionOfRightType(x: any): x is (conf: {})=>void {
   return (typeof x === 'function') && (x.length === 1); // or customize as needed
}

// ... later

let property: this[keyof this] = utils.getProperty(this, name);
if (isFunctionOfRightType(property)) { property(conf); } // avoids errors

Try out the code on TypeScript Playground

Answer 2

Unfortunately, there are no typeof type guards available for function types as per design decisions mentioned in microsoft/TypeScript#2072. While there are no built-in options, TypeScript does support user-defined type guards, allowing you to define functions that can narrow down the type of their arguments.

Once TypeScript code is compiled into JavaScript, the static type system gets erased. This means that at runtime, information about parameters like (conf: {}) => void isn't retained and cannot be directly accessed. Testing if a value is a function using

typeof x === "function"

only confirms it's a function without revealing details about its parameters or types. Alternative checks such as x.length === 1 have limitations due to factors like rest parameters and default parameters.

At runtime, any specifics about function parameter types are lost, especially if the functions originated from non-TypeScript sources. The ability to test functions by calling them with sample parameters exists but poses risks of unwanted side effects. The challenge lies in validating a function's correct type before utilizing it in operations.

If you're willing to accept these constraints, one approach is to consider a function valid if its length property equals 1. Alternatively, you may implement additional tests like setting a custom property named isOfRightType to validate specific functions. Creating a type guard based on your runtime tests provides a way to discern suitable functions:

function isFunctionOfRightType(x: any): x is (conf: {})=>void {
   return (typeof x === 'function') && (x.length === 1); // or customize as needed
}

// ... later

let property: this[keyof this] = utils.getProperty(this, name);
if (isFunctionOfRightType(property)) { property(conf); } // avoids errors

Try out the code on TypeScript Playground

Answer 3

Answer №2

There is a slight error in your function signature that needs to be addressed. The key parameter should actually be of type K. This change will help improve inference when using constants for parameters:

export function getProperty<T, K extends keyof T>(obj: T, key: string): T[K] {
    if (key in obj) { return obj[key as K]; }
    throw new Error(`Invalid object member "${key}"`);
}

let foo = {
    fn (conf: {}): void {}
}
let fn = getProperty(foo, "fn");
fn({}); // callable

The issue arises when utilizing a key that is a string and isn't validated at compile time. In such cases, the compiler lacks efficiency in providing assistance. Since indexing by an arbitrary string leads to potential ambiguity, the compiler assumes the return type could be any valid field type within the target object. It's essential to understand that runtime validation of function parameter types becomes ineffective as they get erased. However, validating the count of parameters at runtime remains feasible:

let property:  Function = getProperty(this, name) as any;
if (typeof property === 'function' && property.length == 1)  
{ 
    property({}); 
}

Answer 4

There is a slight error in your function signature that needs to be addressed. The key parameter should actually be of type K. This change will help improve inference when using constants for parameters:

export function getProperty<T, K extends keyof T>(obj: T, key: string): T[K] {
    if (key in obj) { return obj[key as K]; }
    throw new Error(`Invalid object member "${key}"`);
}

let foo = {
    fn (conf: {}): void {}
}
let fn = getProperty(foo, "fn");
fn({}); // callable

The issue arises when utilizing a key that is a string and isn't validated at compile time. In such cases, the compiler lacks efficiency in providing assistance. Since indexing by an arbitrary string leads to potential ambiguity, the compiler assumes the return type could be any valid field type within the target object. It's essential to understand that runtime validation of function parameter types becomes ineffective as they get erased. However, validating the count of parameters at runtime remains feasible:

let property:  Function = getProperty(this, name) as any;
if (typeof property === 'function' && property.length == 1)  
{ 
    property({}); 
}

Verify in TypeScript whether a property of an object is a function with a specified signature

Answer №1

Answer №2

Similar questions

Is there a way to verify an if-else statement in the ngStyle background property with Angular 7?

When is the appropriate time to provide arguments to the constructor of a TypeScript service?

What is the process for type checking a Date in TypeScript?

Are Named Capture Groups in Typescript Regex malfunctioning?

Determining the size of a custom-typed array in Typescript

Deleting specialized object using useEffect hook

Encountered a problem while trying to retrieve HTML values from an object within a ReactJS component

Display array elements in a PDF document using pdfmake

Issue with MUI DialogTitle Ignoring SCSS Customization

Is there a technique to block small increments in a Time Input field?

Ways to achieve the organization of nested promises in Angular 9

Guide to automatically blur the input field and toggle it upon clicking the checkbox using Angular

Angular 2 iframe balked at being shown

I need to search through a tree structure in typescript based on a specific value without encountering a maximum stack call exceeded error

Achieving the incorporation of multiple components within a parent component using Angular 6

What is the process for embedding a Google Chart within an Angular 4 application?

Establishing the placement of map markers in Angular

Alter the language settings of the Datepicker feature in Material Angular 4

Discover how to showcase the balances of various supported networks through the Wagmi Library in a React application, just like how it's executed in

Enhancing JSON data: Transforming basic JSON structure into more complex format