如何从javascript中的子原型调用Parent类的构造方法？

Question

下面是代码sn-p，我在构造函数中定义了'run'方法，这与原型中定义的'eat'方法不同。我如何从从 A1 继承的 B1 原型访问这个“运行”方法。我的意图是覆盖 B1 中的“运行”方法，我可以在其中使用 A1 的现有“运行”方法。有什么方法可以实现吗？

function A1() {
	this.run = function() {
		return 'A1 runs';
	}
};
A1.prototype.eat = function() {
	return 'A1 eats';
};

function B1() {
	A1.call(this);
};
B1.prototype = Object.create(A1.prototype); //new A1();

B1.prototype.eat = function() {
	return A1.prototype.eat.call(this) + ',B1 also eats'; 
}

B1.prototype.run = function() {
	var parentRun = this.constructor.run();
	 var result = parentRun + ",B1 also runs";
	 return result; 
};


var b1 = new B1();
b1.eat(); // It will give 'A1 eats, B1 also eats', which is fine
b1.run(); // It will give 'A1 runs', where I want 'A1 runs, B1 also runs'.

编辑 1： 我更新了代码 sn-p，删除了 console.log 并从每个方法返回了字符串。

最初我没有对此进行研究。一些人提到它与this 重复，我已经通过相同的链接，但我的问题完全不同。我知道如何调用我为“吃”所做的父类原型的方法。

我的查询很简单，
有什么方法可以访问Parent类的构造方法（'run'方法），而不是原型的方法（'eat'方法）？

Answer 1

三个问题：

1. A1 放置在实例上的 run 不会返回任何内容，因此调用它会产生 undefined。

2. A1 将run 放在实例 上，这意味着在您的b1 实例中，B1.prototype.run 已被run 遮挡，A1 直接分配给实例。

3. this.constructor.run() 不是 A1 版本。

如果你把run放在A1.prototype上，你就可以做到：

function A1() {
}
A1.prototype.eat = function() {
    console.log('A1 eats');
};
A1.prototype.run = function() {
    return 'A1 runs';
};

function B1() {
    A1.call(this);
}
B1.prototype = Object.create(A1.prototype);

B1.prototype.run = function() {
    return A1.prototype.run.call(this) + ",B1 also runs";
};
var b1 = new B1();
console.log(b1.run());

这很丑，这就是为什么I wrote a script to automate supercalls back in the day，但这就是你在这个级别工作时的做法。

不过，现在，您会使用 ES2015 的 class 语法和 super 来代替，如果需要支持过时的 JavaScript 引擎，则使用 Babel 或 Traceur 或类似方法进行转译：

class A1 {
    eat() {
        console.log("A1 eats");
    }
    run() {
        return "A1 runs";
    }
}

class B1 extends A1 {
    run() {
        return super.run() + ",B1 also runs";
    }
}

var b1 = new B1();
console.log(b1.run());

---

您的编辑说您不希望run 出现在原型上，它必须由A1 分配，如下所示：

function A1() {
    this.run = function() {
        return 'A1 runs';
    };
}

这有点麻烦，但您仍然可以做到。由于我上面提到的原因，在实例上设置 run 会掩盖您的实例通常使用的 B1.prototype.run。所以要使用它，还要调用A1的non-prototype run，你必须在实例上替换它。

因此，在B1 中定义B1 的run 比在B1.prototype 上更有意义，就像A1 在A1 中定义它一样，而不是在A1.prototype 中定义它：

function B1() {
    var A1run;
    A1.call(this);
    A1run = this.run;
    this.run = function() {
        return A1run.call(this) + ",B1 also runs";
    };
}

活生生的例子：

function A1() {
    this.run = function() {
        return 'A1 runs';
    };
}
A1.prototype.eat = function() {
    console.log('A1 eats');
};

function B1() {
    var A1run;
    A1.call(this);
    A1run = this.run;
    this.run = function() {
        return A1run.call(this) + ",B1 also runs";
    };
}
B1.prototype = Object.create(A1.prototype);

var b1 = new B1();
console.log(b1.run());

但如果你真的，真的希望它（至少部分）出现在B1.prototype：

function B1() {
    var A1run;
    A1.call(this);
    A1run = this.run;
    this.run = function() {
      return A1run.call(this) + B1.prototype.run.call(this);
    };
}
// ...
B1.prototype.run = function() {
    return ",B1 also runs";
};

活生生的例子：

function A1() {
    this.run = function() {
        return 'A1 runs';
    };
}
A1.prototype.eat = function() {
    console.log('A1 eats');
};

function B1() {
    var A1run;
    A1.call(this);
    A1run = this.run;
    this.run = function() {
        return A1run.call(this) + B1.prototype.run.call(this);
    };
}
B1.prototype = Object.create(A1.prototype);

B1.prototype.run = function() {
    return ",B1 also runs";
};
var b1 = new B1();
console.log(b1.run());