En JavasCritp, este no es necesariamente el único contexto del método de objeto, y esto también se menciona en las llamadas de funciones globales y varios otros contextos diferentes.
Puede ser un objeto global, un objeto actual, o cualquier objeto, dependiendo completamente de cómo se llama a la función. Hay varias formas de llamar a las funciones en JavaScript: como llamadas del método de objeto, como llamadas a funciones, como llamadas de constructor y usando llamadas de aplicación o llamadas.
1. Llame como método de objeto
En JavaScript, las funciones también son objetos, por lo que las funciones pueden usarse como atributos de un objeto. En este momento, la función se llama método del objeto. Al usar este método de llamadas, esto está naturalmente unido al objeto.
La copia del código es la siguiente:
Var Point = {
x: 0,
Y: 0,
Moveto: function (x, y) {
this.x = this.x + x;
this.y = this.y + y;
}
};
Point.moveto (1, 1) // Esto se une al objeto actual, es decir, objeto de punto
2. En función de la llamada
La función también se puede llamar directamente, y esto está vinculado al objeto global. En el navegador, Window es el objeto global. Por ejemplo, el siguiente ejemplo: cuando se llama una función, esto está vinculado al objeto global, y la declaración de asignación se ejecuta a continuación, que es equivalente a declarar implícitamente una variable global, que obviamente no es lo que la persona que llama quiere.
La copia del código es la siguiente:
función makeneSense (x) {
this.x = x;
}
makeneSense (5);
x; // x se ha convertido en una variable global con un valor de 5
Para las funciones internas, es decir, las funciones declaradas dentro del cuerpo de otra función, esta forma de vincularse a un objeto global creará otro problema. Usaremos el objeto de punto mencionado anteriormente como ejemplo. Esta vez esperamos definir dos funciones dentro del método Moveto, y traducir las coordenadas X e Y respectivamente. El resultado puede ser inesperado. El punto no solo no se mueve, sino que hay dos variables globales adicionales x e y.
La copia del código es la siguiente:
Var Point = {
x: 0,
Y: 0,
Moveto: function (x, y) {
// Funciones internas
var mudex = function (x) {
This.x = x; // ¿Dónde está esto vinculado?
};
// Funciones internas
var Movey = function (y) {
this.y = y; // ¿Dónde está esto vinculado?
};
Movex (x);
movimiento (y);
}
};
punto.moveto (1, 1);
punto.x; // ==> 0
punto.y; // ==> 0
incógnita; // ==> 1
y; // ==> 1
Este es un defecto de diseño de JavaScript. El método de diseño correcto es que este de la función interna debe estar unida al objeto correspondiente a su función externa. Para evitar esta falla de diseño, el inteligente programador de JavaScript se le ocurrió un método para reemplazar las variables, que convencionalmente se llama eso.
La copia del código es la siguiente:
Var Point = {
x: 0,
Y: 0,
Moveto: function (x, y) {
var que = esto;
// Funciones internas
var mudex = function (x) {
que.x = x;
};
// Funciones internas
var Movey = function (y) {
que.y = y;
}
Movex (x);
movimiento (y);
}
};
punto.moveto (1, 1);
punto.x; // ==> 1
punto.y; // ==> 1
Llamado como constructor
JavaScript admite la programación orientada a objetos. A diferencia de los lenguajes de programación orientados a objetos principales, JavaScript no tiene el concepto de clase, pero utiliza un método de herencia basado en prototipos. En consecuencia, los constructores en JavaScript también son muy especiales. Si no usa nuevas llamadas, es lo mismo que las funciones ordinarias. Como otra regla convencional, el constructor comienza con letras mayúsculas para recordarle a la persona que llama de la manera correcta. Si la llamada es correcta, esto está vinculado al objeto recién creado.
La copia del código es la siguiente:
punto de función (x, y) {
this.x = x;
this.y = y;
}
Llamado usando aplicar o llamar
Reiteramos que en las funciones de JavaScript también son objetos, los objetos tienen métodos y aplicar y llamar son métodos de objetos de función. Estos dos métodos son extremadamente potentes y permiten cambiar el contexto de la ejecución de la función, es decir, el objeto unido a esto. Este método se utiliza en muchas técnicas de JavaScript y bibliotecas de clases. Veamos un ejemplo específico:
La copia del código es la siguiente:
punto de función (x, y) {
this.x = x;
this.y = y;
this.moveto = function (x, y) {
this.x = x;
this.y = y;
}
}
var p1 = nuevo punto (0, 0);
var p2 = {x: 0, y: 0};
p1.moveto (1, 1);
p1.moveto.apply (P2, [10, 10]);
En el ejemplo anterior, usamos el constructor para generar un objeto P1, que también tiene un método Moveto; Use el objeto literal para crear otro objeto P2, y vemos que, utilizando aplicar, el método de P1 se puede aplicar a P2, y esto también está vinculado al objeto P2. Otra llamada de método también tiene la misma función, la diferencia es que el último parámetro no se pasa en uniforme como una matriz, sino que se pasa por separado.
La copia del código es la siguiente:
función foo () {
//1. Este constructor referenciado es un objeto referenciado por el argumento. Callee
// Las instrucciones son constructores ejecutadas a través del nuevo operador
if (this.constructor == arguments.callee) {
alerta ('objeto creado');
}
//2. Esta es la ventana, entonces es una llamada global
if (this == Window) {
alerta ('llamada normal');
}
else {// 3. De lo contrario se llama como método de otros objetos
alerta ('llamado por'+ this.constructor);
}
}
Foo (); // Llama de función global
Foo.call (nuevo objeto ()); // llamar como método miembro de un objeto objeto
nuevo foo (); // llamado por el nuevo operador para ejecutar la construcción de objetos