Javascript-Framework-Design und andere Fabriken_Javascript-Kenntnisse

Das Aufkommen von Klassen und Vererbung in JavaScript zeigt, dass JavaScript vor ECMAScript 4 versucht hat, Klassen, Module und andere Dinge einzuführen, aber aufgrund der übermäßigen Einführung von zu vielen Funktionen wurde JavaScript zu einem Chaos, das zur Ablehnung führte. Aber es verzögert nur die Klasse auf ES6. Bisher gibt es in JavaScript keine echte Klasse. In jüngster Zeit sind Klassenfabriken jedoch die Standardfunktion von Frameworks. In diesem Kapitel werden verschiedene Klassenimplementierungen vorgestellt, um es jedem zu erleichtern, den Stil zu wählen, der ihm in seinem eigenen Framework gefällt.

1.Javascript-Unterstützung für Klassen

In anderen Sprachen müssen Instanzen von Klassen über den Konstruktor new erstellt werden. Als Sprache, die Java bewusst imitiert. In JavaScript gibt es einen neuen Operator und alle Funktionen können als Konstruktoren verwendet werden. Konstruktoren unterscheiden sich nicht von gewöhnlichen Methoden. Um sein florierendes Ökosystem wie Node, Element, HTMLElement und HTMLParagraphElement aufzubauen, verwendet der Browser offensichtlich Vererbungsbeziehungen, um die gemeinsame Nutzung einiger Methoden oder Attribute zu erleichtern, sodass JavaScript den Prototypmechanismus von anderen Sprachen übernimmt. Prototyp existiert als spezielle Objekteigenschaft für jede Funktion. Wenn eine Funktion den neuen Operator new verwendet, um ihr „Kind“ – „Instanz“ – zu erzeugen, verfügt dieses Objekt mit dem Namen „Instanz“ über alle Mitglieder des Prototypobjekts dieser Funktion, wodurch erkannt wird, dass alle Instanzobjekte einen Satz von Methoden oder Eigenschaften gemeinsam haben. Die sogenannte „Klasse“ in JavaScript dient dazu, das native Objekt von seinen anderen definierten „Klassen“ zu unterscheiden, indem dieses Prototyp-Objekt geändert wird. Im Browser wird die Knotenklasse basierend auf Object geändert, während Element auf Node basiert und HTMLElement auf Element basiert. Im Vergleich zu unserem Arbeitsgeschäft können wir unsere eigenen Klassen erstellen, um Wiederverwendung und gemeinsame Nutzung zu erreichen.

  function A(){

  }
  A.prototype = {
    aa:"aa",
    method:function(){
    }
  };
  var a = new A;
  var b = new A;
  console.log(a.aa === b.aa);
  console.log(a.method === b.method)

Im Allgemeinen nennen wir die im Prototyp definierte Methode, die von allen Instanzen gemeinsam genutzt wird. Um eine Unterscheidung zu erreichen, ermöglicht JavaScript die Angabe ihrer Methode direkt im Konstruktor wird als privilegierte Methode bezeichnet. Handelt es sich um ein Attribut, spricht man von einem privilegierten Attribut. Jede Instanz davon hat eine Kopie und wird nicht voneinander beeinflusst. Daher fügen wir normalerweise die gemeinsam genutzten Methoden zum Betreiben von Daten in den Prototyp ein und fügen die privaten Attribute in die privilegierten Attribute ein. Wenn Sie es jedoch darauf platzieren, kann immer noch nach Belieben darauf zugegriffen werden. Platzieren Sie es daher im Bereich des Funktionskörpers. An diesem Punkt wird es zu einem wirklich privaten Eigentum.

  function A() {
    var count = 0;
    this.aa = "aa";
    this.method = function() {
      return count;
    }
    this.obj = {}
  }
  A.prototype = {
    aa:"aa",
    method:function(){

    }
  };
  var a = new A;
  var b = new A;
  console.log(a.aa === b.aa);//true 由于aa的值为基本类型，比较值
  console.log(a.obj === b.obj) //false 引用类型，每次进入函数体都要重新创建，因此都不一样。
  console.log(a.method === b.method); //false

Privilegierte Methoden oder Attribute decken nur die Prototypmethoden oder -attribute ab. Solange Sie also die privilegierte Methode löschen, können Sie auf die Prototypmethode oder das Attribut mit demselben Namen zugreifen.

  delete a.method;
  delete b.method;
  console.log(a.method === A.prototype.method);//true
  console.log(a.method === b.method); //true

In der Java-Sprache sind sowohl Prototypmethoden als auch privilegierte Methoden Attribute von Instanzmethoden. In Java gibt es auch etwas, das als Klassenmethode und Klassenattribut bezeichnet wird. Sie lassen sich sehr einfach mit JavaScript simulieren. Definieren Sie sie einfach direkt in der Funktion.

  A.method2 = function(){} //类方法
  var c = new A;
  console.log(c.method2); //undefined

Als nächstes schauen wir uns die Implementierung der Vererbung an. Wie oben erwähnt, wird seine Instanz etwas haben, unabhängig davon, ob dieses Attribut später hinzugefügt wird oder der gesamte Prototyp ersetzt wird. Wenn wir dieses Prototypobjekt durch den Prototyp einer anderen Klasse ersetzen, kann es problemlos alle Prototypmitglieder dieser Klasse erhalten.

  function A() {};
  A.prototype = {
    aaa : 1
  }
  function B() {};
  B.prototype = A.prototype;
  var b = new B;
  console.log(b.aaa); //=> 1;
  A.prototype.bb = 2;
  console.log(b.bb) //=> 2;

Da es sich auf dasselbe Objekt bezieht, bedeutet dies, dass das Ändern des Prototyps der Klasse A dem Ändern des Prototyps der Klasse B entspricht. Daher können wir ein Objekt nicht zwei Klassen zuordnen. Es gibt zwei Möglichkeiten, dies zu tun,

Methode 1: Weisen Sie die Prototyp-Mitglieder der übergeordneten Klasse nacheinander bis zum
dem Prototyp der Unterklasse zu Methode 2 ist: Der Prototyp der Unterklasse wird nicht direkt von der übergeordneten Klasse abgerufen. Weisen Sie zunächst den Prototyp der übergeordneten Klasse einer Funktion zu und verwenden Sie dann die Instanz dieser Funktion als Prototyp der Unterklasse.

Bei der ersten Methode müssen wir normalerweise eine Methode wie mixin implementieren, die in manchen Büchern als Kopiervererbung bezeichnet wird. Der Vorteil besteht darin, dass sie einfach und direkt ist, der Nachteil besteht jedoch darin, dass sie die Instanzüberprüfung nicht bestehen kann. Hierzu wird die Extend-Methode von Prototype.js verwendet.

  function extend (des, source) { //des = destination
    for (var property in source)
      des[property] = source[property];
    return des;
  }

Methode zwei besteht darin, Ihr Gehirn für den Prototyp zu verwenden, daher wird dies als prototypische Vererbung bezeichnet. Unten finden Sie eine Vorlage

  function A() {};
  A.prototype = {
    aa:function(){
      alert(1)
    }
  }
  function bridge() {

  };
  bridge.prototype = A.prototype;

  function B() {}
  B.prototype = new bridge();

  var a = new A;
  var b = new B;

  console.log(a == b) //false 证明成功分开原型
  console.log(A.prototype == B.prototype) //true 子类共享父类的原型方法
  console.log(a.aa === b.aa); //为父类动态添加新的方法
  A.prototype.bb = function () {
    alert(2)
  }
  //true，继承父类的方法
  B.prototype.cc = function (){
    alert(3)
  }
  //false 父类未必有子类的new实例
  console.log(a.cc === b.cc)
  //并且它能够正常通过javascript自带的验证机制instanceof
  console.log(b instanceof A) ;//true
  console.log(b instanceof B) ; //true

Methode 2 kann die Instanzüberprüfung bestehen. Es ist eine integrierte Methode zur Implementierung der Prototypenvererbung. Wenn der zweite Parameter nicht berücksichtigt wird, entspricht er ungefähr dem folgenden Code.

  Object.create = function (o) {
    function F() {}
    F.prototype = o;
    return new F();
  }

Die obige Methode erfordert die Übergabe eines Prototyps der übergeordneten Klasse als Parameter und gibt dann den Prototyp der Unterklasse zurück

Allerdings vermissen wir noch etwas: Die Unterklasse erbt nicht nur die Vererbung der übergeordneten Klasse, sondern verfügt auch über ihre eigenen Dinge. Darüber hinaus erlaubt die prototypische Vererbung der Unterklasse nicht, die Mitglieder und privilegierten Mitglieder der übergeordneten Klasse zu erben . Wir müssen diese manuell hinzufügen, z. B. Klassenmitglieder. Wir können die obige Erweiterungsmethode verwenden und privilegierte Mitglieder können über Apply im Unterklassenkonstruktor implementiert werden.

  function inherit(init, Parent, proto){
    function Son(){
      Parent.apply(this, argument); //先继承父类的特权成员
      init.apply(this, argument); //在执行自己的构造器
    }
  }
  //由于Object.create是我们伪造的，因此避免使用第二个参数
  Son.prototype = Object.create(Parent.prototype,{});
  Son.prototype.toString = Parent.prototype.toString; //处理IEbug
  Son.prototype.valueOf = Parent.prototype.valueOf; //处理IEbug
  Son.prototype.constructor = Son; //确保构造器正常指向，而不是Object
  extend(Son, proto) ;//添加子类的特有的原型成员
  return Son;

下面，做一组实验，测试下实例的回溯机制。当我们访问对象的一个属性，那么他先寻找其特权成员，如果有同名就返回，没有就找原型，再没有，就找父类的原型...我们尝试将它的原型临时修改下，看它的属性会变成那个。

  function A(){

  }
  A.prototype = {
    aa:1
  }
  var a = new A;
  console.log(a.aa) ; //=>1

  //将它的所有原型都替换掉
  A.prototype = {
    aa:2
  }
  console.log(a.aa); //=>1

  //于是我们想到每个实例都有一个constructor方法，指向其构造器
  //而构造器上面正好有我们的原型，javascript引擎是不是通过该路线回溯属性呢
  function B(){

  }
  B.prototype = {
    aa:3
  }
  a.constructor = B;
  console.log(a.aa) //1 表示不受影响

因此类的实例肯定通过另一条通道进行回溯，翻看ecma规范可知每一个对象都有一个内部属性[[prototype]],它保存这我们new它时的构造器所引用的Prototype对象。在标准浏览器与IE11里，它暴露了一个叫__proto__属性来访问它。因此，只要不动__proto__上面的代码怎么动，a.aa始终坚定不毅的返回1.

再看一下，new时操作发生了什么。

1.创建了一个空对象 instance
2.instance.__proto__ = intanceClass.prototype
3.将构造函数里面的this = instance
4.执行构造函数里的代码
5.判定有没有返回值，没有返回值就返回默认值为undefined,如果返回值为复合数据类型，则直接返回，否则返回this
于是有了下面的结果。

  function A(){
    console.log(this.__proto__.aa); //1
    this.aa = 2
  }
  A.prototype = {aa:1}
  var a = new A;
  console.log(a.aa)
  a.__proto__ = {
    aa:3
  }
  console.log(a.aa) //=>2
  delete a. aa; //删除特权属性，暴露原型链上的同名属性
  console.log(a.aa) //=>3

有了__proto__，我们可以将原型设计继承设计得更简单，我们还是拿上面的例子改一改，进行试验

  function A() {}
  A.prototype = {
    aa:1
  }
  function bridge() {}
  bridge.prototype = A.prototype;

  function B(){}
  B.prototype = new bridge();
  B.prototype.constructor = B;
  var b = new B;
  B.prototype.cc = function(){
    alert(3)
  }
  //String.prototype === new String().__proto__ => true
  console.log(B.prototype.__proto__ === A.prototype) //true
  console.log(b.__proto__ == B.prototype); //true 
  console.log(b.__proto__.__proto__ === A.prototype); //true 得到父类的原型对象

因为b.__proto__.constructor为B，而B的原型是从bridge中得来的，而bride.prototype = A.prototype,反过来，我们在定义时，B.prototype.__proto__ = A.prototype,就能轻松实现两个类的继承.

__proto__属性已经加入es6,因此可以通过防止大胆的使用

2.各种类工厂的实现。

上节我们演示了各种继承方式的实现，但都很凌乱。我们希望提供一个专门的方法，只要用户传入相应的参数，或按照一定简单格式就能创建一个类。特别是子类。

由于主流框架的类工厂太依赖他们庞杂的工具函数，而一个精巧的类工厂也不过百行左右

相当精巧的库，P.js

https://github.com/jiayi2/pjs

使用版：https://github.com/jiayi2/factoryjs

这是一个相当精巧的库，尤其调用父类的同名方法时，它直接将父类的原型抛在你面前，连_super也省了。

  var P = (function(prototype, ownProperty, undefined) {
 return function P(_superclass /* = Object */, definition) {
  // handle the case where no superclass is given
  if (definition === undefined) {
   definition = _superclass;
   _superclass = Object;
  }

  // C is the class to be returned.
  //
  // When called, creates and initializes an instance of C, unless
  // `this` is already an instance of C, then just initializes `this`;
  // either way, returns the instance of C that was initialized.
  //
  // TODO: the Chrome inspector shows all created objects as `C`
  //    rather than `Object`. Setting the .name property seems to
  //    have no effect. Is there a way to override this behavior?
  function C() {
   var self = this instanceof C ? this : new Bare;
   self.init.apply(self, arguments);
   return self;
  }

  // C.Bare is a class with a noop constructor. Its prototype will be
  // the same as C, so that instances of C.Bare are instances of C.
  // `new MyClass.Bare` then creates new instances of C without
  // calling .init().
  function Bare() {}
  C.Bare = Bare;

  // Extend the prototype chain: first use Bare to create an
  // uninitialized instance of the superclass, then set up Bare
  // to create instances of this class.
  var _super = Bare[prototype] = _superclass[prototype];
  var proto = Bare[prototype] = C[prototype] = C.p = new Bare;

  // pre-declaring the iteration variable for the loop below to save
  // a `var` keyword after minification
  var key;

  // set the constructor property on the prototype, for convenience
  proto.constructor = C;

  C.extend = function(def) { return P(C, def); }

  return (C.open = function(def) {
   if (typeof def === 'function') {
    // call the defining function with all the arguments you need
    // extensions captures the return value.
    def = def.call(C, proto, _super, C, _superclass);
   }

   // ...and extend it
   if (typeof def === 'object') {
    for (key in def) {
     if (ownProperty.call(def, key)) {
      proto[key] = def[key];
     }
    }
   }

   // if no init, assume we're inheriting from a non-Pjs class, so
   // default to using the superclass constructor.
   if (!('init' in proto)) proto.init = _superclass;

   return C;
  })(definition);
 }

 // as a minifier optimization, we've closured in a few helper functions
 // and the string 'prototype' (C[p] is much shorter than C.prototype)
})('prototype', ({}).hasOwnProperty);

我们尝试创建一个类：

  var Dog = P (function(proto, superProto){
    proto.init = function(name) { //构造函数
      this.name = name;
    }
    proto.move = function(meters){ //原型方法
      console.log(this.name + " moved " + meters + " m.")
    }
  });
  var a = new Dog("aaa")
  var b = new Dog("bbb"); //无实例变化
  a.move(1);
  b.move(2);

我们在现在的情况下，可以尝试创建更简洁的定义方式

  var Animal = P (function(proto, superProto){
    proto.init = function(name) { //构造函数
      this.name = name;
    }
    proto.move = function(meters){ //原型方法
      console.log(this.name + " moved " + meters + " m.")
    }
  });
  var a = new Animal("aaa")
  var b = new Animal("bbb"); //无实例变化
  a.move(1);
  b.move(2);
  //...............
  var Snake = P (Animal, function(snake, animal){
    snake.init = function(name, eyes){
      animal.init.call(this, arguments); //调运父类构造器
      this.eyes = 2;
    }
    snake.move = function() {
      console.log('slithering...');
      animal.move.call(this, 5); //调运父类同名方法
    }
  });
  var s = new Snake("snake", 1);
  s.move();
  console.log(s.name);
  console.log(s.eyes);

私有属性演示，由于放在函数体内集中定义，因此安全可靠！

  var Cobra = P (Snake, function(cobra){
    var age = 1;//私有属性
    //这里还可以编写私有方法
    cobra.glow = function(){ //长大
      return age++;
    }
  });
  var c = new Cobra("cobra");
  console.log(c.glow()); //1
  console.log(c.glow()); //2
  console.log(c.glow()); //3

以上所述就是本文的全部内容了，希望大家能够喜欢。