特定用例

Question

如果我理解正确，object.hasOwnProperty()应该在父类的继承属性上返回false。但是，以下代码在自身和继承的属性上返回true。

我的理解/代码是否不正确或hasOwnPropery()不正确？如果是我，我如何区分自己和继承的属性？

修改：我已将用例添加到示例代码中。

我希望孩子的fromDb()只关注自己的属性，而是覆盖父级fromDb()设置的属性。

class Parent {
    parentProp = '';
    fromDb(row: {}) {
        for (const key of Object.keys(row)) {
            if (this.hasOwnProperty(key)) {
                if (key === 'parentProp') {
                    // Do some required data cleansing
                    this[key] = row[key].toUpperCase()
                } else {
                    this[key] = row[key];
                }
            }
        };
        return this;
    }
}

class Child extends Parent {
    childProp = '';
    fromDb(row: {}) {
        super.fromDb(row);
        for (const key of Object.keys(row)) {
            if (this.hasOwnProperty(key)) {
                this[key] = row[key];
            }
        };
        return this;
    }
}

let row = {
    parentProp: 'parent',
    childProp: 'child',
}

let childObj = new Child().fromDb(row);
console.log(childObj);

控制台：

Child:
    childProp: "child"
    parentProp: "parent"

Answer 1

在生成的extends代码中，属性将复制到子类，如下所示：

function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };

这意味着您的子类（d）被赋予了它自己的属性。

这与使用纯JavaScript继承没有什么不同：

function Parent() {
    this.parentProp = `I'm defined by Parent`;
}

function Child() {
  Parent.call(this);
  this.childProp = `I'm defined by Child`;
}

let childObj = new Child();

for (const key of Object.keys(childObj)) {
    console.log(key, childObj.hasOwnProperty(key));
}

如果你就我们需要达到的目标给出一些指示，我相信我们会为你找到一个能够克服这个障碍的合适机制。

特定用例

对于您的特定用例，您可以通过调用超类的位置设置“胜出”的先例。

获取输出

childProp: "child"
parentProp: "PARENT"

让父母跑“第二”，而不是“第一”：

class Child extends Parent {
    childProp = '';
    fromDb(row: {}) {
        for (const key of Object.keys(row)) {
            if (this.hasOwnProperty(key)) {
                this[key] = row[key];
            }
        };

        super.fromDb(row); // <-- last update wins
        return this;
    }
}

超级动态属性资料

这将从父级动态排除子键和子键中的父键...添加console.log语句以查看内部...

class Parent {
    parentProp = '';
    fromDb(row: {}) {

        const ownKeys = Object.keys(new Parent());

        for (const key of Object.keys(row)) {
            if (ownKeys.indexOf(key) > -1) {
                if (key === 'parentProp') {
                    // Do some required data cleansing
                    this[key] = row[key].toUpperCase()
                } else {
                    this[key] = row[key];
                }
            }
        };
        return this;
    }
}

class Child extends Parent {
    childProp = '';
    fromDb(row: {}) {
        super.fromDb(row);

        const ownKeys = this.getKeys();

        for (const key of Object.keys(row)) {
            if (ownKeys.indexOf(key) > -1) {
                this[key] = row[key];
            }
        };
        return this;
    }

    getKeys() {
        const childKeys = Object.keys(this);
        const parentKeys = Object.keys(new Parent());

        return childKeys.filter( function( el ) {
             return parentKeys.indexOf( el ) < 0;
        });
    }
}

let row = {
    parentProp: 'parent',
    childProp: 'child',
}

let childObj = new Child().fromDb(row);
console.log(childObj);

Answer 2

类是旧的构造函数语法的语法糖。类中定义的属性始终是实例属性，编译为构造函数中设置的值：

function Parent() {
    this.parentProp = "I'm defined by Parent";
}

该属性不是来自原型，它是构造函数中this上设置的实例属性。原型上只共享方法。如果您想要共享属性，则必须声明它们static;但是他们是一个阶级财产而不是原型。

Typescript：object.hasOwnProperty（）在继承的属性上显示true。为什么？

2 个答案:

特定用例

超级动态属性资料