Javascript TypeScript动态类-合并/删除

我试图创建一个动态类，它是使用许多其他可能类的组件构建的

我试图使用ES6 Object.assign（）添加和删除它们，并且可以获取要复制的变量，但似乎无法获取要复制的方法

下面是我尝试做的一个例子：

class foo {
  salad: string = 'salad';
  chop(){
    console.log('Chop');
  }
}

class man {
  nuts: string = 'nuts';
  kick(){
    console.log('Kick')
  }
}

class choo {
  add(){
    var f: foo = new foo();
    var m: man = new man();
    //Copy variables
    Object.assign(this, f, m);
    //Copy methods
    //Object.assign(this.prototype, f, m);
  }
  remove(){
    d = Object.getPrototypeOf(foo);
    for (key in d){
        delete this[key]
    }
  }
}

var karate = new choo();
karate.add();

//karate.chop();
console.log(karate.salad);
//karate.kick();
console.log(karate.nuts);

我试着找一个例子来分享，但没有成功。不工作的代码将被注释掉

ES6建议使用Object.assign（this.prototype，obj1）将原型函数从一个类复制到另一个类，但TypeScript似乎不喜欢它

---

有什么想法吗？

这完全是一种黑客行为，但它似乎能满足您的需求：

function extend < A, B > (d: A,
b: B) {
    for (var x in b) d[x] = b[x];
    return <A & B > d;
}

interface Object {
    assign < P, Q > (a: P,
    ...b: Q[]): P & Q;
}

interface ifoo {
    salad: string;
    chop();
}

interface iman {
    nuts: string;
    kick();
}

class foo implements ifoo {
    salad: string = 'salad';
    chop() {
        console.log('Chop');
    }
}

class man implements iman {
    nuts: string = 'nuts';
    kick() {
        console.log('Kick')
    }
}

class choo {
    foo: foo;
    man: man;
    add() {
        return extend(this, extend(this.foo = new foo(), this.man = new man()));        
    }
    remove() {
        Object.keys(this.man).forEach(k => delete this[k]);
        return <ifoo><any>this;
    }
}


let both = new choo();
var karate = both.add();
console.log("karate", karate);
karate.chop();
console.log(karate.salad);
karate.kick();
console.log(karate.nuts);

let chooman = both.remove();
console.log("karate", karate);
chooman.chop();

函数扩展（d:A，
b:b）{
对于（b中的var x）d[x]=b[x]；
返回d；
}
接口对象{
分配（a:P，
…b:Q[]）：P&Q；
}
接口ifoo{
沙拉：细绳；
斩（）；
}
接口iman{
坚果：细绳；
踢（）；
}
类foo实现了ifoo{
沙拉：字符串=‘沙拉’；
印章（）{
控制台日志（“印章”）；
}
}
class-man实现了iman{
螺母：字符串='nuts'；
踢{
console.log（'Kick'））
}
}
choo班{
富:富,；
男人：男人；
添加（）{
返回extend（this，extend（this.foo=newfoo（），this.man=newman（））；
}
删除（）{
Object.keys（this.man）.forEach（k=>删除这个[k]）；
归还这个；
}
}
让两者都=new choo（）；
var karate=both.add（）；
控制台日志（“空手道”，空手道）；
空手道；
控制台。原木（空手道。沙拉）；
空手道；
控制台。原木（空手道。螺母）；
让chooman=both.remove（）；
控制台日志（“空手道”，空手道）；
chooman.chop（）；

首先，我要指出，mixin可能是我想要做的事情的正确答案

下面是一篇关于mixin的好文章：

话虽如此，我还是想出了一个使用

Object.assign（）

的解决方案，尽管直接对

\uuuuuu proto\uuuuuu

进行变异可能会让人有点不悦

Choo现在看起来像这样：

class choo {
  add(){
    var f: foo = new foo();
    var m: man = new man();
    //Copy variables
    Object.assign(this, f, m);
    //Copy methods
    Object.assign(this.__proto__, foo.prototype, man.prototype);
  }
}

---

remove（）

方法已被删除，因为

Object.assign（）

将覆盖类方法（如果它们共享相同的名称）。在测试之前，我不确定这是否会有问题。

从表面上看，您正在尝试进行多重继承。我会先调查一下。注意：我不建议动态多重继承，因为Typescript不会理解它。我还建议您查看实际生成的js，看看为什么

Object.assign

不起作用。