classMethodsThis

Reports class methods that do not use this.

✅ This rule is included in the ts stylistic and stylisticStrict presets.

Class methods that don’t use this are often better suited as static methods or standalone functions. Instance methods that don’t access instance state can be misleading and suggest a design issue.

class 
class Calculator
Calculator {
  
Calculator.add(a: number, b: number): number
add(
a: number
a: number, 
b: number
b: number) {
    return 
a: number
a + 
b: number
b;
  }
}

class 
class Formatter
Formatter {
  
Formatter.format(value: string): string
format(
value: string
value: string) {
    return 
value: string
value.
String.trim(): string
Removes the leading and trailing white space and line terminator characters from a string.
trim().
String.toLowerCase(): string
Converts all the alphabetic characters in a string to lowercase.
toLowerCase();
  }
}

class 
class Handler
Handler {
  get 
Handler.type: string
type() {
    return "default";
  }
}

class 
class Processor
Processor {
  
Processor.handler: () => number
handler = () => {
    return 
var Math: Math
An intrinsic object that provides basic mathematics functionality and constants.
Math.
Math.random(): number
Returns a pseudorandom number between 0 and 1.
random();
  };
}

class 
class Calculator
Calculator {
  
Calculator.add(a: number, b: number): any
add(
a: number
a: number, 
b: number
b: number) {
    return this.
any
precision(
a: number
a + 
b: number
b);
  }
}

class 
class Calculator
Calculator {
  static 
Calculator.add(a: number, b: number): number
add(
a: number
a: number, 
b: number
b: number) {
    return 
a: number
a + 
b: number
b;
  }
}

function 
function add(a: number, b: number): number
add(
a: number
a: number, 
b: number
b: number) {
  return 
a: number
a + 
b: number
b;
}

class 
class Counter
Counter {
  private 
Counter.count: number
count = 0;

  get 
Counter.value: number
value() {
    return this.
Counter.count: number
count;
  }
}

class 
class Base
Base {
  
Base.method(): void
method(): void {}
}

class 
class Derived
Derived extends 
class Base
Base {
  override 
Derived.method(): void
method() {
    
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log("overridden");
  }
}

interface 
interface Handler
Handler {
  
Handler.handle(): void
handle(): void;
}

class 
class MyHandler
MyHandler implements 
interface Handler
Handler {
  
MyHandler.handle(): void
handle() {
    
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log("handled");
  }
}

Options

This rule is not configurable.

When Not To Use It

If your codebase has many classes that implement external interfaces or extend base classes where methods are expected to exist without using this, this rule may produce false positives. Some frameworks require instance methods for dependency injection or other patterns even when they don’t use this.

Equivalents in Other Linters

ESLint: class-methods-use-this@typescript-eslint/class-methods-use-this

Made with ❤️‍🔥 around the world by the Flint team and contributors.

classMethodsThis

Examples

Options

When Not To Use It

Further Reading

Equivalents in Other Linters