Question

我试图找到一种在ES6中创建一个simili抽象类的方法。到目前为止，我尝试的所有内容总是遇到语言和/或语法的限制（也是我对原型设计的有限知识）。

基本oop ;我们声明一个类并扩展它。最后一个类必须从其超类访问一些字段和方法，但不是所有字段和方法。它也改变了公共方法......

类声明应该是一个完美的封装，所以除了这个代码之外别无其他东西（类似于命名空间）。

到目前为止，我在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编程有两种主要风格：惯用风格和经典风格。

idomatic风格大量使用对象文字，鸭子打字，工厂功能和构图。
经典样式试图模仿基于类的语言的行为，使用类和IIFE（立即调用函数表达式）的构造函数进行封装。它强调继承和多态性。

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

＆＃13;

// ==============================
// 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());

＆＃13;

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

＆＃13;

// ==============================
// 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());

＆＃13;

当然，这些片段并不完美，可能看起来有些可怕。但由于JavaScript的原型特性，我认为这是我们能做的最好的事情。

正如您可能看到的那样，类成员要么是私有的（感谢IIFE和闭包），要么是公共的（感谢对象是如何创建的，具有自己的属性和原型链）。如果你真的想要受保护的成员，这是另一个故事......

如果您想到了JavaScript代码的OOP模型，我建议您使用TypeScript。这比上面提供的代码更方便，可读和可维护。

最后，如果您想进一步了解如何在JavaScript中实现所有传统的OOP设计模式（尤其是GoF模式），我邀请您在GitHub上查看我的一个项目：PatternifyJS

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

1 个答案: