使用私有/受保护/公共字段和方法扩展类

Question

我正在尝试找到一种在 ES6 中创建模拟抽象类的方法。到目前为止，我尝试的所有内容总是遇到语言和/或其语法的局限性(也是我对原型的有限知识)。

基本哎呀;我们声明一个类并扩展它。最后一个类必须访问其超类中的某些字段和方法，但不是全部。它还改变了公共方法...

类声明应该在一个完美的封装中，所以除了这个代码之外，没有其他任何东西能够访问它(类似于命名空间的东西)。

---

到目前为止，我在 ES5 中的实验是错误的......我真的很感激一些建议和帮助。

(function(){
// ==================================
function AbstractClass(params) {
var _myParams = params;
var _privateField = "Only AbstractClass can see me";
this.publicField = "Everybody can see me";
function privateFunc() {
// Does private stuff
}
}
AbstractClass.prototype.publicFunc = function() {
// Does public stuff
privateFunc(); // Works?
}
// ==================================
function FinalClass(params) {
// How to pass the params to the superclass?
}
FinalClass.prototype.publicFunc = function() {
// Override and calls the superclass.publicFunc()?
// How can I touch _privateField ? publicField ?
}
FinalClass.prototype = Object.create(AbstractClass.prototype);
// ==================================
var foo = new FinalClass("hello world!");
foo.publicFunc();
})();

---

你能告诉我这段代码有什么问题以及如何解决它吗？
奖励问题：如何在 ES6 中正确执行此操作？
三重奖励：受保护的字段和方法呢？

谢谢。

Answer 1

这实际上是一个非常好的问题，我会尽量给你一个有见地的答案......

正如我已经在Stack Overflow的某个地方解释的那样，JavaScript并不是一种真正的基于类的语言。它基于原型。这是一个完全不同的编程范式，您应该考虑到这一点。因此，当你用Vanilla JS编写一些东西时，这通常是一个好主意，忘记(只是一点点)你对Java或C++的了解。

但是，JavaScript是一种非常灵活的语言，您可以根据需要进行编程。在我看来，JavaScript 编程有两种主要风格：惯用风格和经典风格。

• 偶像风格大量使用对象文字、鸭子类型、工厂功能和组合。
• 经典风格试图模仿基于类的语言的行为，使用构造函数用于类和 IIFE(立即调用的函数表达式)进行封装。它强调遗传和多态性。

你想要的是一个抽象类。抽象类是无法实例化的类，仅用作派生类的模型。如果你关心严格的封装，这就是你在 ES5 中实现它的方式：

// ==============================
// ABSTRACT "CLASS"
// ==============================
var OS = (function (n) {
// Here "name" is private because it is encapsulated in the IIFE
var name = "";
// Constructor
function OS (n) {
// If "OS" is called with "new", throw an error
if (this.constructor === OS) {
throw new Error('You cannot instantiate an abstract class!');
}
name = n;
}
// We cannot call this method directly (except with "call" or "apply") because we cannot have direct instances of "OS"
OS.prototype.boot = function () {
return name + ' is booting...';
};
// This is an abstract method. It will be in the prototype of derived objects but should be overriden to work
OS.prototype.shutdown = function () {
throw new Error('You cannot call an abstract method!');
};
// Getter for "name"
OS.prototype.getName = function () {
return name;
};
// The constructor must be returned to be public
return OS;
})();
// ==============================
// CONCRETE "CLASS"
// ==============================
var LinuxDistro = (function (name) {
// Constructor
function LinuxDistro(name) {
// Here we call the constructor of "OS" without "new", so there will not be any error
OS.call(this, name);
}
// Here "Linux Distro" inherits from "OS"
LinuxDistro.prototype = Object.create(OS.prototype);
LinuxDistro.prototype.constructor = LinuxDistro;
// Private function/method
function textTransform(str, style) {
return style === 'lowercase' ? str.toLowerCase() : str.toUpperCase();
}
// The parent method is used and overriden
LinuxDistro.prototype.boot = function () {
return OS.prototype.boot.call(this) + ' Welcome to ' + textTransform(this.getName());
};
// The abstract method is implemented
LinuxDistro.prototype.shutdown = function () {
return 'Shutting down... See you soon on ' + textTransform(this.getName());
};

// The constructor must be returned to be public
return LinuxDistro;
})();
// ==============================
// CLIENT CODE
// ==============================
var arch = new LinuxDistro('Arch Linux');
console.log(arch.getName());
console.log(arch.boot());
console.log(arch.shutdown());

现在你想要同样的东西与ES6。好的一点是 ES6 提供了很好的语法糖来处理类。同样，如果您关心严格封装，则可以使用以下实现：

// ==============================
// ABSTRACT "CLASS"
// ==============================
const OS = (n => {
// Here "name" is private because it is encapsulated in the IIFE
let name = "";
class OS {
constructor(n) {
// If "OS" is called with "new", throw an error
if (new.target === OS) {
throw new Error('You cannot instantiate an abstract class!');
}
name = n;
}
// We cannot call this method directly (except with "call" or "apply") because we cannot have direct instances of "OS"
boot() {
return `${name} is booting...`;
}
// This is an abstract method. It will be in the prototype of derived objects but should be overriden to work
shutdown() {
throw new Error('You cannot call an abstract method!');
}
// Getter for "name"
get name() {
return name;
}
}
// The class must be returned to be public
return OS;
})();
// ==============================
// CONCRETE "CLASS"
// ==============================
const LinuxDistro = (name => {
// Private function/method
function textTransform(str, style) {
return style === 'lowercase' ? str.toLowerCase() : str.toUpperCase();
}

class LinuxDistro extends OS {
constructor(name) {
// Here we call the constructor of "OS" without "new", so there will not be any error
super(name);
}
// The parent method is used and overriden
boot() {
return `${super.boot()} Welcome to ${textTransform(this.name)}`;
}
// The abstract method is implemented
shutdown() {
return `Shutting down... See you soon on ${textTransform(this.name)}`;
}
}

// The class must be returned to be public
return LinuxDistro;
})();
// ==============================
// CLIENT CODE
// ==============================
const arch = new LinuxDistro('Arch Linux');
console.log(arch.name); // This is not a direct access to "name". The getter is used...
console.log(arch.boot());
console.log(arch.shutdown());

当然，这些片段并不完美，可能看起来有点吓人。但我认为这是我们能做的最好的事情，因为JavaScript的原型性质。

正如您可能看到的，类成员要么是私有的(由于 IIFE 和闭包)，要么是公共的(由于对象的创建方式，具有自己的属性和原型链)。如果你真的想要受保护的成员，这是另一回事......

当你想到JavaScript代码的OOP模型时，我建议你使用TypeScript。这比上面介绍的代码更方便、可读和更易于维护。

最后，如果你想更进一步，看看如何在JavaScript中实现所有传统的OOP设计模式(特别是GoF模式)，我邀请你看看我在GitHub上的一个项目：PatternifyJS。