Is the return type of 'void' being overlooked in TypeScript - a solution to avoid unresolved promises?

Question

Is the return type of 'void' being overlooked in TypeScript - a solution to avoid unresolved promises?

When working in TypeScript 3.9.7, the compiler is not concerned with the following code:

const someFn: () => void = () => 123;

After stumbling upon this answer, it became apparent that this behavior is intentional. The rationale behind it makes sense (essentially, ignoring the return type when passing the function as an argument).

However, things take a turn when dealing with promises:

const someFn: () => void = () =>
  new Promise((resolve, reject) => reject(Error('onoez')));
someFn();

I am using ESLint's

@typescript-eslint/no-floating-promises

rule to catch unhandled promise rejections in my code. In the example above, since the linter believes someFn does not have a return value, it will not issue a warning.

Do I just have to accept this situation? If a function expects a () => void type callback and I provide it with an async function, the compiler won't flag any issues, leading to potential problems. Is there a way to prevent this?

typescript promise eslint void

Answer 1

Answer №1

When a function has a return type of void in TypeScript, it means that the return value cannot be used, regardless of what it is. However, this does not prevent the function from actually returning something. This behavior will remain unchanged.

The syntax () => void indicates that you do not need to know or use the return value because it is not important for your purpose. But in some cases, such as this one, the return value does matter.

To enforce that a function does not return any value at all, you can use a return type of undefined.

const someFn: () => undefined = () =>
  // Type 'Promise<unknown>' is not assignable to type 'undefined'.
  new Promise((resolve, reject) => reject(Error('oh no!')));

Answer 2

When a function has a return type of void in TypeScript, it means that the return value cannot be used, regardless of what it is. However, this does not prevent the function from actually returning something. This behavior will remain unchanged.

The syntax () => void indicates that you do not need to know or use the return value because it is not important for your purpose. But in some cases, such as this one, the return value does matter.

To enforce that a function does not return any value at all, you can use a return type of undefined.

const someFn: () => undefined = () =>
  // Type 'Promise<unknown>' is not assignable to type 'undefined'.
  new Promise((resolve, reject) => reject(Error('oh no!')));

Is the return type of 'void' being overlooked in TypeScript - a solution to avoid unresolved promises?

Answer №1

Similar questions

There is no valid injection token found for the parameter 'functions' in the class 'TodosComponent'

"Enable email delivery in the background on a mobile app without relying on a server

Is it possible to invoke Cucumber stepDefinitions from a separate project at the same directory level?

Error Message in Terminal When Launching React Application Using Webpack

I am facing an issue with my interface - the variable designed to store boolean values

Unexpected behavior with Node js event listener

How to pass data/props to a dynamic page in NextJS?

Using typescript for Gnome shell extension development. Guidelines on importing .ts files

Issues may arise in Typescript when trying to return an array of data from a redux createAsyncThunk function

Error message: The ofType method from Angular Redux was not found

The compatibility issues between Karma and Jasmine testing configurations cause errors during the Ionic packaging process

Can the Rxjs library's Observables of() function be used to output multiple values?

Guide on deactivating the div in angular using ngClass based on a boolean value

How can I retrieve List<T> from a Razor Page using TypeScript?

Instead of relying on Vue TypeScript, we are leveraging IntelliJ with TypeScript 5.0.3 to compile our Vue project

Is there a way to implement personalized error management in TypeScript with Express?

Tips for verifying the presence of a specific value within an array of union types

The functionality of CSS transitions may be affected when dynamically adding a class

How can I suggest the return type of a function that is out of my control?

What steps can be taken to resolve an ESLing error in this situation?