useThisInClassMethods

JavaScript (and super languages)

Summary

Rule available since: v2.4.15
Diagnostic Category: lint/nursery/useThisInClassMethods
This rule doesn’t have a fix.
The default severity of this rule is warning.
Sources:
- Same as class-methods-use-this

How to configure

1
{
2
  "linter": {
3
    "rules": {
4
      "nursery": {
5
        "useThisInClassMethods": "error"
6
      }
7
    }
8
  }
9
}

Description

Enforce that class methods utilize this.

Instance methods usually communicate that their behavior depends on instance state. When a class member never uses this, it can often be made static or moved outside the class to better reflect its intent.

This rule checks instance methods, getters, setters, and instance field initializers whose value is an arrow function or function expression. Constructors, static members, and static blocks are ignored.

Examples

Invalid

1
class A {
2
    foo() {
3
        console.log("Hello");
4
    }
5
}

code-block.js:2:5 lint/nursery/useThisInClassMethods ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ Expected this to be used by class method foo.
  
    1 │ class A {
  > 2 │     foo() {
      │     ^^^
    3 │         console.log(“Hello”);
    4 │     }
  
  ℹ Adding functions as class members can be a convenient way to organize code related to a class, but when those functions do not use instance state, it can be misleading to readers. Consider whether static or a module-level function would better communicate the intent of this code.
  
  ℹ If this member does not depend on instance state, make it static or move it outside the class.
  
  ℹ This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.

Valid

1
class A {
2
    foo() {
3
        this.value = "Hello";
4
    }
5
}

1
class A {
2
    static foo() {}
3
}

Options

`ignoreMethods`

A list of method names to ignore for this rule.

Default: []

1
{
2
  "linter": {
3
    "rules": {
4
      "nursery": {
5
        "useThisInClassMethods": {
6
          "options": {
7
            "ignoreMethods": [
8
              "render",
9
              "#serialize"
10
            ]
11
          }
12
        }
13
      }
14
    }
15
  }
16
}

In this example, render and #serialize are ignored, so the rule does not report these methods.

1
class Component {
2
    render() {}
3
    #serialize() {}
4
}

`ignoreOverrideMethods`

Whether to ignore override methods on subclasses.

Default: false

1
{
2
  "linter": {
3
    "rules": {
4
      "nursery": {
5
        "useThisInClassMethods": {
6
          "options": {
7
            "ignoreOverrideMethods": true
8
          }
9
        }
10
      }
11
    }
12
  }
13
}

In this example, the method in Derived is ignored because it is marked with override.

1
abstract class Base {
2
    abstract method(): void;
3
}
4

5
class Derived extends Base {
6
    override method() {} // ignored because it has `override`
7
}

`ignoreClassesWithImplements`

Controls how classes with an implements clause are handled.

Default: "none"

"none" checks classes with an implements clause the same way as any other class.
"all" ignores every eligible instance member in classes that implement an interface.
"public-fields" ignores only public eligible members in those classes. Protected and private members are still checked.

1
{
2
  "linter": {
3
    "rules": {
4
      "nursery": {
5
        "useThisInClassMethods": {
6
          "options": {
7
            "ignoreClassesWithImplements": "all"
8
          }
9
        }
10
      }
11
    }
12
  }
13
}

In this example, every eligible member in a class with an implements clause is ignored.

1
interface Service {
2
    run(): void;
3
}
4

5
class ServiceImpl implements Service {
6
    run() {}
7
}

1
{
2
  "linter": {
3
    "rules": {
4
      "nursery": {
5
        "useThisInClassMethods": {
6
          "options": {
7
            "ignoreClassesWithImplements": "public-fields"
8
          }
9
        }
10
      }
11
    }
12
  }
13
}

In this example, only public eligible members are ignored, so helper is still reported.

1
interface Service {
2
    run(): void;
3
}
4

5
class ServiceImpl implements Service {
6
    run() {}
7
    protected helper() {}
8
}

code-block.ts:7:15 lint/nursery/useThisInClassMethods ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ Expected this to be used by class method helper.
  
    5 │ class ServiceImpl implements Service {
    6 │     run() {}
  > 7 │     protected helper() {}
      │               ^^^^^^
    8 │ }
    9 │ 
  
  ℹ Adding functions as class members can be a convenient way to organize code related to a class, but when those functions do not use instance state, it can be misleading to readers. Consider whether static or a module-level function would better communicate the intent of this code.
  
  ℹ If this member does not depend on instance state, make it static or move it outside the class.
  
  ℹ This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.