conception de framework javascript et autres compétences d'usines_javascript

L'émergence des classes et de l'héritage en JavaScript montre que JavaScript a atteint le seuil du développement à grande échelle. Avant ECMAScript 4, il essayait d'introduire des classes, des modules et d'autres choses, mais en raison de l'introduction excessive d'un trop grand nombre. fonctionnalités, JavaScript est devenu un gâchis entraînant un rejet. Mais cela ne fait que retarder la classe vers ES6. Jusqu'à présent, JavaScript n'a pas de vraie classe. Cependant, nous pouvons simuler des classes. Ces derniers temps, les fabriques de classes sont la fonctionnalité standard des frameworks. Ce chapitre présentera diverses implémentations de classes pour permettre à chacun de choisir le style qu'il préfère dans son propre framework.

1.Prise en charge javascript pour les cours

Dans d'autres langages, les instances de classes doivent être créées via le constructeur new. En tant que langage qui imite délibérément Java. Il existe un nouvel opérateur en JavaScript et toutes les fonctions peuvent être utilisées comme constructeurs. Les constructeurs ne sont pas différents des méthodes ordinaires. Afin de construire son écosystème florissant, comme Node, Element, HTMLElement et HTMLParagraphElement, le navigateur utilise évidemment des relations d'héritage pour faciliter le partage de certaines méthodes ou attributs, donc JavaScript emprunte le mécanisme de prototype à d'autres langages. Le prototype existe en tant que propriété d'objet spéciale sur chaque fonction. Lorsqu'une fonction utilise l'opérateur new new pour produire son "enfant" - "instance", cet objet nommé instance possède tous les membres de l'objet prototype de cette fonction, réalisant ainsi que tous les objets instance partagent un ensemble de méthodes ou de propriétés. La soi-disant « classe » en JavaScript consiste à distinguer l'objet natif de ses autres « classes » définies en modifiant cet objet Prototype. Dans le navigateur, la classe de nœud est modifiée en fonction de l'objet, tandis qu'Element est basé sur Node et HTMLElement est basé sur Element.... Par rapport à notre activité professionnelle, nous pouvons créer nos propres classes pour réaliser la réutilisation et le partage.

  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)

Généralement, nous appelons la méthode définie sur le prototype une méthode prototype, qui est partagée par toutes les instances. Afin de réaliser la différenciation, JavaScript nous permet de spécifier sa méthode directement dans le constructeur. appelée méthode privilégiée. S’il s’agit d’un attribut, on l’appelle un attribut privilégié. Chaque instance d'entre eux a une copie et n'est pas affectée les unes par les autres. Par conséquent, nous mettons généralement les méthodes partagées pour exploiter les données dans le prototype et mettons les attributs privés dans les attributs privilégiés. Mais si vous le mettez ici, il est toujours accessible à volonté, alors placez-le dans la portée du corps de la fonction. Il devient alors une véritable propriété privée.

  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

Les méthodes ou attributs privilégiés ne couvrent que les méthodes ou attributs prototypes, donc tant que vous supprimez la méthode privilégiée, vous pouvez accéder à la méthode ou à l'attribut prototype portant le même nom.

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

En langage Java, les méthodes prototypes et les méthodes privilégiées sont des attributs des méthodes d'instance. Il existe également ce qu'on appelle méthode de classe et attribut de classe en Java. Ils sont très simples à simuler en JavaScript, il suffit de les définir directement sur la fonction.

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

Ensuite, regardons l'implémentation de l'héritage. Comme mentionné ci-dessus, quoi qu'il y ait sur le prototype, son instance aura quelque chose, que cet attribut soit ajouté plus tard ou que l'intégralité du prototype soit remplacée. Si nous remplaçons cet objet prototype par le prototype d’une autre classe, alors il peut facilement obtenir tous les membres prototypes de cette classe.

  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;

Puisqu'il fait référence au même objet, cela signifie que lorsque l'on modifie le prototype de la classe A, cela équivaut à modifier le prototype de la classe B. Par conséquent, nous ne pouvons pas affecter un objet à deux classes. Il y a deux façons de procéder,

Méthode 1 : attribuer les membres prototypes de la classe parent au prototype de la sous-classe un par un via in
La méthode 2 est la suivante : le prototype de la sous-classe n'est pas obtenu directement de la classe parent. Tout d'abord, attribuez le prototype de la classe parent à une fonction, puis utilisez l'instance de cette fonction comme prototype de la sous-classe.

Première méthode, nous devons généralement implémenter une méthode comme mixin, que certains livres appellent l'héritage de copie. L'avantage est qu'elle est simple et directe, mais l'inconvénient est qu'elle ne peut pas passer l'instance de vérification. La méthode extend de Prototype.js est utilisée pour ce faire.

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

La deuxième méthode consiste à utiliser votre cerveau sur le prototype, c'est ce qu'on appelle l'héritage prototypique. Ci-dessous un modèle

  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

La méthode 2 peut réussir l'instance de vérification. es5 a intégré cette méthode pour implémenter l'héritage du prototype. Si le deuxième paramètre n'est pas pris en compte, il est approximativement égal au code suivant.

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

La méthode ci-dessus nécessite de passer un prototype de la classe parent en paramètre, puis renvoie le prototype de la sous-classe

Cependant, il nous manque encore quelque chose : la sous-classe hérite non seulement de l'héritage de la classe parent, mais a également ses propres éléments. De plus, l'héritage prototypique ne permet pas à la sous-classe d'hériter des membres et des membres privilégiés de la classe parent. . Nous devons les ajouter manuellement, tels que les membres de la classe, nous pouvons utiliser la méthode extend ci-dessus et les membres privilégiés peuvent être implémentés dans le constructeur de sous-classe via apply.

  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

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