Question

我正在写一些扩展父类的JS，我想知道是否有一种方法可以判断一个子类是否使用了父方法而没有调用它。理想情况下，我想在父项的构造函数中运行检查，以查看是否有任何子方法正在使用方法定义中的父方法。

我做了一些研究并遇到过像Object.getOwnPropertyNames()这样的事情，但我不确定我是否朝着正确的方向前进。

例如：

class Path {

    constructor (name) {
        // how can I check if addRelationship have been used? If possible.
        this.relationships         = {};
        this.currentRelationship   = '';
        this.path                  = path;
    }

    addRelationship (relationship) {
        // do something
        this.currentRelationship = relationship.path;

        return this;
    }

    makePath () {
        let path = [this.path];

        if(this.currentRelationship) {
            path.push(this.currentRelationship)
        }

        return path.join("/");
    }

}

class OnePath extends Path {
    // ...
    someMethodFromThatRelationship () { }
}

class TwoPath extends Path {
    // ...
}

var onePath = new OnePath('one');
var twoPath = new TwoPath('two-path');

class SomeOtherPath extends Path {

    one () {
        return this.addRelationship(onePath);
    }

    two () {
        return this.addRelationship(twoPath);
    }

}

上述示例的想法是我可以检查是否在任何方法中引用了addRelationship，如果是，请在this.relationships.one和{{之前注册this.relationships.two和one() 1}}实际上是被调用的。我希望我有道理。我很想知道这是否可能。

更新

上述代码的最终结果是能够执行以下操作：

two()

Answer 1

有没有办法告诉子类是否在没有调用它的情况下使用父方法？

没有。确定哪些程序在不调用它们的情况下执行操作等同于无法解析的halting problem。

Answer 2

我认为你实际上正在寻找的是一种更具声明性的方法，可以一次性创建关系及其伴随方法。不要使用太多的魔法（父构造函数检查其子类代码肯定会），但要明确。

class Path {
    constructor (path) {
        this.relationships         = {};
        this.currentRelationship   = '';
        this.path                  = path;
    }
    addRelationship (name, relationship) {
        this.relationships[name] = relationship;
        this[name] = function() {
            // do something
            this.currentRelationship = name;
            return this.relationships[name];
        }
        return this;
    }

    makePath () {
        let path = this.path;
        if (this.currentRelationship) {
            path += "/" + this.relationships[this.currentRelationship].makePath();
        }
        return path;
    }
}

class SomeOtherPath extends Path {
    constructor(name) {
        super(name);
        this.addRelationship("one", new OnePath('one'));
        this.addRelationship("two", new TwoPath('two-path'));
    }
}

甚至

class Path {
    constructor (path, relationships = {}) {
        this.relationships         = relationships;
        this.currentRelationship   = '';
        this.path                  = path;

        for (let const r in relationships)
            this.addRelationship(r, relationships[r]);
    }
    …
}

class SomeOtherPath extends Path {
    constructor(name) {
        super(name, {
           one: new OnePath('one'),
           two: new TwoPath('two-path')
        });
    }
}

如果他们没有其他方法或只实例化一次（作为单身人士），也许你甚至不再需要这些子类。

请注意，上述方法将在构造函数的每个实例化上创建新方法和新子路径，如果您不希望您当然也可以静态地将该声明放在类上。只需使addRelationShip成为静态方法，初始化默认的relationships对象，并将方法放在类.prototype上。模式的变化是无穷无尽的。

您甚至可能希望尝试使用建议的decorators feature类。

javascript - 检查子方法

2 个答案: