1. Herencia de objetos en js
Hay tres métodos de herencia en js.
1.js prototipo (prototipo) implementa la herencia
Copie el código de código de la siguiente manera:
<SPAN style="COLOR-FONDO: #ffffff"><SPAN style="TAMAÑO-FUENTE: 18px"><html>
<cuerpo>
<tipo de script="texto/javascript">
función Persona(nombre,edad){
this.nombre=nombre;
esta.edad=edad;
}
Persona.prototype.sayHello=función(){
alert("Usar prototipo para obtener Nombre: "+this.name);
}
var per=nueva Persona("Ma Xiaoqian",21);
per.sayHello(); //Salida: use el prototipo para obtener el nombre: Ma Xiaoqian
función Estudiante(){}
Student.prototype=nueva persona("Hong Rutong",21);
var stu=nuevo Estudiante();
Estudiante.prototipo.grado=5;
Estudiante.prototipo.intr=función(){
alerta (este.grado);
}
stu.sayHello();//Salida: use el prototipo para obtener el nombre: Hong Rutong
stu.intr();//Salida: 5
</script>
</cuerpo>
</html></SPAN></SPAN>
2. El constructor implementa la herencia.
Copie el código de código de la siguiente manera:
<SPAN style="TAMAÑO DE FUENTE: 18px"><html>
<cuerpo>
<tipo de script="texto/javascript">
función Padre(nombre){
this.nombre=nombre;
this.sayParent=función(){
alert("Padre:"+este.nombre);
}
}
función Niño(nombre,edad){
this.tempMethod=Padre;
this.tempMethod(nombre);
esta.edad=edad;
this.sayChild=función(){
alert("Niño:"+este.nombre+"edad:"+esta.edad);
}
}
var padre = nuevo padre ("Jiang Jianchen");
parent.sayParent(); //Salida: "Padre: Jiang Jianchen"
var niño=nuevo Niño("李明",24); //Salida: "Niño:李明edad:24"
niño.sayChild();
</script>
</cuerpo>
</html></SPAN>
3.llamar, aplicar para implementar la herencia
Copie el código de código de la siguiente manera:
<SPAN style="TAMAÑO DE FUENTE: 18px"><html>
<cuerpo>
<tipo de script="texto/javascript">
función Persona(nombre,edad,amor){
this.nombre=nombre;
esta.edad=edad;
this.amor=amor;
this.say=función say(){
alerta("Nombre:"+nombre);
}
}
//llamar al método
función estudiante(nombre,edad){
Persona.llamada(este,nombre,edad);
}
//aplicar método
función profesor(nombre,amor){
Persona.apply(esto,[nombre,amor]);
//Person.apply(this,arguments); //Mismo efecto que la oración anterior, argumentos
}
//Similitudes y diferencias entre call y aply:
//1, el primer parámetro es el mismo, se refiere al objeto actual
// 2, el segundo parámetro es diferente: call es una lista de parámetros uno por uno; apply es una matriz (también se pueden usar argumentos)
var per=new Person("Wufenglou",25,"Wei Yingping"); //Salida: "Wufenglou"
por.say();
var stu=nuevo estudiante("Cao Yu",18);//Salida: "Cao Yu"
stu.say();
var tea=nuevo profesor("Qin Jie",16);//Salida: "Qin Jie"
té.decir();
</script>
</cuerpo>
</html></SPAN>
2. Uso de llamar y aplicar (introducción detallada)
Tanto llamar como aplicar en js pueden implementar la herencia. La única diferencia de parámetros es que el método de escritura de aplicación correspondiente a func.call (func1, var1, var2, var3) es: func.apply (func1, [var1, var2, var3]) .
La explicación de la llamada en el manual JS:
Copie el código de código de la siguiente manera:
<SPAN style="FONT-SIZE: 18px">método de llamada
Llame a un método en un objeto para reemplazar el objeto actual con otro objeto.
llamar([esteObj[,arg1[, arg2[, [,.argN]]]]])
parámetro
esteObj
Opcional. El objeto que se utilizará como objeto actual.
arg1, arg2, , argN
Opcional. Se pasará una secuencia de parámetros del método.
ilustrar
El método de llamada se puede utilizar para llamar a un método en nombre de otro objeto. El método de llamada cambia el contexto del objeto de una función desde el contexto inicial al nuevo objeto especificado por thisObj.
Si no se proporciona el parámetro thisObj, el objeto global se utiliza como thisObj. </SPAN>
En pocas palabras, la función de estas dos funciones es en realidad cambiar el puntero interno del objeto, es decir, cambiar el contenido al que apunta el objeto. A veces esto es útil en la programación js orientada a objetos. Tomemos Apply como ejemplo para hablar sobre el importante papel de estas dos funciones en js. como:
Copie el código de código de la siguiente manera:
<SPAN style="FONT-SIZE: 18px"> function Persona(nombre,edad){ //Definir una clase
this.nombre=nombre; //nombre
this.age=edad; //Edad
this.sayhello=function(){alerta(este.nombre)};
}
function Print(){ //Mostrar atributos de clase
this.funcName="Imprimir";
this.mostrar=función(){
var mensaje=[];
for(var clave en esto){
if(tipode(esta[clave])!="función"){
msg.push([clave,":",esta[clave]].join(""));
}
}
alerta(msg.join(" "));
};
}
function Estudiante(nombre,edad,grado,escuela){ //Clase de estudiante
Person.apply(this,arguments); // Ventajas sobre la llamada
Print.apply(esto,argumentos);
this.grade=calificación; //Calificación
this.school=escuela; //escuela
}
var p1=nueva Persona("Bu Kaihua",80);
p1.saluda();
var s1=nuevo Estudiante("Bai Yunfei",40,9,"Academia Yuelu");
s1.mostrar();
s1.saluda();
alerta(s1.funcName);</SPAN>
Además, Function.apply() juega un papel destacado en la mejora del rendimiento del programa:
Comencemos con la función Math.max(). Math.max puede ir seguido de cualquier número de parámetros y finalmente devuelve el valor máximo entre todos los parámetros.
Por ejemplo
Copie el código de código de la siguiente manera:
<SPAN style="FONT-SIZE: 18px">alert(Math.max(5,8));
alerta(Math.max(5,7,9,3,1,6));
//Pero en muchos casos necesitamos encontrar el elemento más grande de la matriz.
vararr=[5,7,9,1];
//alert(Math.max(arr)); // Esto no funciona. Yaya
//Escríbelo así
función getMax(arr){
var arrLen=arr.length;
for(var i=0,ret=arr[0];i<arrLen;i++){
ret=Math.max(ret,arr[i]);
}
volver atrás;
}
alerta(getMax(arr)); //9
// Cambia para aplicar, puedes escribir así
función getMax2(arr){
devolver Math.max.apply(nulo,arr);
}
alerta(getMax2(arr)); //9
// Los dos fragmentos de código logran el mismo propósito, pero getMax2 es elegante, eficiente y mucho más conciso.
//Otro ejemplo es el método push de la matriz.
vararr1=[1,3,4];
vararr2=[3,4,5];
// Si queremos expandir arr2, luego agregar a arr1 uno por uno y finalmente dejar arr1=[1,3,4,3,4,5]
//arr1.push(arr2) obviamente no funciona. Porque al hacer esto obtendrás [1,3,4,[3,4,5]]
// Solo podemos usar un bucle para empujar uno por uno (por supuesto, también puedes usar arr1.concat (arr2), pero el método concat no cambia arr1 en sí)
var arrLen=arr2.length;
for(var i=0;i<arrLen;i++){
arr1.push(arr2[i]);
}
//Desde la introducción de Apply, las cosas se han vuelto muy simples
Array.prototype.push.apply(arr1,arr2); //Ahora arr1 es el resultado deseado</SPAN>