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 .

Answer 1

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 .

Answer 2

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 .

Answer 3

As long as the static method is invoked as a member expression , eg

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.