Javascript ES6类中的访问器组合

假设我有一个

东西

类，我希望它既能

隐藏

又能

打开

通过组合使用类似的对象创建方法，我能够从多个类“继承”

这种方法不适用于访问器（getter/setter）。

我需要使用类，因为这是一项要求。我还发现我在类与类之间复制功能，但我不希望这些功能从基类继承

有什么想法吗

到目前为止，我取得的进展如下：

类可打开{
构造函数（isOpen=false）{
这个._isOpen=isOpen；
}
获取isOpen（）{
把这个还给我。_isOpen+“太蠢了。”；
}
设置等参线（值）{
这是一个数值；
}
}
类隐藏{
构造函数（isHidden=false）{
这个；
}
得到ishiden（）{
归还这个。_ishiden+“太愚蠢了。”；
}
设置isHidden（值）{
这是。_ishiden=值；
}
}
阶级事务{
构造函数（配置）{
设{isOpen，isHidden}=config；
let openable=新的openable（等参）；
this.isOpen=openable.isOpen；
let hiddeble=新的hiddeble（ishiden）；
this.ishiden=openable.ishiden；
}
}
让事物=新事物({
是的，
伊希登：错
});因为
isOpen
和
ishiden
都是访问器，所以您不能只获取它们的副本，必须在需要时访问它们

尽管如此，您仍然可以创建自己的
isOpen
，
ishiden
，它们使用底层的：

let openable = new Openable(isOpen);
Object.defineProperty(this, "isOpen", {
    get: () => openable.isOpen,
    set: value => {
        openable.isOpen = value;
    }
});

let hideable = new Hideable(isHidden);
Object.defineProperty(this, "isHidden", {
    get: () => hideable.isHidden,
    set: value => {
        hideable.isHidden = value;
    }
});


当然，如果您经常这样做，您会希望有一个辅助函数来设置它，而不是一直重新键入它：

function wrapProperty(dest, src, name) {
    Object.defineProperty(dest, name, {
        get: () => src[name],
        set: value => { src[name] = value; }
    });
}

（或者抓取属性描述符并更新它）

然后：


我想问一下，对于
Openable
和
hiddeable
必须使用
class
的要求。在我看来，它们更像是混合体。
因为
isOpen
和
ishiden
都是访问器，你不能只获取它们的副本，你必须在需要时访问它们

尽管如此，您仍然可以创建自己的
isOpen
，
ishiden
，它们使用底层的：

let openable = new Openable(isOpen);
Object.defineProperty(this, "isOpen", {
    get: () => openable.isOpen,
    set: value => {
        openable.isOpen = value;
    }
});

let hideable = new Hideable(isHidden);
Object.defineProperty(this, "isHidden", {
    get: () => hideable.isHidden,
    set: value => {
        hideable.isHidden = value;
    }
});


当然，如果您经常这样做，您会希望有一个辅助函数来设置它，而不是一直重新键入它：

function wrapProperty(dest, src, name) {
    Object.defineProperty(dest, name, {
        get: () => src[name],
        set: value => { src[name] = value; }
    });
}

（或者抓取属性描述符并更新它）

然后：


我想问一下，对于
Openable
和
hiddeable
必须使用
class
的要求。在我看来，它们更像是mixin。
除此之外，OP通过“伪私有属性”符号和
可打开的
/
可隐藏的
类的原型getter/setter的访问器方法已经存在疑问，
trait
s将最接近于将类用作
mixin
代理以满足文档需求这一同样值得怀疑的要求

只要JavaScript不提供本机特性，就必须坚持自己记忆中的任何一种特性

必须编写的mixin的
函数
体与
类的
构造函数
体足够接近。尽管如此，基于函数的mixin永远不会被实例化，而是必须始终通过
call
或
apply
应用于对象/类型

一个可能的解决方案，以这种mixin方法为特色，已经可靠地满足OP的需求，然后可能看起来像下面提供的示例代码


let
Openable=（函数openableMixinFactory（）{
让
defineProperty=Object.defineProperty，
isBoolean=（type=>（typeof type=='boolean'）；
返回函数openableMixinApplicator（isOpen=false）{
让
openableCompositeType=this，
getIsOpen=（（）=>isOpen），
setIsOpen=（value=>（（isBoolean（value）和&（isOpen=value））| |（void 0））；
定义属性（openableCompositeType，'isOpen'{
get:getIsOpen，
集合：setIsOpen，
可枚举：true
});
返回openableCompositeType；
};
}()),
Hideable=（函数hideableMixinFactory（）{
让
defineProperty=Object.defineProperty，
isBoolean=（type=>（typeof type=='boolean'）；
返回函数hideableMixinApplicator（isHidden=false）{
让
HIDEABLECOMPOLITYPE=此，
//getIsHidden=（（）=>isHidden），
getIsHidden=（（）=>[isHidden'很蠢。].join（''），
setIsHidden=（value=>（（isBoolean（value）和&（isHidden=value））| |（void 0））；
defineProperty（hideableCompositeType，'isHidden'{
get:getIsHidden，
set:setisheden，
可枚举：true
});
返回hideableCompositeType
};
}());
阶级事务{
构造函数（配置）{
让
{isOpen，isHidden}=config；
Openable.call（this，isOpen）；
隐藏。调用（此，isHidden）；
}
}
变量
thing=新事物（{isOpen:true/*，ishiden:false*/}）；
log（'thing:'，thing）；
log（'thing.isOpen:'，thing.isOpen）；
log（'thing.ishiden:'，thing.ishiden）；
log（'（thing.isOpen=“xyz”）：'，（thing.isOpen=“abc”）；
log（'（thing.ishiden=“xyz”）：'，（thing.ishiden=“xyz”）；
log（'thing.isOpen:'，thing.isOpen）；
log（'thing.ishiden:'，thing.ishiden）；
log（'（thing.isOpen=false）：'，（thing.isOpen=false））；
log（'（thing.ishiden=true）：'，（thing.ishiden=true））；
log（'thing.isOpen:'，thing.isOpen）；
log（'thing.ishiden:'，thing.ishiden）
.as控制台包装{max height:100%！important；top:0；}
除了OP通过“伪私有属性”表示法和
可打开的
/
可隐藏的
类的原型getter/setter的访问器方法已经有问题之外，
trait
s将