class-methods-use-this
Enforce that class methods utilize
this
.
This rule extends the base eslint/class-methods-use-this
rule.
It adds support for ignoring override
methods or methods on classes that implement an interface.
How to Use
module.exports = {
"rules": {
// Note: you must disable the base rule as it can report incorrect errors
"class-methods-use-this": "off",
"@typescript-eslint/class-methods-use-this": "error"
}
};
Try this rule in the playground ↗
Options
See eslint/class-methods-use-this
options.
This rule adds the following options:
interface Options extends BaseClassMethodsUseThisOptions {
ignoreOverrideMethods?: boolean;
ignoreClassesThatImplementAnInterface?: boolean | 'public-fields';
}
const defaultOptions: Options = {
...baseClassMethodsUseThisOptions,
ignoreOverrideMethods: false,
ignoreClassesThatImplementAnInterface: false,
};
ignoreOverrideMethods
Makes the rule to ignores any class member explicitly marked with override
.
Example of a correct code when ignoreOverrideMethods
is set to true
:
class X {
override method() {}
override property = () => {};
}
Open in PlaygroundignoreClassesThatImplementAnInterface
Makes the rule ignore class members that are defined within a class that implements
a type.
If specified, it can be either:
true
: Ignore all classes that implement an interface'public-fields'
: Ignore only the public fields of classes that implement an interface
It's important to note that this option does not only apply to members defined in the interface as that would require type information.
true
Example of correct code when ignoreClassesThatImplementAnInterface
is set to true
:
class X implements Y {
method() {}
property = () => {};
}
Open in Playground'public-fields'
Example of incorrect code when ignoreClassesThatImplementAnInterface
is set to 'public-fields'
:
- ❌ Incorrect
- ✅ Correct
class X implements Y {
method() {}
property = () => {};
private privateMethod() {}
private privateProperty = () => {};
protected privateMethod() {}
protected privateProperty = () => {};
}
Open in Playgroundclass X implements Y {
method() {}
property = () => {};
}
Open in PlaygroundWhen Not To Use It
If your project dynamically changes this
scopes around in a way TypeScript has difficulties modeling, this rule may not be viable to use.
You might consider using ESLint disable comments for those specific situations instead of completely disabling this rule.