Meu entendimento disso sempre foi apenas sobre poder usá -lo e saber, mas não mergulhei em sua essência. Desta vez, tenho um profundo entendimento com "JavaScript the Good Parts". (Toda a depuração pode ser vista no console, chave do navegador F12)
Vamos dar uma olhada nisso juntos.
Quando declaramos uma função, cada função possui dois parâmetros adicionais (parâmetros formais) definidos, um é esse e o outro são argumentos. Os argumentos são os parâmetros realmente aceitos pela função e são uma variedade de classes. Vou dar apenas uma breve introdução aos argumentos e nos concentraremos neste ponteiro.
Na transformação orientada a objetos, isso é muito importante e seu valor depende do padrão da chamada. No JavaScript, existem 4 padrões de chamada no total: padrões de chamada de método, padrões de chamada de função, padrões de chamada de construtor e padrões de chamada de aplicação.
Modo de chamada de método
Quando uma função é um atributo como objeto, geralmente chamamos essa função de método desse objeto. Quando esse método é chamado, isso aponta para o objeto ao qual o método pertence.
A cópia do código é a seguinte:
<script type = "text/javascript">
var pessoas = {
Nome: "Yika",
SayName: function () {
console.log (this.name); // "Yika"
// Isso foi vinculado ao objeto de pessoas
}
}
People.SayName ();
</script>
Como mostrado por Chestnut, isso aponta para o objeto SayName. Este método de obter o contexto do objeto através disso é um método público. (Método Publices)
Modo de chamada de função
Quando uma função é chamada não é um método em um objeto, ela é chamada de função.
Essa chamada de padrão apontará para o objeto da janela, mesmo que essa função possa ser chamada em uma função externa, vejamos.
A cópia do código é a seguinte:
<script type = "text/javascript">
var name = "window-yika";
var pessoas = {
Nome: "People-yika",
aluno: function () {
console.log (this); // Isso liga o objeto pessoas aqui
function SayName () {
var name = "SayName-yika";
console.log (this.name); // window-yika
// Mesmo que a função SayName e o povo esteja localizado tenha valor de nome, isso aponta para a janela
};
SayName ();
}
}
pessoas.student ();
</script>
Nessa perspectiva, você sabe como resolver o JavaScript "Erro de design".
Sim, basta cache isso na função do aluno, ou seja, linha 6. Em seguida, transfira isso para a função Sayname através das variáveis para resolvê -lo!
A cópia do código é a seguinte:
var pessoas = {
Nome: "People-yika",
aluno: function () {
var self = this; // cache isso
function SayName () {
var name = "SayName-yika";
console.log (self.name); // "People-yika", neste momento, aponta para o objeto de pessoas
};
SayName ();
}
}
Modo de chamada do construtor
Quando o JavaScript fala sobre construtores, você pensará: "O nome da função é capitalizado! Use o novo operador ao ligar!" A capitalização de nomes da função é fácil de entender, a fim de padronizar a nomeação do construtor. Mas você já se aprofundou por que precisa usar o novo? Se você chamar uma nova função com a nova, o fundo da função criará um novo objeto apontando para o protótipo da função, e isso também estará vinculado ao novo objeto. JavaScript é uma linguagem baseada na herança do protótipo. Os alunos que não estão muito claros sobre os protótipos de protótipos podem verificar as informações sozinhas. Eu me concentro nisso.
Vamos primeiro olhar para a aparência do construtor.
A cópia do código é a seguinte:
<script type = "text/javascript">
função pessoas (nome) {
this.name = nome; // Isso aqui aponta para o novo objeto Yika depois de chamá -lo com novo
this.sayName = function () {
console.log (this.name); //Saída
}
}
var yika = novas pessoas ("Yika");
Yika.sayName (); // Saída "Yika" porque o Yika é obtido através de uma nova chamada, isso está ligado ao objeto Yika.
</script>
À primeira vista, parece que não é fácil de entender. Por que isso apontou para a janela da função agora e agora você pode apontar para as pessoas funcionarem sem cache?
Não importa. Você não apenas disse que a função fará "coisas ruins" secretamente chamando de novo? Vamos ver o que exatamente você fez.
A cópia do código é a seguinte:
<script type = "text/javascript">
função pessoas (nome) {
var que = {}; // coisa ruim um: gerar um objeto sozinho
that.name = nome;
that.SayName = function () {
console.log (that.name);
};
devolver isso; // coisa ruim 2, você mudará o comportamento do retorno, devolverá o objeto que acabou de ser gerado
}
var yika = pessoas ("yika"); // novo pode ser omitido aqui e imitar a chamada para o novo operador
Yika.sayName (); // saída "Yika" como agora
</script>
Você pode ver claramente dessa maneira. O novo não apenas gerará um objeto, mas também retornará automaticamente o objeto, para que isso indique naturalmente para esse novo objeto.
Lembre -se de usar o novo para chamar o construtor; caso contrário, não haverá aviso se algo der errado, e todos os acordos de capital ainda são muito necessários.
Aplique o modo de chamada
O método Aplicar nos permite criar uma matriz de parâmetros passados para a função de chamada, o que também nos permite alterar esse valor.
function.Apply (este valor limitado, Array de parâmetros de argumentos)
Há tantas coisas que posso dizer, só vou te dar uma castanha aqui para ajudá -lo a entender:
A cópia do código é a seguinte:
<script type = "text/javascript">
função pessoas (nome) {
this.name = nome;
this.sayName = function () {
console.log (this.name); // o método SayName pertence ao construtor de pessoas
}
}
Função Student (nome) {
People.Apply (isto, argumentos); // O método de integração de emprestar construtores é chamar de construção de construtores, aplicando -se no construtor do aluno e alterar esse valor das pessoas
// Dessa forma, toda vez que uma instância do aluno é criada, o construtor de pessoas será chamado
}
VAR Student = novo aluno ("Yika");
estudante.SayName (); // Saída "Yika"
</script>
Podemos modificar facilmente a função esse objeto de ligação através do Apply. Chamada semelhante para aplicar também tem o mesmo efeito. Os alunos interessados podem pesquisar e aprender sozinhos.
Ok, finalmente terminamos de alterar os quatro modos de chamada disso. O modo de chamada de método e o modo de chamada de construtor serão mais usados e será mais importante. Para o modo de chamada de função, devemos aprender a evitar as armadilhas nele.
Se houver algum erro, denuncie -o a tempo e eu o corrigirei o mais rápido possível para impedir os outros. Obrigado!