A sintaxe JavaScript é flexível e não é incomum ter cinco ou seis métodos de implementação para a mesma função. Em seguida, juntamente com algum protótipo anti-humano herança e características assíncronas, é ainda mais confuso. Muitas vezes, não entendo a diferença entre chamada e aplicação, então a gravarei hoje para evitar esquecê -la novamente.
Em JavaScript, os métodos podem ser executados das seguintes maneiras:
1.Func () é a maneira mais direta e comum de chamar, e também está em conformidade com a lógica do pensamento das pessoas comuns, mas em alguns casos existem algumas deficiências, que serão explicadas abaixo.
2. (função (arg) {}) (janela), uma chamada de método anônimo, é mais útil ao construir um espaço para nome. Os parâmetros nos seguintes colchetes correspondem aos parâmetros recebidos no método anônimo um por um.
3.func.bind (sth) (). O Manual Mozilla menciona que o Bind é um novo recurso adicionado na 5ª edição da ECMA-262. Ele está listado separadamente como um método de chamada porque compensa o defeito de que o escopo não pode ser vinculado em chamadas diretas.
4.func.call (), esta é a segunda maneira de chamar. Cada método possui um método de chamada definido no protótipo para executar o método atual.
5.Func.Apply (), irmão gêmeo de Call.
func ()
Esta é a maneira mais comum de chamar e pode ser vista em qualquer lugar em qualquer idioma. func (x, y) pode passar em diferentes parâmetros. Em alguns idiomas, como PHP, Java, esse tipo de chamada é suficiente para resolver todos os problemas. Mas o JavaScript é uma linguagem funcional, e o conceito de fechamento e uma palavra -chave estranha que isso determina as deficiências dessa maneira de chamar. Isso deve ser interpretado como o escopo do segmento de código atual, que mudará à medida que o código é executado para diferentes fragmentos. No entanto, em alguns casos, não queremos que isso seja alterado, como eventos ligados a certos DOMs. Definitivamente, não queremos que isso seja transferido para o objeto da janela quando eles são chamados, mas às vezes isso é verdade, por exemplo, o código a seguir.
A cópia do código é a seguinte:
var a = {};
var func = function (x) {
console.log (this);
};
A.OnClick = function () {
var x = 100;
func (x);
};
A.OnClick ();
Você pode pensar em um link como um link na página. Como apenas queremos vincular o método definido ao evento OnClick, em vez de chamá -lo imediatamente, e esse método possui um parâmetro, precisamos embrulhá -lo com um método anônimo e passá -lo para o evento OnClick de a. Isso tem um problema. Isso no Func se torna a janela de objeto global, obviamente não queremos isso. No momento, o uso do FUNC () como método de chamada direta não é possível; portanto, precisamos vincular isso fora do Func ao método FUNC. Portanto, há um método de ligação, chamada, aplique.
vincular
O objetivo do Bind é muito simples, retornando o mesmo método que vincula esse objeto. O código acima pode alcançar o objetivo de vincular isso no objeto A modificando uma linha.
A cópia do código é a seguinte:
var a = {};
var func = function (x) {
console.log (this);
};
A.OnClick = function () {
var x = 100;
func.bind (this) (x); // vincular aqui
};
A.OnClick ();
Dessa forma, este evento OnClick não corre como uma mosca sem cabeça.
Ligue e aplique
Chamada e aplicação devem ser discutidas juntas, porque elas são muito semelhantes. Todos eles suportam vários parâmetros, e o primeiro parâmetro é esse objeto que estará vinculado, e o segundo parâmetro é a diferença deles. A chamada usa parâmetros independentes como parâmetros de invocação e o aplicativo usa uma matriz como parâmetros de invocação. Às vezes, não queremos alterar esse objeto, mas queremos ligá -lo artificialmente a outros objetos. Neste momento, ligue e aplique são muito úteis. (Não é que você não possa usar o Bind, mas parece que o Bind parece tardio, portanto a compatibilidade do navegador pode ser ruim). Pegue uma castanha:
A cópia do código é a seguinte:
a = {
func: function () {
this.x += 1;
},
x: 0
};
b = {
A: A,
X: 20
};
for (var i = 0; i <10; i ++) {
Bafunc ();
}
console.log (AX);
console.log (bx);
Existem x nos objetos A e B acima. Esperamos que o FUNC possa modificar o X correspondente de maneira direcionada, mas a chamada direta pode modificar apenas X no escopo do func, ou seja, AX. Modifique o código para alcançar o objetivo de modificar o BX
A cópia do código é a seguinte:
a = {
func: function () {
this.x += 1;
},
x: 0
};
b = {
A: A,
X: 20
};
for (var i = 0; i <10; i ++) {
bafunc.call (b); // liga isso a b
}
console.log (AX);
console.log (bx);
Essa castanha não é bem recebida e é um estilo de código muito confuso, com cenários aplicáveis, mas não está disponível em todos os lugares.