Antes de especificación ES6 no lo define, Js es en realidad un constructor de la clase. (Blog Citado Park: heweiquan )
1. Una clase simple.
función Persona () {
This.Name = '张三';
this.age = 20;
}
Var p = new Persona ();
alerta (p.name)
2. herencia de implementación a través de la creación de prototipos. (Constructor Prototype y un método para aumentar la cadena interior)
la función Persona () {
This.Name = 'John Doe'; / * atributo * /
this.age = 20 es;
this.run = function () {
Alert (this.name + 'movimiento');
}
}
// cadena de prototipo las propiedades anteriores no son compartidas por una instancia pluralidad constructor
Person.prototype.sex = "M";
Person.prototype.work = function () {
Alert (this.name + 'en el trabajo');
}
var P = la nueva persona nueva ();
//alert(p.name);
//p.run ();
p.work ();
método estático 3. clase
la función Persona () {}
Person.getInfo = function () {
Alert ( 'método I estática');
}
// Llamar al método estático
Person.getInfo ();
4.es5 posando dentro de los objetos que heredan tras la realización,
la función Persona () {
This.Name = 'John Doe'; / * atributo * /
this.age = 20 es;
this.run = function () {/ * Ejemplos de métodos * /
Alert (this.name 'movimiento' +);
}
}
Person.prototype.sex = "M";
Person.prototype.work = function () {
Alert (this.name + 'en el trabajo');
}
hereda de la clase // persona las composiciones prototipo patrones cadena + herencia basadas en la web de los objetos que presenta
la función de web () {
Person.call (el este); / * enmascaramiento objeto herencia * /
}
var nuevo nuevo el W web = ();
objetos //w.run();// pueden heredar las propiedades y métodos de la función de presentación de constructor , donde se está ejecutando
w.work (); // heredaron pero no las propiedades y métodos de la anterior cadena de prototipo, se da aquí
5.es5 dentro de la cadena de prototipo a herede herencia
la función Persona () {
This.Name = 'John Doe'; / * atributo * /
this.age = 20 es;
this.run = function () {/ * Ejemplos de métodos * /
Alert (this.name 'movimiento' +);
}
}
Person.prototype.sex = "M";
Person.prototype.work = function () {
Alert (this.name + 'en el trabajo');
}
hereda de la clase // persona las composiciones prototipo patrones cadena + herencia basadas en la web de los objetos que presenta
la función web () {}
Web.prototype nueva nueva = la persona (); // herencia cadena de prototipo
var nueva nuevo la banda W = ();
//w.run();// herencia cadena de prototipo: hereda el interior del constructor propiedades y métodos, en los que se está ejecutando
w.work (); // cadena de prototipo puede heredar atributos y procedimientos de lo anterior, es aquí el funcionamiento normal
problemas de la cadena herencia 6. prototipo
la función Persona (nombre, edad) {
this.name = nombre; / * atributo * /
this.age = edad;
this.run función = () {/ * Ejemplos de métodos * /
Alert (this.name + 'movimiento');
}
}
funcionar la web (nombre, edad) {}
Web.prototype nueva nueva = la persona ();
var nueva nueva del web W = ( 'Zhao si', 20 es);
w.run (); // subclase instanciable no cuando el paso de parámetros a la clase padre, se da aquí
la función Persona (nombre, edad) {
this.name = nombre; / * atributo * /
this.age = edad;
this.run función = () {/ * Ejemplos de métodos * /
Alert (this.name + 'movimiento');
}
}
funcionar la web (nombre, edad) {
Person.call (el presente, nombre, edad); subclases // instancia hereda objetos parámetros posando puede ser transferido a la clase padre
}
Web.prototype nueva nueva = la persona ();
var nueva nueva = W web ( 'Zhao Si', 20);
w.run (); // aquí sin error
8. Otra forma de presentación de la cadena de objeto prototipo herencia +
función Persona (nombre, edad) {
this.name = nombre; / * *属性/
this.age = edad;
this.run = function () {/ *实例方法* /
alerta (this.name + '在运动');
}
}
Función de Web (nombre, edad) {
Person.call (esto, nombre, edad);
}
Web.prototype = Person.prototype;
var w = new Web ( '赵四', 20);
w.run ();
La relación entre la función, objeto objeto prototipo, la cadena de prototipo.
En primer lugar, entender lo Construtor cosas, como su nombre indica es un constructor. Recordar el código.
la función del empleado (nombre, Trabajo, Born)
{
this.name = nombre;
this.job = Trabajo;
this.born = Born;
}
var = new nuevo proyecto de ley del Empleado ( "Bill Gates", "ingeniero", 1985);
la console.log (bill.constructor); // cadena Empleado que describe la función.
la console.log (Bill .__ proto__); {// constructor: fEmployee (nombre, Trabajo, Born), proto __ __: Objeto}
la console.log (bill.prototype); // indefinidos únicas funciones (incluyendo constructores) único prototipo propiedad . objetos ordinarios ningún prototipo (si no se especifica)
console.log (el empleado .__ proto__ === Function.prototype) // true
La conclusión es:
1): Sabemos que en Js, es posible utilizar nuevo lugar, sólo a 3.
Aquí está el primer lugar. + nuevo constructor. La segunda situación es nueva + Función (); tercer caso es nuevo + Object ().
Un constructor de objetos constructor a ella.
constructor de objeto Function.prototype es función,
el objeto es el constructor de objetos de Object.prototype
2): __proto__ propiedad de prototipo del objeto se utiliza para acceder al constructor. Cualquier objeto tiene la propiedad __proto__.
relación específica es como sigue:
