no-invalid-void-type
Disallow
void
type outside of generic or return types.
Extending "plugin:@typescript-eslint/strict"
in an ESLint configuration enables this rule.
void
in TypeScript refers to a function return that is meant to be ignored.
Attempting to use a void
type outside of a return type or generic type argument is often a sign of programmer error.
void
can also be misleading for other developers even if used correctly.
The
void
type means cannot be mixed with any other types, other thannever
, which accepts all types. If you think you need this then you probably want theundefined
type instead.
module.exports = {
"rules": {
"@typescript-eslint/no-invalid-void-type": "error"
}
};
Try this rule in the playground ↗
Examples
- ❌ Incorrect
- ✅ Correct
type PossibleValues = string | number | void;
type MorePossibleValues = string | ((number & any) | (string | void));
function logSomething(thing: void) {}
function printArg<T = void>(arg: T) {}
logAndReturn<void>(undefined);
interface Interface {
lambda: () => void;
prop: void;
}
class MyClass {
private readonly propName: void;
}
Open in Playgroundtype NoOp = () => void;
function noop(): void {}
let trulyUndefined = void 0;
async function promiseMeSomething(): Promise<void> {}
type stillVoid = void | never;
Open in PlaygroundOptions
This rule accepts the following options:
type Options = [
{
/** Whether a `this` parameter of a function may be `void`. */
allowAsThisParameter?: boolean;
/** Whether `void` can be used as a valid value for generic type parameters. */
allowInGenericTypeArguments?:
| [string, ...string[]]
/** Whether `void` can be used as a valid value for generic type parameters. */
| boolean;
},
];
const defaultOptions: Options = [
{ allowAsThisParameter: false, allowInGenericTypeArguments: true },
];
allowInGenericTypeArguments
Whether void
can be used as a valid value for generic type parameters.
Alternatively, you can provide an array of strings which whitelist which types may accept void
as a generic type parameter.
Any types considered valid by this option will be considered valid as part of a union type with void
.
This option is true
by default.
The following patterns are considered warnings with { allowInGenericTypeArguments: false }
:
logAndReturn<void>(undefined);
let voidPromise: Promise<void> = new Promise<void>(() => {});
let voidMap: Map<string, void> = new Map<string, void>();
Open in PlaygroundThe following patterns are considered warnings with { allowInGenericTypeArguments: ['Ex.Mx.Tx'] }
:
logAndReturn<void>(undefined);
type NotAllowedVoid1 = Mx.Tx<void>;
type NotAllowedVoid2 = Tx<void>;
type NotAllowedVoid3 = Promise<void>;
Open in PlaygroundThe following patterns are not considered warnings with { allowInGenericTypeArguments: ['Ex.Mx.Tx'] }
:
type AllowedVoid = Ex.Mx.Tx<void>;
type AllowedVoidUnion = void | Ex.Mx.Tx<void>;
Open in PlaygroundallowAsThisParameter
Whether a this
parameter of a function may be void
.
This pattern can be useful to explicitly label function types that do not use a this
argument. See the TypeScript docs for more information.
This option is false
by default.
The following patterns are considered warnings with { allowAsThisParameter: false }
but valid with { allowAsThisParameter: true }
:
function doThing(this: void) {}
class Example {
static helper(this: void) {}
callback(this: void) {}
}
Open in PlaygroundWhen Not To Use It
If you don't care about if void
is used with other types, or in invalid places, then you don't need this rule.