explicar el objeto de backbone y el patrón de creación de clase

Question

Soy un desarrollador de JavaScript de nivel moderado que intenta comprender cómo funciona la biblioteca de backbone internamente y agradecería profundamente si alguien me ayudara a resolver algunos desafíos.

así que aquí es lo que entiendo

definición básica de la función constructora en Backbone está

Backbone.Model = function(attributes, options) { } 

luego usan para fines generales extender método para agregar características comunes en nuestro prototipo del constructor.

_.extend(Backbone.Model.prototype, Backbone.Events, {...}) 

ahora hasta esta parte sé exactamente lo que está sucediendo y estaremos encantados de crear una instancia de objeto nuevo, aunque siguiente código

var user = new Backbone.Model() 

y esta es la parte que estoy encontrando difícil

por supuesto, no es la forma en que instanciamos un objeto en Backbone, pero utilizamos extender el método

var Users = Backbone.Model.extend({}); 
var user = new Users() 

y en el código de la columna vertebral

Backbone.Model.extend = extend; 

var extend = function(protoProps, classProps) { 
     var child = inherits(this, protoProps, classProps); 
     child.extend = this.extend; 
     return child; 
}; 

var inherits = function(parent, protoProps, staticProps) { 
    var child; 
    if (protoProps && protoProps.hasOwnProperty('constructor')) { 
     child = protoProps.constructor; 
    } else { 
     child = function() { 
      return parent.apply(this, arguments); 
     }; 
    } 
    _.extend(child, parent); 
    ctor.prototype = parent.prototype; 
    child.prototype = new ctor(); 
    if (protoProps) _.extend(child.prototype, protoProps); 
    if (staticProps) _.extend(child, staticProps); 
    child.prototype.constructor = child; 
    child.__super__ = parent.prototype; 
    return child; 
}; 

por favor me explique lo que está sucediendo dentro de la función de heredar y cuál es el beneficio de ampliar el enfoque método

Answer 1

función de subrayado extend fusiona los miembros (funciones y propiedades) de la segunda argumento en el primero. Por ejemplo:

var reciever = { 
    name: "Jonny", 
    age: 29 
}; 

var supplier: { 
    languages: [ "javascript", "actionscript" ]; 
    sayHi: function() { 
     console.log("Hi, name name is " + this.name); 
    } 
}; 

_.extend(receiver, supplier); 

Después de ejecutar el código anterior, el objeto receptor habrá sido aumentada (modificado) y ahora tener este aspecto:

/* 
    { 
     age: 29, 
     languages: [ "javascript", "actionscript" ], 
     name: "Jonny", 
     sayHi: <<function>> 
    } 
*/ 
console.dir(receiver); 

Nota que el objeto proveedor permanece sin modificar y el objeto receptor gana todas las propiedades y funciones del proveedor. Este proceso se conoce comúnmente como mixin y se usa para evitar tener que redeclarar funciones (como parte de un principio de programación más amplio, conozca DRY - Don't Repeat Yourself).

Ahora en cuanto a la función del Backbone Model.extend, que actúa como un factory method a que devolver una función constructora que se puede utilizar para crear nuevas instancias de su modelo con la función interna inherits haciendo la mayor parte del trabajo. La función inherits lleva el concepto de mixin un paso más allá y crea un inheritance chain entre el objeto suministrado y un elemento primario (en este caso particular, el objeto Backbone.Model).

var child; 
if (protoProps && protoProps.hasOwnProperty('constructor')) { 
    child = protoProps.constructor; 
} else { 
    child = function() { 
     return parent.apply(this, arguments); 
    }; 
} 

Este primer bloque de código está tratando de encontrar una función constructora dentro del hash objeto suministrado; si uno no está presente, entonces crea una nueva función de Constructor para usted que automáticamente pasa los argumentos proporcionados al Backbone.Model propio constructor function en su lugar.

_.extend(child, parent); 

Siguiente llamamos subrayar de extender el método a mixin todas las propiedades y funciones de hash suministrado de propiedades y funciones en la función constructora; esto garantiza que cada instancia que cree tenga sus propios datos (p. ej., las propiedades no son estáticas y se comparten en todas las instancias que cree).

ctor.prototype = parent.prototype; 
child.prototype = new ctor(); 
if (protoProps) _.extend(child.prototype, protoProps); 
if (staticProps) _.extend(child, staticProps); 
child.prototype.constructor = child; 
child.__super__ = parent.prototype; 

Este último bloque es el más emocionante y crea una relación entre el prototipo de la función constructora recién creado y el padre prototipo (Backbone.Model) del objeto. Al hacer esto, todas las instancias nuevas devueltas por el Constructor contendrán los métodos habituales del Modelo principal (es decir, get y set) ya que se resuelven desde la cadena del prototipo. Si desea obtener más información sobre este bloque de código en particular, Douglas Crockford's article on Prototypal inheritance es un gran lugar para comenzar.

El objetivo de este enfoque es que permite proporcionar un hash de propiedades y función que la función constructora resultante utilizará como modelo, por ejemplo:

var Person = Backbone.Model.extend({ 
    name: "Jon Doe", 
    sayHi: function() { 
     console.log("Hi, my name is " + this.get("name")); 
    } 
}); 

Ahora cada Person objeto crear una instancia tendrá tanto un name propiedad y un sayHi función, por ejemplo:

var dave = new Person(); 
dave.sayHi(); // "Hi, my name is Jon Doe" 

dave.set("name", "Dave"); 
dave.sayHi(); // "Hi, my name is Dave" 

// You can also supply properties when invoking the constructor. 
var jimmy = new Person({ name: "Jimmy" }); 
jimmy.sayHi(); // "Hi, my name is Jimmy"