6.2.1 patrón de fábrica:
función creatPerson (nombre, edad, trabajo) {
Hay o = new Object ()
o.name = nombre;
o.age = edad;
o.job = puestos de trabajo;
o.sayName = function () {
console.log (this.name)
};
O RETURN;
}
person1 var = nuevo createPerson ( "lilei", 22 "ingeniero de software")
person1.sayName () // 'Lilie'
6.2.2 Modo Constructor:
función de la persona (nombre, edad, trabajo) {
this.name = Nombre;
this.age = edad;
this.job = trabajo;
this.sayName = function () {
console.log (this.name)
}
}
var person1 = new Persona ( "lilei", 22 "ingeniero de software");
person1.sayName () // "lilei"
Descripción: person1 este objeto tiene un constructor (el constructor) Persona atributo.
alerta (person1.constructor == persona) // verdadera
propiedad constructor del primer objeto se utiliza para identificar el tipo de objeto. Sin embargo, la referencia de tipo de objeto de detección, el operador instanceof es más fiable.
alerta (person1 instanceof Object) // verdadera
alerta (person1 instanceof persona) // true
Aquí el objeto es a la vez objeto person1 instancia, la instancia es también una persona de.
1. La función del constructor como:
La única diferencia entre los constructores y otras funciones, es que ellos llaman de una manera diferente. Pero, después de todo, es la función constructora, sintaxis especial para definir un constructor no existe. Cualquier función, siempre que se invoca con el nuevo operador, entonces se puede utilizar como un constructor. La función no lo hace por ninguna llamada de constructor, y que su función normal Qué diferencia.
Persona delante castañas de función ():
// constructor se utiliza como una
var persona = new Persona ( "lilei", 22 "ingeniero de software");
person.sayName () // "lilei"
// llamar a la función con normalidad
Persona ( "lilei", 22 "ingeniero de software") // Añadir a la ventana
window.sayName () // "lilei"
// Llamar a otra acción de dominio objeto
Hay o = new Object ()
Person.call (O, "Kristen", 25, "enfermera")
o.sayName () // "Kristen"
2. La pregunta del constructor:
El problema es que cada método constructor debe ser re-creado de nuevo en cada caso. Por lo tanto no existe una definición de una función, se crea una instancia de un objeto. Desde una perspectiva lógica, este caso puede ser tan constructores define:
función de la persona (nombre, edad, trabajo) {
this.name = Nombre;
this.age = edad;
this.job = trabajo;
this.sayName = new Function () {console.log (this.name)}
}
Desde este punto constructor, cada instancia de persona contiene una instancia de la naturaleza de función diferente.
Por lo tanto, la definición de la función constructor también se puede escribir para resolver constructores externos crean instancias del mismo problema de función.
función de la persona (nombre, edad, trabajo) {
this.name = Nombre;
this.age = edad;
this.job = trabajo;
this.sayName = sayName
}
sayName función () {console.log (this.name)}
var person1 = new Persona ( "lilei", 22 "ingeniero de software");
person1.sayName () // "lilei"
6.2.3 modelo de prototipo:
Cada función tiene un prototipo (prototipo) Propiedad, que es un puntero a un objeto.
En otras palabras, la información no tiene que definir objetos en el ejemplo de las funciones de configuración, pero puede añadir información al objeto prototipo.
De castañas: Persona función () {}
Person.prototype.name = "lilei";
Person.prototype.age = 22;
Person.prototype.job = "ingeniero de software";
Person.prototype.sayName = function () {console.log (this.name)}
era PERSON1 = new Persona ()
person1.sayName () // "lilei"
1. Comprender el objeto prototipo
ECMAScript5 añade un nuevo método, llamado Object.getPrototypeOf (), todo ello apoyado por la puesta en práctica, este método devuelve el [Prototype] [] Valor.
Object.getPrototypeOf (person1) == Person.prototype // true
Object.getPrototypeOf (person1) .name // "lilei"
Explicó: Object.getPrototypeOf () objeto devuelto es en realidad un prototipo de este objeto. La segunda línea tuvo que el valor de nombre de atributo de objeto prototipo.
Por lo tanto, usando Object.getPrototypeOf (puede ser obtenido fácilmente a un objeto prototipo). En este caso, el uso de la herencia de prototipo es muy importante.
Una pluralidad de instancias de objeto comparten los principios y métodos de las propiedades del prototipo almacenado básicos:
Cuando el código para leer una propiedad de un objeto, se tendrá que realizar dos búsquedas. Cuando se llama a person1.sayName (), el analizador le preguntará primero: "person1 tienen atributos sayName?" Respuesta: "no". Entonces, la búsqueda continuará, pregunte: "¿prototipo person1 ha atributos sayName" R: "No". A continuación, se lee el objeto prototipo de la función almacenada.
Podemos crear la propiedad en el ejemplo, la propiedad protegerá a las propiedades en el prototipo.
Persona función () {}
Person.prototype.name = "liil"
fue PERSON1 = new Persona () era person2 = new Persona ()
person1.name = "mali"
console.log (person1.name) // mali
console.log (person2.name) // Hilali
Utilizar el operador delete para borrar person1.name, person1 restaurarán el enlace con el atributo de nombre de prototipo
person1.name de eliminación
console.log (person1.name) // liil - desde el prototipo
método hasOwnPrototype () puede detectar si hay un atributo en el ejemplo, todavía presente en el prototipo:
En la propiedad existe dada en las propiedades del objeto, sólo devolverá verdadero
función Persona () {};
Person.prototype.name = "mali";
person1 var = nueva persona ();
console.log (person.name) // mali del Ejemplo
la console.log (person1.hasOwnProperty ( "nombre")); // false
person1.name = "Gery";
console.log (person.name) // gery del Ejemplo
la console.log (person1.hasOwnProperty ( "nombre")); // true
person1.name Delete;
console.log (person1.name) // mali来自原型
console.log (person1.hasOwnProperty ( "nombre")); // false
2. Prototipo y el operador en
Operador de dos maneras: solo, porque en bucle utilizado.
en el operador, en el presente ejemplo, las propiedades o el prototipo devuelve true.
método Uso hasOwnProperty (), y en el operador, la propiedad puede ser determinada al final presente en el sujeto, o prototipo.
栗子: función hasPrototypeProperty (objeto, nombre) {
! Object.hasOwnProperty retorno (nombre) && (nombre de objeto)
}
Explicación: objeto es un objeto, el nombre es el nombre del atributo. Devuelve true porque mientras el operador puede acceder a la propiedad por el objeto,
hasOwnProperty () está presente sólo en el atributo de ejemplo, se devuelve verdadero, siempre que el operador devuelve cierto en el hasOwnProperty () devuelve falso,
Se determina que el atributo está presente en el prototipo.
hasPrototypeProperty () aplicación de función:
Persona función () {}
Person.prototype.name = "mali"
era persona = new Persona ()
alerta (hasPrototypeProperty (persona, "nombre")) // persona verdadera diana en presencia de una persona prototipo nombre del atributo
person.name = "gery"
alerta (hasPrototypeProperty (persona, "nombre")) // persona objetivo falsa en el nombre de la propiedad no existe en la persona del prototipo
Object.keys método ()
Aceptar el objeto como un parámetro y devuelve las propiedades del objeto pueden ser enumeradas en una matriz.
var persona = {
nombre: "kk",
edad: 55,
obra: "software"
}
llaves var = Object.keys (persona)
alerta (teclas) // [ "nombre", "edad", "trabajo"]
3. prototipo dinámico
Dado que el valor del proceso de descubrimiento es una búsqueda en el prototipo, por lo que cualquier cambio que hicimos al objeto prototipo se refleja inmediatamente de los ejemplos fuera - también modificar el prototipo sigue siendo el caso, incluso después de que se crea la primera instancia. Las castañas:
Persona función () {}
amigo var = new Peson ()
Person.prototype.sayhi = function () {alert ( "Hola")}
friend.sayHi () // "Hola"
Explicación: La razón de esto se puede atribuir al ejemplo prototipo de una relación de conexión suelta. Cuando se llama a friend.sayHI (), en el primer caso, se llamará en la búsqueda de estructuras sayHi, en ausencia de las búsquedas para encontrar el prototipo. Debido a que la conexión entre el ejemplo y el prototipo es sólo un puntero en lugar de una copia. Para que pueda encontrar nuevas propiedades sayHi en el prototipo y volviendo almacenada allí.
Sin embargo, si vuelve a escribir todo el objeto prototipo, la situación es diferente. Sabemos que añadirá un enlace con el prototipo original de la [[Prototype]] puntero a una instancia al llamar al constructor, y modificar el prototipo a otro objeto es igual a cortar el vínculo entre el constructor y el prototipo inicial.
Recuerde que el puntero para el ejemplo prototipo solamente, y no al constructor. Las castañas:
Persona función () {}
amigo var = new Persona ()
Person.prototype = {
constructor: persona,
Nombre: "lilei",
sayName: function () {alert (this.name)}
}
friend.sayName () // error
Explicación: Aquí primero se crea una instancia de la persona, y luego volver a escribir su objeto prototipo. Entonces errores que se producen cuando se llama friend.sayName (), ya que el prototipo puntas amigo No incluye el nombre de las propiedades con nombre.
4. El objeto prototipo original
La importancia del modelo prototipo no sólo se refleja en la creación de tipos personalizados, incluso todos los tipos de referencia nativos, se crean utilizando este modelo. Todo tipo de referencia nativo (Object, Array, String, etc.) se definen en el constructor método prototipo. Por ejemplo: Encontrar un método para ordenar () en Array.prototype puede encontrar el método substring () de String.prototype. Las castañas:
alerta (typeof Array.prototype.sort) // "función"
alerta (typeof Array.prototype.substring) // "función"
Por prototipo de objetos nativos no sólo pueden obtener todas las referencias al método por defecto, pero se puede definir nuevos métodos. Puede modificar los objetos nativos como el prototipo de modificación del objeto personalizado, al igual que el prototipo, puede agregar métodos en cualquier momento. Las castañas: String para añadir un método llamado startWith ()
String.prototype.startsWidth = función (texto) {
this.indexOf retorno (texto) == 0
}
var msg = "Hello World"
alerta (msg.startsWith ( "Hola")) // verdadera
El objeto prototipo problema
No tiene en cuenta los parámetros de inicialización que pasa al constructor de esta parte, el resultado de todas las instancias obtendrá los mismos valores de las propiedades por defecto. El mayor problema es el prototipo de su naturaleza compartida causado. Prototipo de todos los atributos se comparten muchos casos, esta función es muy útil para compartir del total. Sin embargo, la propiedad contiene un valor de tipo de referencia, el problema es más pronunciado. Las castañas:
Persona función () {}
Person.prototype = {
constructor: persona,
nombre: "nick",
edad: 29,
amigos: [ "Shelby", "corte"]
}
var person1 = new Persona ()
var person2 = new Persona ()
person1.friends.push ( "van")
console.log (person1.friends) // [ "Shelby", "corte", "van"]
console.log (person2.friends) // [ "Shelby", "corte", "van"]
console.log ( person2.friends === person1.friends) // true
Explicar: Person.prototype objeto tiene una propiedad denominada amigos, que atributo contiene una matriz de cadenas. A continuación, creamos dos instancias de Persona. A continuación, modifique las referencias person1.friends de matriz. Debido a que la matriz está presente en Person.prototype amigos y no en person1, se modificará sólo person2.friends (con person1.friends apuntan a la misma matriz) reflejada. Si nuestra intención es compartir una serie de este tipo en todos los casos, el resultado no dije. Sin embargo, los ejemplos son por lo general pertenecen a todos tienen sus propios atributos. Y este problema es la razón por la que rara vez se ve menos a alguien mentiras prototipo.
6.2.4 modo de combinación y el constructor patrón prototipo
La forma más común de crear un tipo de auto-definido, se utiliza en combinación con el modo de modo de constructor prototipo. constructor de modelo para la propiedad de instancia se define, y el modelo prototipo se utiliza para definir los métodos y propiedades compartidas. Como resultado, cada instancia tendrá su propia copia de un atributo de instancia, pero al mismo tiempo compartido con referencia a un método para maximizar el ahorro de la memoria. Las castañas:
función Persona (nombre, edad) { // propiedad de instancia de constructores se define
this.name = nombre;
this.age = edad;
this.friends = [ "SELi", "Curt"]
}
Person.prototype = {// de prototipos método y comparten propiedades
constructor: la persona,
sayName: function () {
el console.log (this.name)
}
}
var = new PERSON1 nuevo la persona ( "Nick", 26 es)
var = new PERSON2 nuevo la Persona ( "gris", 27)
PERSON1. friends.push ( "Van")
la console.log (person1.friends) // [ "SELi", "Curt", "Van"]
la console.log (person2.friends) // [ "SELi", "Curt"]
Explicación: Este constructor con un modelo prototipo híbrido, ECMAScript es actualmente el más utilizado, uno de los más alto grado de reconocimiento para crear tipos personalizados.
6.2.5 prototipo de modelo dinámico
Constructor inicializa prototipo (en el caso donde sólo el necesario), manteniendo al mismo tiempo las ventajas de utilizar el constructor y prototipos. En otras palabras, se puede comprobar si el método se debe almacenar de manera eficiente, para decidir si inicializar el prototipo. Las castañas:
función de la persona (nombre, edad) {
this.name = Nombre; // Propiedades
this.age = edad;
si (typeof this.sayName! = "función") {
Person.prototype.sayName = function () {
alerta (this.name)
}
}
}
amigo var = new Persona ( "klli", 28)
friend.sayName ();
