ES6: this within static method

Question

Let's say I have two ES6 classes like this:

class Base {
    static something() {
        console.log(this);
    }
}

class Derived extends Base {
}

And then I make a call like this:

Derived.something();

Note that I am making a call to a static method defined on the super class via sub class.

This does not give me errors. It prints

[Function: Derived]

So accessing this within a static method seems to work here.

I need a common static method for all sub-classes of a super class and I need to be able to know what sub-class is calling this method.

Now my question is whether using this within a static method is legal. I know these static methods become class methods, and hence this would naturally point to the class object they are called on. (The class object being the constructor.)

But I can't seem to find any definitive resource that states that this is allowed by the ES specification.

This looks like a good introduction to ES6 classes but does not talk about this with static.

`this` works exactly like in any other non-arrow function: It's value depends on how the function is called. A static class method is a function like any other. That's probably the reason why you don't find anything specific about it. — Felix Kling, May 11 '18 at 05:11

JLRishe · Answer 1 · 2018-05-11T05:20:30.840

10

Under typical circumstances, the this in any call to something.method() will refer to something as long as the function is not an arrow function, bound function, or something like that (and it is neither of those in this case).

Class inheritance, or even ES6, aren't really relevant here. All you need to know is that you are calling Derived.something(), so this will refer to Derived.

edited May 11 '18 at 05:20

answered May 11 '18 at 05:02

JLRishe

99,490
19
131
169

score 8 · Answer 2 · answered May 11 '18 at 05:17

Yes, this is legal in static methods, that's the way this should be done.

this refers to class instance in prototype methods and refers to class constructor in static methods, unless a method was unbound from its original context.

Similarly, super refers to parent class prototype in instance methods and refers to parent class constructor in static methods.

score 0 · Answer 3 · edited Jun 20 '20 at 09:12

As long as the static method is invoked as a member expression, e.g.

Derived.something();

as opposed to

const { something } = Derived;
something();

then this will refer to Derived. Derived.something() is identical to something.call(Derived) if Derived.something is stored to an intermediate variable, because that's how a member expression with a nested call expression is evaluated, essentially.

ES6: this within static method

3 Answers3

Linked

Related