Cuando hablamos de objetos orientados a los objetos, podemos pensar en la clase, los objetos, el embalaje, la herencia, el polimorfismo. En el libro "JavaScript Advanced Program Design" (People's Post and Telecommunications Press, Cao Li, Zhang Xin. El nombre en inglés es: JavaScript profesional para desarrolladores web) se describe en el libro. Echemos un vistazo a los diversos métodos definidos en JavaScript.
1. Método de fábrica
Cree nuestra propia clase y objetos en JavaScript, deberíamos tener que dominar.
Copiar código del código de la siguiente manera:
<script type = "text/javaScript">
//definición
var oCar = new Object ();
Ocar.color = "rojo";
OCAR.Doors = 4;
Ocar.showColor = function () {
Alerta (this.color);
}
// Llamar
Ocar.showColor ();
</script>
Somos fáciles de usar los objetos OCAR, pero creamos múltiples instancias de automóviles. Podemos usar una función para encapsular el código anterior para implementar:
Copiar código del código de la siguiente manera:
<script type = "text/javaScript">
//definición
function createCar () {
var oCar = new Object ();
Ocar.color = "rojo";
OCAR.Doors = 4;
Ocar.showColor = function () {
Alerta (this.color);
}
Devolver OCAR;
}
// Llamar
var ocar1 = createCar ();
var oCar2 = createCar ();
Ocar1.color = "Black";
Ocar1.showColor ();
Ocar2.showColor ();
</script>
Por cierto, los atributos de membresía predeterminados del objeto JavaScript son públicos. De esta manera, lo llamamos un método de fábrica, y hemos creado fábricas que pueden crear y devolver tipos específicos de objetos.
Esto es un poco interesante, pero en el objeto orientado al objeto, el método para crear el objeto es:
Coche de coche = coche nuevo ();
El uso de nuevas palabras clave ha estado profundamente arraigado en los corazones de las personas, por lo que usamos el método anterior para definirlo siempre se siente incómodo, y cada vez que lo llamamos, creamos nuevos atributos y funciones. . Veamos la definición de formulario del constructor.
2. Constructor
Este método se parece un poco a una función de fábrica. El rendimiento específico es el siguiente:
Copiar código del código de la siguiente manera:
<script type = "text/javaScript">
//definición
Function car (color, puertas) {
this.color = color;
this.doors = puertas;
this.showColor = function () {
Alerta (this.color);
};
}
// Llamar
var car1 = coche nuevo ("rojo", 4);
var car2 = auto nuevo ("azul", 4);
coche1.showColor ();
Car2.showColor ();
</script>
Parece obvio, hay diferencias. Se siente un poco interesante. Cree un objeto dentro de la función de construcción utilizando estas palabras clave, y se siente muy amable crear objetos utilizando el nuevo símbolo informático. Pero también hay algunos problemas: cada vez que se crea el nuevo objeto, todos los atributos, incluida la creación de la función, es decir que múltiples objetos son completamente independientes. El objeto CAR1 y el objeto CAR2 son ambos. Esta es la ventaja de la forma original.
3. Prototipo
Usando el atributo prototipo del objeto, puede ver el prototipo del que depende el nuevo objeto. El método es el siguiente:
Copiar código del código de la siguiente manera:
<script type = "text/javaScript">
//definición
Fuinction coche () {
};
Car.prototype.color = "rojo";
Car.prototype.doors = 4;
Car.prototype.drivers = new Array ("Tom", "Jerry");
Car.prototype.showColor = function () {
Alerta (this.color);
}
// Llamar:
var car1 = nuevo coche ();
var car2 = nuevo coche ();
coche1.showColor ();
Car2.showColor ();
alerta (car1.rivers);
car1.drivers.push ("stephen");
Alerta (CAR1.Drivers);
Alerta (CAR2.Drivers);
// Puede usar JSON para simplificar la definición de prototipo:
Car.prototype =
{{
Color: "Rojo",
Puertas: 4,
Conductores: ["Tom", "Jerry", 'Safdad'],
showColor: function () {
Alerta (this.color);
}
}
</script>
En primer lugar, el constructor de este código, no hay código y luego agregue el atributo del objeto para definir el atributo del objeto CAR a través del atributo prototipo del objeto. Este método es muy bueno, pero el problema es que el objeto del automóvil apunta al puntero de la matriz. Car2 también al mismo tiempo, esto no está permitido.
Al mismo tiempo, el problema también se manifiesta en el prototipo que no puede traer ningún parámetros de inicialización, lo que hace que el constructor no pueda inicializarse normalmente. Esto requiere otra forma de resolver: es el modo mixto de constructor/prototipo.
4. Modo de constructor/prototipo mixto
La combinación de constructor y prototipo es muy conveniente para definir la clase.
Copiar código del código de la siguiente manera:
<script type = "text/javaScript">
//definición
Function Car (color, puertas)
{{
this.color = color;
this.doors = puertas;
this.drivers = new Array ("Tom", "Jerry");
}
Car.prototype.showColor = function () {
Alerta (this.color);
}
// Llamar:
var car1 = coche nuevo ('rojo', 4);
var car2 = auto nuevo ('azul', 4);
coche1.showColor ();
Car2.showColor ();
alerta (car1.rivers);
car1.drivers.push ("stephen");
Alerta (CAR1.Drivers);
alerta (car2.drivers);
Alerta (auto1 instancia de coche);
</script>
Este método es definir los atributos dentro y usar el prototipo para definirlo afuera. El problema de resolver el tercer método.
Este método en realidad debería ser muy amigable, pero en comparación con la gramática de Java, debería haber algo de falta de armonía, y se siente más desordenado. Para el personal de I + D de J2EE, este método siempre es incómodo. Siempre siente que no es un embalaje amigable. , se considera que es más problemático. Ese es el prototipo dinámico.
5. Prototipo dinámico
Para los desarrolladores que están acostumbrados a usar otros idiomas, el uso de constructor/prototipos mixtos no es tan armonioso. Después de todo, al definir las categorías, la mayoría de los idiomas orientados a los objetos se empaquetan visualmente en atributos y métodos. Considere la siguiente clase C#:
Copiar código del código de la siguiente manera:
coche de clase // clase
{{
Color de cadena pública = "rojo";
Public int puertas = 4;
público int mpg = 23;
Public Car (Color de cadena, int puertas, int mpg) // constructor
{{
this.color = color;
this.doors = puertas;
this.mpg = mpg;
}
public void showcolor () // Medhod
{{
Console.WriteLine (this.color);
}
}
C#está bien empaquetado todos los atributos y métodos de la clase de automóvil, por lo que cuando ve este código, sabe qué funciones es lograr, y define la información de un objeto. Las personas que critican el constructor/prototipo de constructores mixtos creen que el método para encontrar atributos en la memoria del constructor y el método para encontrar métodos fuera de él no es lógico. Por lo tanto, diseñaron un prototipo dinámico para proporcionar un estilo de codificación más amigable.
La idea básica del método de prototipo dinámico es la misma que el constructor/prototipo de la estructura mixta, es decir, definir los atributos de no función en el constructor, y el atributo de función se define utilizando el atributo prototipo. La única diferencia es la posición del método de objeto. La siguiente es la clase de automóvil reescrita por un prototipo dinámico:
Copiar código del código de la siguiente manera:
<script type = "text/javaScript">
//definición
Fuinction coche () {
this.color = "rojo";
this.Doors = 4;
this.drivers = new Array ("Tom", "Jerry");
ifof car._initialized == "indefinido") {{
Car.prototype.showColor = function () {
Alerta (this.color);
}
// ............
}
// Última definición
Coche._initialized = true;
}
</script>
Hasta que verifica el tipo de automóvil. Esta línea de código es la parte más importante del método de prototipo dinámico. Si este valor no se define, el constructor continuará definiendo el método de objeto por prototipo y luego configure el automóvil. Si este valor se define (cuando su valor es verdadero, el valor de typeOf es booleano), entonces este método no se creará. En resumen, este método utiliza el logotipo (_inicializado) para determinar si ha dado algún método al prototipo. Este método solo se crea y asigna una vez.
6 Método de fábrica híbrida
Este método suele ser una forma de cambiar la forma en que no se puede aplicar el método anterior. Su propósito es crear un constructor falso y devolver solo un nuevo ejemplo de otro objeto. Este código parece ser muy similar a la función de fábrica:
Copiar código del código de la siguiente manera:
Fuinction coche () {
var ompcar = new Object ();
ionmpcar.color = "rojo";
ionmpcar.doors = 4;
ionmpcar.mpg = 23;
ionmpcar.showColor = function () {
Alerta (this.color);
}
Regresar otempcar;
}
A diferencia del método clásico, este método utiliza el nuevo operador para que parezca una función de estructura real:
var oCar = nuevo coche ();
Debido a que el nuevo operador se llama dentro del constructor Car (), el segundo nuevo operador será ignorado (ubicado fuera del constructor). El objeto creado en el constructor se vuelve a pasar a la variable var. Este método tiene los mismos problemas que los métodos clásicos del método de objeto. Muy recomendable: a menos que tenga que (ver Capítulo 15), aún evita este método.
Resumen: (qué método se utiliza)
En la actualidad, el más utilizado es un constructor/prototipo mixto. Además, los prototipos dinámicos también son muy populares y son equivalentes a la función/prototipo funcional en función. Puede usar cualquiera de estos dos métodos. Sin embargo, no use el constructor o prototipo clásico, porque esto introducirá el código en el problema.
Copiar código del código de la siguiente manera:
// ps
// Clase estática (1: función)
varcollection = new function () {
var _Carcollection = new Array ();
this.add = function (objcar) {
alerta ('agregar');
}
this.get = function (carid) {
alerta ('Get');
}
}
// Clase estática (2: JSON)
var car = {
Color: 'rojo',
Puertas: 4,
showcolor: function () {alert (this.color);}
}
Car.showColor ();