introduzir
Isso desempenha um papel muito importante em vários programas de objetos e é usado principalmente para apontar para o objeto de chamada. Porém, em JavaScript, o desempenho disso é muito diferente, principalmente em diferentes contextos de execução.
Do artigo anterior sabemos que este também é um atributo no contexto de execução, portanto está destinado a ser inseparável do contexto de execução.
Copie o código do código da seguinte forma:
activeExecutionContext = {
VO: {...},
isto: esteValor};
Em Javascript, o valor disso depende do modo de chamada. Existem quatro modos de chamada: modo de chamada de método, modo de chamada de função, modo de chamada de construtor e modo de chamada de aplicação.
modo de chamada
Padrão de chamada de método
Quando uma função é salva como propriedade de um objeto, nós a chamamos de método. Quando um método é chamado, this está vinculado ao objeto, ou seja, this no padrão de chamada do método aponta para o objeto chamador. Isso é muito fácil de entender. Você é um método meu, você me pertence e, claro, isso aponta para mim.
Copie o código do código da seguinte forma:
var meuObjeto = {
valor: 0,
incremento: função(inc) {
this.value += typeof inc === "número" inc: 1;
}
}
meuObjeto.increment();
console.log(meuObjeto.valor); //Saída: 1
meuObjeto.increment(3);
console.log(meuObjeto.valor); //Saída: 4
Como você pode acessar o objeto ao qual pertence por meio dele, você pode chamar e modificar as propriedades ou métodos do objeto por meio dele. Como pode ser visto no artigo anterior, este, como membro dos atributos no contexto de execução, deve ser criado no momento da criação do contexto. Toda a ligação deste ao objeto ocorre no momento da chamada, que é um ". ligação atrasada". Um alto grau de reutilização disso pode ser alcançado através da ligação retardada.
Copie o código do código da seguinte forma:
função mostrarValor(){
console.log(este.valor);
}
var a = { valor: "a"};
var b = {valor: "b"};
a.showValue = showValue;
b.showValue = showValue;
a.showValue(); //Saída "a"
b.showValue(); //Saída "b"
A função showValue no exemplo acima pertence à ligação atrasada.
padrão de chamada de função
Quando uma função não é chamada como método de um objeto, é uma chamada de função. No modo de chamada de função, isso está vinculado ao objeto global. (Este é um erro no design da linguagem)
Copie o código do código da seguinte forma:
meuObjeto.double = function(){
var isso = isso; //Solução
var ajudante = função(){
console.log(that, ": ", that.value); //Objeto de saída {valor: 4, incremento: função, double: função} ":" 4
console.log(this, ": ", this.value); //Janela de saída {top: Janela, janela: Janela…} ":" indefinido
}
helper(); //Chama como função
}
De acordo com o pensamento normal, conforme resultado da quarta linha, this deve apontar para o objeto ao qual a função pertence. Porém, devido a problemas no design da linguagem, this aponta para o objeto global. Isso torna tudo ainda mais misterioso e imprevisível. Mas, como desenvolvedores, esta situação é definitivamente algo que não queremos ver. Não é de bom senso jogar cartas. Felizmente, o remédio também é muito simples. Dessa forma, chamar isso no método auxiliar pode ser usado assim, o que é simples e conveniente. Quanto ao modo de chamada de função, o motivo pelo qual ele se comporta dessa forma será explicado em detalhes posteriormente, ao analisar o tipo de referência.
Padrão de chamada do construtor
Como o JavaScript é baseado na herança prototípica, seus projetistas desejam que ele seja capaz de criar objetos por meio de novos construtores como as linguagens orientadas a objetos tradicionais, realizando a programação orientada a objetos. Esta não parece ser uma boa ideia e é um pouco embaraçoso desenhar um tigre em vez de um cachorro. Uma é que é impossível aprender, mas não há necessidade de aprender. O mecanismo de herança prototípico do JavaScript já é muito poderoso, o suficiente para atender ao polimorfismo de herança necessário para orientação a objetos.
Sem mais delongas, vamos falar sobre o padrão de chamada do construtor. O padrão de chamada do construtor é muito simples. É usar uma função como construtor e, em seguida, introduzir as propriedades e métodos que você pretende tornar públicos. do seguinte modo
Copie o código do código da seguinte forma:
function Pessoa(nome, idade){
este.nome = nome;
esta.idade = idade;
isto.dizer=função(){
console.log("nome: %s, idade: %n", this.name, this.age);
}
}
var p1 = new Pessoa("jink", 24);
p1.say(); //Nome da saída: jink, idade: 24
var p2 = new Pessoa("Zhang San", 33);
p2.say();//Nome da saída: Zhang San, idade: 33
No exemplo acima, podemos ver claramente que this aponta para o objeto criado por meio de new e do construtor. Por que isso está acontecendo? Isso ocorre porque quando o construtor é chamado através de new em JavaScript, o operador new chama o método interno [[Construct]] da função "Person", e então, após a criação do objeto, o método interno [[Call]] é chamado. Toda a mesma função "Pessoa" define o valor deste para o objeto recém-criado.
aplicar modo de chamada
Depois que todas as funções em JavaScript forem criadas, elas terão dois métodos: apply e call. Não quero explicar em detalhes o uso específico desses dois métodos. Os alunos que não sabem podem pesquisar no Baidu. Através de dois métodos, podemos definir isso manualmente. Embora não seja permitido modificá-lo durante a criação, se o definirmos manualmente antes da criação, isso é outro assunto. Essa configuração é incrível, você pode fazer seu objeto chamar qualquer método, assim como você pode fazer um carro navegar no mar, um elefante africano acelerar como uma onça e um programador tocar como um pianista. Haha, a imaginação é sempre linda. Chamar é chamar, mas se a função pode ser realizada após a chamada é outra questão.
Copie o código do código da seguinte forma:
var programador = {
nome: "Programador",
mão: "mãos flexíveis",
programa: função(){
console.log(this.name+"Escreva o código com "+this.hand+".");
}
}
var pianista = {
nome: "pianista",
mão: "mãos flexíveis",
jogar: função(){
console.log(this.name+"Toque uma bela música com "+this.hand+".");
}
}
var jogador = {
nome: "atleta",
pé: "Pernas fortes",
execute: função(){
console.log(this.name+"Use "+this.foot+" para correr no campo.");
}
}
//Siga as regras
programer.programme(); //Programadores escrevem código com mãos flexíveis.
pianist.play(); //O pianista usa suas mãos flexíveis para tocar uma bela música.
player.run(); //Atletas correm em campo com pernas fortes.
// caprichoso
pianist.play.apply(programmer); //Os programadores usam suas mãos flexíveis para tocar belas músicas.
player.run.apply(programmer); //Programadores usam undefined para rodar em campo. Por falta de exercício físico, não tenho pernas fortes
Parece interessante ver acima. O primeiro parâmetro de apply é o ponteiro this no método de execução. Dessa forma, podemos pegar emprestado os métodos de outras pessoas e usá-los secretamente, o que é extremamente conveniente. Esse tipo de técnica é frequentemente usado em alguns frameworks.
Resumir
Isso é tudo que tenho a dizer sobre isso. Acredito que depois de ler isso, todos terão alguma compreensão da determinação disso em diferentes situações. Originalmente planejei discutir o objeto de referência a seguir e explicar o valor disso no modo de chamada de método. e princípio do modo de chamada de função, mas temia que o comprimento fosse muito longo, então decidi usar um capítulo separado para analisar o conceito de objetos de referência.