1. Isso aponta para o objeto de instanciação do construtor
No artigo anterior, mencionamos a diferença entre usar novos e não chamando construtores, como mostrado no exemplo a seguir:
A cópia do código é a seguinte:
função benjamin (nome de usuário, sexo) {
this.UserName = Nome de usuário;
this.sex = sexo;
}
var Benjamin = New Benjamin ("Zuojj", "Masculino");
// saídas: Benjamin {Sex: "masculino", nome de usuário: "Zuojj"}
console.log (Benjamin);
var Ben = Benjamin ("Zhangsan", "Feminino");
// saídas: indefinido
console.log (ben);
Quando o construtor é chamado de função normal, nenhum valor é retornado, e isso aponta para o objeto global. Então, como podemos evitar problemas causados pela falta de novas palavras -chave?
A cópia do código é a seguinte:
função benjamin (nome de usuário, sexo) {
// Verifique se "this" é um objeto "Benjamin"
if (esta instância de Benjamin) {
this.UserName = Nome de usuário;
this.sex = sexo;
}outro {
devolver o novo Benjamin (nome de usuário, sexo);
}
}
var Benjamin = New Benjamin ("Zuojj", "Masculino");
// saídas: Benjamin {Sex: "masculino", nome de usuário: "Zuojj"}
console.log (Benjamin);
var Ben = Benjamin ("Zhangsan", "Feminino");
// saídas: Benjamin {Nome de usuário: "Zhangsan", sexo: "feminino"}
console.log (ben);
No exemplo acima, primeiro verificamos se essa é uma instância de Benjammin, caso contrário, usemos o novo para chamar automaticamente o construtor e instanciá -lo, o que significa que não precisamos mais nos preocupar em perder o novo construtor de instanciais de palavras -chave. Obviamente, podemos desenvolver um mau hábito dessa maneira. E se evitarmos esse fenômeno? Podemos apresentar um erro como este:
A cópia do código é a seguinte:
função benjamin (nome de usuário, sexo) {
// Verifique se "this" é um objeto "Benjamin"
if (esta instância de Benjamin) {
this.UserName = Nome de usuário;
this.sex = sexo;
}outro {
// Se não, jogue o erro.
lançar um novo erro ("` Benjamin` chamado sem `new`);
}
}
2. Isso aponta para o objeto que chama a função
Veja o seguinte exemplo:
A cópia do código é a seguinte:
var x = 10;
var obj = {
x: 10,
saída: function () {
// saídas: true
console.log (this === obj);
retornar this.x;
},
InnerRobj: {
x: 30,
saída: function () {
// saídas: true
console.log (this === obj.innerobj);
retornar this.x;
}
}
};
// saídas: 10
console.log (obj.Output ());
// saídas: 30
console.log (obj.innerobj.output ());
3. Isso aponta para o objeto global
Ao discutir o construtor acima, também discutimos que, quando o novo não é aplicável, isso apontará para o objeto global. Vamos dar uma olhada em dois exemplos comuns propensos a erros:
A cópia do código é a seguinte:
var x = 100;
var obj = {
x: 10,
saída: function () {
(function () {
// saídas: true
console.log (this === Window);
// saídas: interno: 100
console.log ("interno:" + this.x);
}) ();
retornar this.x;
}
};
// saídas: 10
console.log (obj.Output ());
Ao usar o fechamento, o escopo muda e isso aponta para a janela (no navegador).
A cópia do código é a seguinte:
var x = 100;
var obj = {
x: 10,
saída: function () {
retornar this.x;
}
};
var output = obj.Output;
// saídas: 10
console.log (obj.Output ());
// saídas: 100
console.log (output ());
var obj2 = {
x: 30,
Saída: obj.Output
}
// saídas: 30
console.log (obj2.Output ());
Neste momento, isso sempre aponta para o objeto no momento da chamada da função.
4. Isso aponta para o objeto atribuído pelo método Apply/Call ()
A cópia do código é a seguinte:
var x = 100;
var obj = {
x: 10,
saída: function () {
retornar this.x;
}
};
// saídas: 10
console.log (obj.Output ());
var obj2 = {
x: 40,
Saída: obj.Output
}
// Saídas: 40
console.log (obj.output.call (obj2));
// saídas: 10
console.log (obj2.Output.Apply (obj));
5. Esta da função de retorno de chamada aponta para o objeto apontado por essa função que chama o retorno de chamada.
A cópia do código é a seguinte:
// <input type = "text" value = "3" id = "txt_username">
$ ("#nome de usuário"). on ("clique", function () {
console.log (this.value);
});
6. Este em function.prototype.bind
O método bind () cria uma nova função que, quando chamada, tem essa palavra -chave definida como o valor fornecido, com uma determinada sequência de argumentos que precedem qualquer qualquer quando a nova função é chamada.
Exemplo 1:
A cópia do código é a seguinte:
função pessoa () {
retornar este.name;
}
//Function.prototype.bind
var per = pessoa.bind ({
Nome: "Zuojj"
});
console.log (PER);
var obj = {
Nome: "Ben",
pessoa: pessoa,
Per: por
};
// Saídas: Ben, Zuojj
console.log (obj.person (), obj.per ());
Exemplo 2:
A cópia do código é a seguinte:
this.x = 9;
var módulo = {
x: 81,
getx: function () {return this.x; }
};
// Saídas: 81
console.log (module.getx ());
var getx = module.getx;
// saídas: 9, porque neste caso, "isso" refere -se ao objeto global
console.log (getX);
// Crie uma nova função com 'this' vinculada ao módulo
var limitex = getx.bind (módulo);
// Saídas: 81
console.log (limite ());