What is the difference between instanceof Parent and instanceof super.constructor?

Question

I got a class Parent, and a class Child extending Parent. In Parent's constructor I need now to determine if x is an instance of the original class or of the child class.

As in my case Parent is actually anonymous I'm using instanceof of this.constructor which isn't working as expected:

class Parent {
  constructor(x) {
    if (x instanceof this.constructor) {
      console.log("x is instanceof of this.constructor");
    }
    if (x instanceof Parent) {
      console.log("x is instanceof of Parent");
    }
  }
}

class Child extends Parent {
  constructor(x) {
    super(x);
  }
  foo(x) {
    new this.constructor(new super.constructor(x))
  }
}

Calling

new Child().foo()

now yields x is instanceof of Parent but not x is instanceof of this.constructor. What am I doing wrong and how can I fix this without using x is instanceof of *Parent*?

---

The reason for all this is that I'm wrapping my class definition so that I can create a new instance without new. The class is assigned to Parent after wrapping/mutating, so the class that is wrapped should be anonymous.

I don't know if that makes any sense, and my reduced example may fail to make clear what's the point of all this, but apart from the one issue explained above it's actually quite handy:

X()   // create new instance of Parent without new
X.f   // access static methods

const { X, c: Parent } = function (c) {
    return {
        X: Object.assign(
            function () {
                return new c(...arguments);
            },
            _.pick(c, Object.getOwnPropertyNames(c)  // using lodash here
                .filter(n => typeof c[n] === "function")
            )
        ),
        c
    };
}(class {
  constructor(x) {
    if (x instanceof this.constructor) {
      console.log("x is instanceof of this.constructor");
    }
    if (x instanceof Parent) {
      console.log("x is instanceof of Parent");
    }
  }
})

class Child extends Parent {
  constructor(x) {
    super(x);
  }
  foo(x) {
    new this.constructor(new super.constructor(x))
  }
}

Answer 1

Firstly the bindings of Parent and Child identifiers are the Parent and Child class constructor functions and constant. When used as the first parameter of Object.assign, the Parent binding has not been created but while methods are being assigned to function c, the function is not actually called. So when it comes to calling class constructor code later, both Parent and Child variables refer to the appropriate class constructor.

Hence

class {
  constructor(x) {
    if (x instanceof Parent) {
      console.log("x is instanceof of Parent");
      if( x instance of Child) {
      console.log("x is instance of Child");
    }
  }
}

should indicate if the parameter is an instance of Parent or Child. Of course because the class extension puts Parent.prototype at the head of Child.prototype's inheritance chain, every instance of Child it is also an instance of Parent.

The results obtained from code examining instanceof values are as to be expected:

1. foo creates an [Object Parent] object parameter to pass to the Child constructor

2. Child calls the super constructor with the supplied parameter taking the form:

     super([Parent Object])
   

   but with the this value seen by super set to the new Child object instance.

3. In the super constructor the [Object Parent] x argument is not an instance of this.constructor, which is Child, so no message saying so is generated.

You may wish to see if the full code could be simplified by using less complexity, along the structural lines of:

 class Parent {..........}
 class Child extends Parent {.....}
 const X = Object.assign(.......)