Equality between proxy and target

Question

The Javascript proxy function offers some interesting debugging features. For example, you can “protect” an object by placing it behind a proxy with a handler getthat issues if you access the undefined property. This helps to catch typos and other kinds of errors.

This can be used something like this:

class Something {
    constructor()
    {
        this.foo = "bar";

        allObjects.push(this);
    }
};

function defend(o)
{
    return new Proxy(o, DebugCheckHandler);
};

let rawSomething = new Something();
let defendedSomething = defend(rawSomething);

Code can be written diligently for use in terms only defendedSomething. However, in this example, the constructor Somethinggoes thissomewhere else (before allObjects). This results in the same effect as the use of rawSomethingand defendedSomethingfor the code base.

- , , rawSomething !== defendedSomething. , allObjects.includes(defendedSomething) false, rawSomething, includes ===.

, ?

Answer 1

Iirc, this - - . ( ), :

function Defended() {
    return new Proxy(this, DebugCheckHandler);
//                   ^^^^ will become the subclass instance
}

class Something extends Defended {
//              ^^^^^^^^^^^^^^^^ these…
    constructor() {
        super();
//      ^^^^^^^ …should be the only changes necessary
//      and `this` is now a Proxy exotic object
        this.foo = "bar";

        allObjects.push(this);
    }
};

let defendedSomething = new Something();

Answer 2

, new [[Construct]], , :

• , prototype .
• .
• , - this.

function Something() {
  this.foo = "bar";
  allObjects.push(this);
}
function defendIntanceOf(C) {
  var p = new Proxy(Object.create(C.prototype), DebugCheckHandler);
  C.call(p);
  return p;
};
let defendedSomething = defendIntanceOf(Something);

. 1, Function.call [[Call]] this.