No JavaScritp, este não é necessariamente o único contexto do método de objeto. Isso também é referido nas chamadas de função global e em vários outros contextos diferentes.
Pode ser um objeto global, um objeto atual ou qualquer objeto, dependendo inteiramente de como a função é chamada. Existem várias maneiras de chamar funções no JavaScript: como chamadas de método de objeto, como chamadas de função, como chamadas de construtor e usando chamadas Aplicar ou chamadas.
1. Chame como método de objeto
No JavaScript, as funções também são objetos, portanto, as funções podem ser usadas como atributos de um objeto. No momento, a função é chamada de método do objeto. Ao usar esse método de chamada, isso está naturalmente ligado ao objeto.
A cópia do código é a seguinte:
var point = {
x: 0,
y: 0,
moveto: function (x, y) {
this.x = this.x + x;
this.y = this.y + y;
}
};
Point.moveto (1, 1) // isso se liga ao objeto atual, ou seja, objeto de ponto
2. Como uma chamada de função
A função também pode ser chamada diretamente, e isso está ligado ao objeto global. No navegador, a janela é o objeto global. Por exemplo, o exemplo a seguir: Quando uma função é chamada, isso está vinculado ao objeto global e a declaração de atribuição é executada a seguir, o que é equivalente a declarar implicitamente uma variável global, que obviamente não é o que o chamador deseja.
A cópia do código é a seguinte:
função makenosense (x) {
this.x = x;
}
makenosense (5);
x; // x tornou -se uma variável global com um valor de 5
Para funções internas, ou seja, funções declaradas dentro do corpo de outra função, essa maneira de se ligar a um objeto global criará outro problema. Continuaremos a usar o objeto Point mencionado anteriormente como exemplo. Desta vez, esperamos definir duas funções dentro do método moveto e traduzir as coordenadas X e Y, respectivamente. O resultado pode ser inesperado. O objeto Point não apenas não se move, mas existem duas variáveis globais adicionais x e y.
A cópia do código é a seguinte:
var point = {
x: 0,
y: 0,
moveto: function (x, y) {
// Funções internas
var movex = function (x) {
This.x = x; // Para onde isso está ligado?
};
// Funções internas
var movey = function (y) {
this.y = y; // Para onde isso está ligado?
};
movex (x);
movey (y);
}
};
Point.moveto (1, 1);
Point.x; // ==> 0
Point.Y; // ==> 0
x; // ==> 1
y; // ==> 1
Esta é uma falha de design do JavaScript. O método de design correto é que essa da função interna deve estar ligada ao objeto correspondente à sua função externa. Para evitar essa falha de design, o inteligente programador JavaScript criou um método para substituir as variáveis, que é o nome convencionalmente.
A cópia do código é a seguinte:
var point = {
x: 0,
y: 0,
moveto: function (x, y) {
var que = this;
// Funções internas
var movex = function (x) {
that.x = x;
};
// Funções internas
var movey = function (y) {
that.y = y;
}
movex (x);
movey (y);
}
};
Point.moveto (1, 1);
Point.x; // ==> 1
Point.Y; // ==> 1
Chamado como construtor
O JavaScript suporta programação orientada a objetos. Ao contrário das linguagens de programação orientadas a objetos convencionais, o JavaScript não possui o conceito de classe, mas usa um método de herança baseado em protótipo. Da mesma forma, os construtores em JavaScript também são muito especiais. Se você não usar novas chamadas, é o mesmo que as funções comuns. Como outra regra convencional, o construtor começa com letras maiúsculas para lembrar o chamador a chamar da maneira correta. Se a chamada estiver correta, isso estará vinculado ao objeto recém -criado.
A cópia do código é a seguinte:
ponto de função (x, y) {
this.x = x;
this.y = y;
}
Chamado usando aplicação ou chamada
Vamos reiterar que, nas funções JavaScript, também são objetos, objetos têm métodos e aplicar e chamadas são métodos de função. Esses dois métodos são extremamente poderosos e permitem alternar o contexto da execução da função, ou seja, o objeto ligado a isso. Este método é usado em muitas técnicas de JavaScript e bibliotecas de classes. Vejamos um exemplo específico:
A cópia do código é a seguinte:
ponto de função (x, y) {
this.x = x;
this.y = y;
this.moveto = function (x, y) {
this.x = x;
this.y = y;
}
}
var p1 = novo ponto (0, 0);
var p2 = {x: 0, y: 0};
P1.Moveto (1, 1);
p1.moveto.apply (p2, [10, 10]);
No exemplo acima, usamos o construtor para gerar um objeto P1, que também possui um método moveto; Use o objeto literal para criar outro objeto P2 e vemos que o uso da Aplicação, o método de P1 pode ser aplicado ao P2, e isso também está obrigado ao objeto P2. Outra chamada de método também tem a mesma função, a diferença é que o último parâmetro não é passado de uniforme como uma matriz, mas é passado separadamente.
A cópia do código é a seguinte:
function foo () {
//1.Este construtor referenciado é um objeto referenciado pelo argumento.callee
// As instruções são construtores executados através do novo operador
if (this.Constructor == argumentos.callee) {
alerta ('objeto criado');
}
//2. Esta é a janela, então é uma chamada global
if (this == window) {
alerta ('chamada normal');
}
else {// 3. Caso contrário, é chamado de método de outros objetos
alerta ('chamado por'+ this.Constructor);
}
}
Foo (); // Call Global Function
Foo.Call (new Object ()); // chama como um método de membro de um objeto objeto
novo foo (); // chamado pelo novo operador para executar a construção de objetos