Detect direct instances in JavaScript

Question

A couple of years ago, I wanted figure how to create a type check for class A that returns true only for objects instantiated by new A(). For this, I wrote the class like this:

class A {
  static #instances = new WeakSet();

  static isInstance (value) {
    return A.#instances.has(value);
  }

  constructor () {
    if (new.target === A) {
      A.#instances.add(this);
    }
  }
}

Any instance of a class that extends A thus would return false when passed to A.isInstance. But, then I realized that this can be faked by using Reflect.construct(B, [], A). What I did, then, was create a proxy whose construct trap would only pass A as newTarget if it met some condition. I've been trying to recall what that condition was, but while experimenting to rediscover it, I'm beginning to think that my old solution might not've worked.

Is there some way to achieve my desired effect here?

"I realized that this can be faked" - I'm pretty sure that whatever solution you come up with it can be faked - if nothing else by simply overwriting A.isInstance. So what's your concrete requirements, what's your actual use case? What goal do you try to achieve by checking "only for objects instantiated by new A()"? — Bergi
– Bergi, Commented Jun 11, 2024 at 2:11
@Bergi Whether they change A.isInstance or not is outside the scope of the question. Pretend the class is frozen, pretend it's a global variable, pretends it's preserved in behind-the-scenes code like Node's library, and so on. — Melab
– Melab, Commented Jun 11, 2024 at 4:09
So what's wrong with extending your class? How is new (class B extends A {}) different than new function B() { return new A() }? Why do you need to prevent it? — Bergi
– Bergi, Commented Jun 11, 2024 at 11:04
So what about Reflect.constructor(A, [])? Do you consider that to not be created by new A() either? Again, why do you care? A new B() is indistinguishable from a new A() whose prototype chain was messed with or that got extra properties added. — Bergi
– Bergi, Commented Jun 13, 2024 at 20:03
That thing is pretty much the same as a private field. The isInstance code in your question does work for that criterion already. "I realized that this can be faked by using Reflect.construct(B, [], A)" - only if B calls A (e.g. via super()). Same for subclasses of Set. — Bergi
– Bergi, Commented Jun 20, 2024 at 1:09

Alexander Nenashev · Accepted Answer · 2024-06-11 11:00:32Z

Seems there's no obvious clean way to do it

You can monkey patch Reflect.construct to catch when the prototype is overridden
You can try to check the call stack and look whether the caller is another constructor (should be available in the class' scope (which could be problematic, you could use the option 1 to help with it )):

class A {
  static #instances = new WeakSet();

  static isInstance (value) {
    return A.#instances.has(value);
  }

  constructor() {

    if (new.target === A) {
      try{
        throw new Error;
      }catch(e){
        // parse function names (in FF the stack is different)
        const [a, b] = e.stack.match(/\w+(?=\s*\()/gm);
        const fn = eval(b);
        if(fn?.toString().includes('extends A')) return;
      }
      A.#instances.add(this);
    }
  }
}

class B extends A{}

const b = Reflect.construct(B, [], A);
console.log(A.isInstance(b));

const a = new A;
console.log(A.isInstance(a));

Collectives™ on Stack Overflow

Detect direct instances in JavaScript

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related