Which is better suitable in TypeScript generics: void, never, or undefined?

Question

Which is better suitable in TypeScript generics: void, never, or undefined?

Curious about this topic. I am seeking a definitive answer to clarify my understanding.

My goal is to specify to the compiler/language service/reader that T should be absolutely nothing, empty, or null. I am unsure whether void, never, or undefined is the most appropriate choice.

// indicating that there should be no props available
class MyComponent extends React.Component<???, any> { ... }

// indicating that the Promise should resolve to nothing
function foo(): Promise<???> { ... }

(If you can think of other scenarios where void, never, or undefined should be used in generics, please let me know so I can add them to this list)

Related questions: What is the difference between never and void in typescript?

Based on the information from the above link and the response from @mierion-hughes, it appears that never is straightforward. The remaining dilemma is between void and undefined.

typescript

Answer 1

Answer №1

Your query seems a bit unclear, and I am not entirely convinced by this response.

In my view, the best approach would involve making the constructor argument optional, using `never` or `void` as alternatives.

https://i.sstatic.net/vKXlo.png

The issue arises when utilizing `void` or `never`, as both ultimately result in the argument type being `undefined`. Unfortunately, this allows for the possibility of still passing `undefined`, with no apparent solution to prevent it.

Expanding on this concept: If excluding the property from the instance is desired, omitting the `public` keyword on the argument is necessary:

class Foo<T>{
  prop: T;
  constructor(prop?: T) {
    if (prop != undefined)
      this.prop = prop;
  }
}

let foo = new Foo<never>(undefined);

for (let key in foo) {
   console.log(key); //outputs: nothing
}

console.log(foo);  //outputs:  Foo {}

Answer 2

Your query seems a bit unclear, and I am not entirely convinced by this response.

In my view, the best approach would involve making the constructor argument optional, using `never` or `void` as alternatives.

https://i.sstatic.net/vKXlo.png

The issue arises when utilizing `void` or `never`, as both ultimately result in the argument type being `undefined`. Unfortunately, this allows for the possibility of still passing `undefined`, with no apparent solution to prevent it.

Expanding on this concept: If excluding the property from the instance is desired, omitting the `public` keyword on the argument is necessary:

class Foo<T>{
  prop: T;
  constructor(prop?: T) {
    if (prop != undefined)
      this.prop = prop;
  }
}

let foo = new Foo<never>(undefined);

for (let key in foo) {
   console.log(key); //outputs: nothing
}

console.log(foo);  //outputs:  Foo {}

Which is better suitable in TypeScript generics: void, never, or undefined?

Answer №1

Similar questions

Developing a dynamic object in Typescript to structure and optimize API responses

Playing around with Segment Analytics testing using Jest in TypeScript

TypeScript error: Cannot find property 'propertyName' in the 'Function' type

The issue with the antd Input component's onChange event not updating state correctly when using a list fetched from an axios get request in a React

The Server Components render encountered a glitch

Utilizing TypeScript to mandate properties in a React component

Building a table with Next.js

Guide to incorporating @types/module with the corresponding npm module that has type definitions available

Ways to customize the OverridableComponent interface within Material-UI

Is there a way for me to showcase a particular PDF file from an S3 bucket using a custom URL that corresponds to the object's name

A step-by-step guide on incorporating MarkerClusterer into a google-map-react component

Dealing with precompile array warning when utilizing a basic router in Angular 2

I am encountering an issue where my TSX import is being declared but not read when I attempt to pass it to the Jest render method. Can anyone explain

Enhance your AJAX calls with jQuery by confidently specifying the data type of successful responses using TypeScript

Transforming an Established React Project into a Progressive Web Application

Importing Angular Material modules

Error: The template could not be parsed due to the following issues: Element 'mat-card' is not recognized

Messages are not being emitted from the socket

Calculating numbers with Math.ceil will result in an increase of 1

Is there a way to ensure that in React (Typescript), if a component receives one prop, it must also receive another prop?