node/js es6“类”从函数继承原型（链）

Question

是否可以从 es6 类定义中的函数 inerhit 原型链？

const { PassThrough } = require("stream");
const duplexer = require("duplexer3");


class Interface {

    constructor(obj, options) {

        options = Object.assign({
            decodeStrings: false,
            autoClose: false,
            objectMode: true
        }, options);

        let reader = new PassThrough(options);
        let writer = new PassThrough(options);


        // use duplex stream as prototype
        this = duplexer(options, reader, writer);



        Object.assign(this, obj);

    };

};


const iface = new Interface({
    _id: "60891a02256c0c7931395c48",
    settings: {
        port: 8080,
        host: "127.0.0.1"
    }
});

this = duplexer(options, reader, writer);

给我错误：

        this = duplexer(options, reader, writer);
        ^^^^

SyntaxError: Invalid left-hand side in assignment
    at Object.compileFunction (vm.js:344:18)
    at wrapSafe (internal/modules/cjs/loader.js:1048:15)
    at Module._compile (internal/modules/cjs/loader.js:1082:27)
    at Object.Module._extensions..js (internal/modules/cjs/loader.js:1138:10)
    at Module.load (internal/modules/cjs/loader.js:982:32)
    at Function.Module._load (internal/modules/cjs/loader.js:875:14)
    at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:71:12)
    at internal/main/run_main_module.js:17:47

如果我使用extends 和super，它可以工作，但我在接口对象上有双工器流的属性，但我想“隐藏”它们，在原型链的上层。

class Interface extends duplexer {

    constructor(obj, options) {

        options = Object.assign({
            decodeStrings: false,
            autoClose: false,
            objectMode: true
        }, options);

        let reader = new PassThrough(options);
        let writer = new PassThrough(options);

        super(options, reader, writer)
        Object.assign(this, obj);

    };

};

不确定，如果这是可能的或者我理解正确，但是当我从其他类/对象中获取某些属性时，它们“停留”在其原始对象范围内，当我想访问它们时，引擎“看起来" 向上直到找到一个属性，如果没有，它的undefined。

我的目标是拥有干净的“交互”对象实例，将属性传递给我的构造函数，并且仍然能够使用 node.js 流特定方法（读/写/等）

感谢您的帮助。

编辑：我找到了使用代理对象的解决方法：

class Root {
    constructor() {
        this.root = true;
    }
    rootMethod() {
        console.log("i am root");
    }
}


class Parent extends Root {
    constructor() {
        super();
        this.parent = true;
    }
    parentMethod() {
        console.log("i am parent");
    }
}

class Child extends Parent {
    constructor() {
        super();
        this.child = true;
    }
    childMethod() {
        console.log("i am child")
    }
}


class Interface {
    constructor() {
        this.settings = {
            host: "0.0.0.0",
            port: 8030
        }
    }
}

const root = new Root();
const parent = new Parent();
const child = new Child();
const iface = new Interface();


const proxy = new Proxy(child, {
    get: function (target, prop) {

        if (target[prop]) {
            return target[prop];
        } else {
            return iface[prop];
        }

    }
});


//console.log(root, root.rootMethod);
//console.log(parent, parent.parentMethod);
//console.log(child, child.childMethod);

console.log(proxy.settings, proxy.rootMethod)

这会检查代理对象上是否存在属性，如果不存在，则尝试访问隐藏对象上的属性。

Answer 1

这是肯定的。你只需要修改子类的原型原型，就可以了。

查看代码：

class Interface {}
Object.setPrototypeOf(Interface.prototype, Duplex.prototype)
const instance = new Interface
// you are able to call method from Duplex
instance.someMethodFromDuplex()