Aprendizaje basado en JavaScript - Prototipo

Hablando desde el objeto

JavaScript es un lenguaje orientado a objetos, y las implementaciones de JavaScript y común (como Java) no son los mismos, no a través de las clases de JavaScript a objetos abstractos, creados directamente crear objetos, JavaScritpt único objeto.

[[Prototipo]]

Casi todos los objetos han sido dado un valor no nulo cuando el objeto es creado por un [[] la Prototype] sería
valor puede ser obtenido por un .__ proto__, se puede obtener por Object.getPrototypeOf (A)
var A = {}


objeto [[Prototype]] finalmente apuntará a Objects.prototype

función prototipo

Copiar la forma orientada a objetos JavaScript que a través de la clase (como Java), sino a través de los objetos asociados, el objeto asociado es a través del prototipo
creamos un objeto B y asociarlo al objeto a, b encontrar el punto de prototipo a.
Cuando visitamos ba, aunque en un B no existe, siempre mirar hacia arriba a través del prototipo (hasta que encuentre objetos), que se encuentra en un prototipo de una.

  var a = { a: 2 },
    b = Object.create(a);

  console.log(b);
  console.log(b.a); // 2
  console.log(Object.getPrototypeOf(b) === a); // true

objeto b

Acerca de las funciones

• Habrá también una función de la función objeto prototipo tiene una propiedad prototipo, cuando solíamos llamar a esta nueva función, el objeto resultante [[Prototype]] función de correlación haría del prototipo
• JavaScript no existe constructor sólo cuando se utilizan las nuevas llamadas de función, las llamadas a funciones se convertirán en una llamada al constructor.
• La primera letra del nombre de la función funcionar normalmente nos llamará por nuevo capital, pero para los motores de JavaScript mayúscula la primera letra no tiene ningún sentido.

Cuando usamos nuevo a llamar a una función, se produce el siguiente procedimiento

1. Crear un nuevo objeto
2. Este objeto se ejecutará [[la] Prototype] conexión
3. Este nuevo objeto será obligado a esta llamada de función
4. Si la función no devuelve otros objetos, entonces la llamada a una función nueva expresión volverá automáticamente el nuevo objeto (esto)

  function Foo(name) {
    this.name = name;
  }

  Foo.prototype.myName = function() {
    return this.name;
  };

  var a = new Foo('a');

  console.log(a);
  console.log(a.myName()); // a
  console.log(a.constructor === Foo); // true
  console.log(Foo.constructor === Function);
  console.log(Foo.prototype.constructor === Foo); // true

Objeto A
en sí A tiene un atributo de nombre, un prototipo de una myName de Foo función (), y constructores constructor, el punto constructor A Foo, Foo.prototype.constructor también valores por defecto a la Foo.

---

Las propiedades de un punto .constructor Foo, no Foo descritos por una "configuración", relaciones de confianza sólo entre ellos
Foo.prototype .constructor el defecto sólo atributos de función propiedades Foo cuando hecho, puede ser modificado
cuando el modificado Foo. después de que el prototipo, a.constructor en "{}" no se encuentra en la propiedad constructor, sigue buscando a la cadena de prototipo superior, que se encuentra el objeto, por lo a.constructor === objeto

  function Foo() {}
  Foo.prototype = {};
  var a = new Foo();
  console.log(a.constructor === Foo); // false
  console.log(a.constructor === Object); // true

Heredar

• Bar.prototype = Object.create (Fun.prototype). Crear un nuevo objeto se crea Bar.prototype pasará Object.create () dentro de forma y asociarse nuevo objeto [[Prototype]] para Foo.prototype. Si lo hace, el atributo Would Bar.prototype.constructor falta
• Cuando Bar.prototype = tiempo Fun.prototype, hacen Bar.prototype y Fun.prototype referencia común el mismo objeto, cuando la asignación Bar.prototype, sino también hacer que el cambio Fun.prototype, pérdida de sentido herencia.
• ES6 ofrece una mejor manera Object.setPrototypeOf (Bar.prototype, Fun.prototype)

  function Fun(name) {
    this.name = name;
  }

  Fun.prototype.myName = function() {
    return this.name;
  };

  function Bar(name, lable) {
    Fun.call(this, name);
    this.lable = lable;
  }

  // Bar.prototype = Fun.prototype;
  // Bar.prototype = new Fun();
  Bar.prototype = Object.create(Fun.prototype);
  // Object.setPrototypeOf(Bar.prototype, Fun.prototype);
  Bar.prototype.myName = function() {
    return this.name + 'jsong';
  };

  var a = new Bar('jsong');
  console.log(a.myName()); // jsongjsong

  var b = new Fun('js');
  console.log(b.myName()); // js