(Typescript) Setter n'est pas appelé sur une sous-propriété d'une instance de classe

Question

C'est une question difficile qui, je le sais, est un problème pour beaucoup de programmes (j'aborderai cela à la fin). Je veux créer un setter personnalisé en tapuscrit, mais le type de données de la propriété en cours de définition n'est pas simplement un nombre, une chaîne, mais bien un objet de classe. Cela fonctionne bien - mais si une propriété de l'instance de classe est modifiée, le setter n'est pas appelé. Voici un exemple d'une telle situation:

//This class contains two properties 
class Point 
{ 
    public x : number; 
    public y : number; 

    constructor(x : number, y : number) { this.x = x; this.y = 0; } 
} 

//How here is another class that contains a Point 
//But it is private and a getter/setter is used 
class PointStore 
{ 
    private _foo : Point; 

    public get foo() : Point { return this._foo; } 

    //Here is the problem, the setter is only called when the whole of foo is changed 
    public set foo(n : Point) { this._foo = n; console.log("Foo has been set!"); } 

    constructor() { this._foo = new Point(0, 0); } 
} 

//Use case 
let bar : PointStore = new PointStore(); 

bar.foo = new Point(10, 10); //Logs "Foo has been set!" 
bar.foo.x = 20; //Doesn't log anything 

---

Le problème est assez clair de l'exemple, mais je veux simplement dire ceci:

Y at-il de toute façon autour du tout? Parce que je l'ai vu des API telles que Unity3D ils ont choisi de faire leur classe « Point » ont des membres que privés et pour que les données ne peut être réglé par le constructeur par exemple:

//the 'Unity' solution 
transform.position = new Vector2(10, 10); //Okay 
transform.position.x = 20; //Error 

Mais ce n'est pas du tout une solution parfaite au problème, car il rend la programmation avec la classe 'Point' beaucoup plus difficile à partir de ce moment.

Si quelqu'un a un truc pour résoudre ce problème, il serait grandement apprécié.

Answer 1

Le setter ne sera utilisé que si vous affectez une valeur à la propriété. Une façon de contourner cela est en utilisant Object.assign, comme ceci:

bar.foo = new Point(10, 10); 
bar.foo = Object.assign(bar.foo, {x: 20}) 

Vous pouvez aussi aller plus loin:

bar.foo = Object.assign(bar.foo, {x: {z: 20} }) 

Answer 2

Vous pouvez utiliser a Proxy pour que:

class PointStore { 
    private _foo: Point; 

    constructor() { 
     this.createProxy(new Point(0, 0)); 
    } 

    public get foo(): Point { return this._foo; } 

    public set foo(point: Point) { 
     this.createProxy(point); 
     console.log("Foo has been set!"); 
    } 

    private createProxy(point: Point) { 
     this._foo = new Proxy(point, { 
      set: function (target: Point, property: string, value: any) { 
       target[property] = value; 
       console.log("Foo has been set (using proxy)!"); 
       return true; 
      } 
     }); 
    } 
} 

(code in playground

Answer 3

La grande chose au sujet de tapuscrit est que, 2 types sont compatibles s'ils ont la même forme. Ainsi, en fonction de ce que vous avez décrit, je pense que cela semble correspondre au projet de loi et cela ne cassera pas votre code parce PointStore ici est compatible avec Point classe

class PointStore 
{ 
    private x : number; 
    private y : number; 

    constructor(x: number, y: number) { 
     this.x = x; 
     this.y = y; 
    }; 

    public get x() { return this.point.x; }; 

    public set x(x: number) { 
     // your custom logic here 
     this.point.x = x; 
    }; 

    // setter and getter for other y omitted 

}