Ignore self binding in prefer-prototype-methods

[fisker]

this.foo.bind(this) and foo.bar.bind(foo) is very common.

Even though ClassName.prototype.method.bind(this) make more sense, many people still prefer the old way as they are shorter and not really "borrowing" method, should we ignore it or check under an option?

[sindresorhus]

Agreed. We can add an option if someone asks.

[EvgenyOrekhov]

Could you clarify why does ClassName.prototype.foo.bind(this) make more sense, and why is it better than this.foo.bind(this)?
And which one is better: ClassName.prototype.foo.bind(this) or this.constructor.prototype.foo.bind(this)?

[fisker]

Could you clarify why does ClassName.prototype.foo.bind(this) make more sense, and why is it better than this.foo.bind(this)?

Because .foo() is a method from ClassName.prototype, same as you don't get .push() from [] but Array.prototype.

And which one is better: ClassName.prototype.foo.bind(this) or this.constructor.prototype.foo.bind(this)?

I think first one should be prefered, but if your class don't have a name to use, you can use the second one , not much difference.

[EvgenyOrekhov]

Hmm, this.foo.bind(this) is actually equivalent to this.constructor.prototype.foo.bind(this), NOT to ClassName.prototype.foo.bind(this).

See this example:

class Parent {
  constructor() {
    const foo = this.foo.bind(this);
    foo();
  }
  
  foo() {
    console.log("Parent foo");
  }
}

class Child extends Parent {
  foo() {
    console.log("Child foo");
  }
}

const child = new Child(); // logs "Child foo"

If you change it to const foo = Parent.prototype.foo.bind(this), it will log Parent foo, which is different from the original behavior.

But if you change it to const foo = this.constructor.prototype.foo.bind(this), it will still log Child foo, as expected.

That makes me think that this.constructor.prototype should be preferred over ClassName.prototype.

But this.constructor.prototype.foo.bind(this) looks way more wordy than this.foo.bind(this), and it even might be confusing to the ones who are familiar only with the this.foo.bind(this) syntax. So I think I would prefer to have an option to ignore self binding.

[fisker]

You are right about super classes. I'm thinking maybe we should only check [] and {}, it's the initial idea of this rule #1223, we are just doing too much now. And borrowing a method from another user defined class was rarely seen in a real world case.

[fisker]

People are disabling this rule https://github.com/search?q=prefer-prototype-method&type=commits

[alfaproject]

Was actually going to open an issue and then saw this. I'm also disabling this rule. At the very least, an option for self binding would be nice