Las funciones de JavaScript son diferentes de otros lenguajes. Cada función se mantiene y ejecuta como un objeto. A través de las propiedades de los objetos de función, puede asignar fácilmente una función a una variable o pasar la función como parámetro. Antes de continuar, echemos un vistazo a la sintaxis del uso de funciones:
Aquí hay una cita:
función función1(…){…}
var func2=función(…){…};
var func3=función func4(…){…};
var func5=nueva función();
Copie el código de código de la siguiente manera:
<tipo de script="texto/javascript">
// 1, modo de llamada al método
// Cuando una función se guarda como propiedad de un objeto, la llamamos método del objeto, luego esto se vincula al objeto
var miObjeto={
nombre: "miObjeto",
valor: 0,
incremento: función(núm){
this.value += tipode(núm) === 'número' núm: 0;
devolver esto;
} ,
toString: función(){
return '[Objeto:' + este.nombre + ' {valor:' + este.valor + '}]';
}
}
alert(myObject.increment(10).increment(20).toString()); // [Objeto:myObject {valor:30}]
// 2, modo de llamada de función
// Cuando una función no es una función de un objeto, se llama como una función y esta está vinculada al objeto global. Este es un error en el diseño del lenguaje. Si el diseño del lenguaje es correcto, cuando se llama a la función interna, esta aún debería estar vinculada a esta variable de la función externa.
var miObjeto={
nombre: "miObjeto",
valor: 0,
incremento: función(núm){
this.value += tipode(núm) === 'número' núm: 0;
devolver esto;
} ,
toString: función(){
return '[Objeto:' + este.nombre + ' {valor:' + este.valor + '}]';
},
obtener información: función(){
var self=esto;
retorno (función(){
//return this.toString(); // Esto en la función anónima interna apunta a la ventana del objeto global y genera [object Window]
return self.toString(); // Defina una variable selft y asígnele el valor this, luego la función interna puede acceder a esto apuntando al objeto a través de esta variable
})();
}
}
alert(myObject.increment(10).increment(20).toString()); // [Objeto:myObject {valor:30}]
// 3, modo de llamada al constructor
// JavaScript es un lenguaje basado en herencia prototípica, lo que significa que los objetos pueden heredar propiedades directamente de otros objetos y el lenguaje no tiene clases.
// Si se llama a una función con new delante, se creará un nuevo objeto que oculta el miembro prototipo conectado a la función, y este estará vinculado a la instancia del constructor.
función MiObjeto(nombre){
this.name = nombre || 'MiObjeto';
este.valor=0;
this.incremento = función(núm){
this.value += tipode(núm) === 'número' núm: 0;
};
this.toString = función(){
return '[Objeto:' + este.nombre + ' {valor:' + este.valor + '}]';
}
este.objetivo = esto;
}
MiObjeto.prototipo.getInfo = función(){
devolver this.toString();
}
// Crea un objeto MyObject.prototype al mismo tiempo. myObject hereda todas las propiedades de MyObject.prototype. Esto está vinculado a la instancia de MyObject.
var miObjeto = nuevo MiObjeto();
miObjeto.incremento(10);
alerta(miObjeto.valor); //10
var otroObjeto = nuevo MiObjeto();
otroObjeto.incremento(20);
alerta(otroObjeto.valor); //20
alerta(miObjeto.destino===miObjeto); // verdadero);
alert(myObject.target.getInfo()); // [Objeto:MiObjeto {valor:10}]
// 4, Aplicar modo de llamada
// JavaScript es un lenguaje de programación funcional orientado a objetos, por lo que las funciones pueden tener métodos. El método de aplicación de la función es como si el objeto tuviera este método y esto apunta al objeto.
// aplicar recibe dos parámetros, el primero es el objeto a vincular (el objeto al que apunta) y el segundo es la matriz de parámetros.
función MiObjeto(nombre){
this.name = nombre || 'MiObjeto';
este.valor = 0;
this.incremento = función(núm){
this.value += tipode(núm) === 'número' núm: 0;
};
this.toString=función(){
return '[Objeto:'+este.nombre+' {valor:'+este.valor+'}]';
}
this.objetivo=esto;
}
función obtener información(){
devolver this.toString();
}
var miObj = nuevo MiObjeto();
alert(getInfo.apply(myObj)); //[Objeto:MiObjeto {valor:0}], esto apunta a miObj
alert(getInfo.apply(ventana)); //[objeto ventana], esto apunta a la ventana
// durante y mientras
función función(a,b){
alerta(a); // 1
alerta(b); // 2
for(var i=0;i<argumentos.longitud;i++){
alerta(argumentos[i]); // 1, 2, 1, 2, 3
}
var i=0;
while(i<argumentos.longitud){
alerta(argumentos[i]); // 1, 2, 1, 2, 3
yo=yo+1;
}
}
función (1,2,3);
var i=0
para (i=0;i<=10;i++) {
document.write("El número es " + i + "<br/>")
}
</script>