Primeiro de tudo, deve -se dizer que esse apontamento não pode ser determinado quando a função é definida. Somente quando a função é executada, isso pode apontar para quem é esse ponto. De fato, isso aponta para o objeto que o chama (existem alguns problemas nesta frase, e explicaremos por que há problemas mais tarde. Embora a maioria dos artigos na Internet diga isso, embora não haja problema em entendê -lo assim, em muitos casos, é realmente impreciso entender, então você sentirá que você não pode descobrir isso quando entende isso). Então discutirei essa questão em profundidade a seguir.
Por que aprender isso? Se você aprendeu programação funcional e programação orientada a objetos, deve saber o que fazer. Se você não aprendeu, não precisa ler este artigo por enquanto. Obviamente, se você estiver interessado, também pode lê -lo. Afinal, isso é algo que deve ser dominado em JS.
Exemplo 1:
função a () {var user = "Little j"; console.log (this.User); // console indefinido (this); // janela} a ();De acordo com o que dissemos acima, isso aponta para o objeto que o chama. A função A aqui é realmente apontada pelo objeto da janela, e o código a seguir pode provar isso.
função a () {var user = "Little j"; console.log (this.User); // console indefinido (this); } window.a () // janelaAssim como o código acima, o Alert é na verdade uma propriedade da janela e também é apontada pela janela.
Exemplo 2:
var o = {user: "perseguindo sonhos", fn: function () {console.log (this.User); // Dreams perseguindo}} o.fn ();Isso aqui aponta para o objeto O, porque você chama isso de FN e o executa através de o.fn (), de modo que o apontamento natural é o objeto o. Gostaria de enfatizar novamente aqui que esse apontamento não pode ser decidido quando a função é criada e só pode ser decidida quando é chamada. Quem o chama vai apontar para quem você deve descobrir isso.
De fato, o Exemplo 1 e o Exemplo 2 não são precisos o suficiente. O exemplo a seguir pode derrubar a teoria acima.
Se você deseja entender isso minuciosamente, deve olhar para os próximos exemplos.
Exemplo 3:
var o = {user: "Catching Dreams", fn: function () {console.log (this.User); // pegando sonhos}} window.o.fn ();Esse código é quase o mesmo que o código acima, mas por que isso aponta para a janela? Se você seguir a teoria acima, este ponto para o objeto que o chama. Deixe -me dizer algo mais aqui. O Windows é um objeto global em JS. A variável que criamos realmente adiciona atributos à janela, para que você possa usar a janela para apontar o objeto O aqui.
Não vou explicar por que esse código acima não aponta para a janela. Vejamos outro código.
var o = {a: 10, b: {a: 12, fn: function () {console.log (this.a); // 12}}} obfn ();Isso também é apontado pelo objeto O, mas isso não o executa, então você definitivamente dirá que o que eu disse no começo está errado? Na verdade, não é, é apenas impreciso no começo. Em seguida, adicionarei uma frase. Eu acredito que você pode entender completamente o problema que isso aponta.
========================================================================== >>>>
Caso 1 : Se houver isso em uma função, mas não é chamado por um objeto no nível anterior, isso aponta para a janela. O que precisa ser explicado aqui é que, na versão estrita do JS, isso aponta para a janela, mas não discutiremos o problema da versão rigorosa aqui. Se você quiser saber, pode pesquisar on -line sozinho.
========================================================================== >>>>
Caso 2 : Se houver isso em uma função e essa função é chamada por um objeto no nível anterior, isso aponta para o objeto no nível anterior.
========================================================================== >>>>
Caso 3: Se houver isso em uma função, esta função contém vários objetos. Embora essa função seja chamada pelo objeto mais externo, isso aponta apenas para o objeto no próximo nível. O Exemplo 3 pode provar que, se você não acredita, vamos continuar analisando alguns exemplos a seguir.
var o = {a: 10, b: {// a: 12, fn: function () {console.log (this.a); // indefinido}}} obfn ();Embora não haja atributo A no objeto B, isso também aponta para o objeto B, porque isso só apontará para o objeto anterior, independentemente de haver algo que isso deseje nesse objeto.
Há outro caso especial, Exemplo 4:
var o = {a: 10, b: {a: 12, fn: function () {console.log (this.a); // console indefinido (this); // janela}}} var j = obfn; j ();Isso aponta para a janela aqui, não é um pouco confuso? Na verdade, é porque você não entende uma frase, o que também é crucial.
Isso sempre aponta para o objeto que o chama por último, o que significa quem o chama quando é executado. No Exemplo 4, embora a função Fn seja referenciada pelo objeto B, ela não é executada ao atribuir FN à variável j, por isso aponta para a janela, que é diferente do Exemplo 3. O Exemplo 3 executa diretamente FN.
Na verdade, é exatamente isso, mas os apontadores serão diferentes em diferentes circunstâncias. O resumo acima é um pequeno erro em cada lugar, e não se pode dizer que seja um erro, mas a situação será diferente em ambientes diferentes, por isso não posso explicar claramente de uma só vez, para que você só possa experimentá -lo lentamente.
Versão do construtor isto:
função fn () {this.User = "small j";} var a = new fn (); console.log (a.User); // pequeno jA razão pela qual o objeto A pode apontar o usuário na função FN aqui é porque a nova palavra -chave pode alterar a direção disso e apontar isso para objeto a. Por que digo que A é um objeto? Porque usar a nova palavra -chave é criar uma instância do objeto. Compreendendo essa frase, você pode pensar no nosso Exemplo 3. Usamos a variável A para criar uma instância de FN (equivalente a copiar um FN no objeto A). No momento, ele é criado e não é executado. A chamada para esta função FN é o objeto A, então este é naturalmente objeto a. Então, por que existe um usuário no objeto fn? Porque você copiou uma função FN no objeto A e o uso da nova palavra -chave é equivalente a copiar uma cópia.
Além do exposto, também podemos alterar a direção disso por nós mesmos ========= >>> LIGUE, APLICAR, VINTE
Atualize um pequeno problema quando este encontro retornar
função fn () {this.User = 'small j'; retornar {}; } var a = novo fn; console.log (A.User); //indefinidoOlhe para outro
função fn () {this.User = 'small j'; retornar function () {};} var a = new fn; console.log (A.User); //indefinidoVenha de novo
função fn () {this.User = 'small j'; retornar 1;} var a = novo fn; console.log (A.User); // pequeno jfunction fn () {this.User = 'pequeno j'; retornar indefinido;} var a = novo fn; console.log (A.User); // pequeno jSe o valor de retorno for um objeto, isso aponta para o objeto retornado. Se o valor de retorno não for um objeto, isso ainda apontará para uma instância da função.
função fn () {this.User = 'small j'; retornar indefinido;} var a = novo fn; console.log (a); // fn {user: "small j"}Outro ponto é que, embora o NULL também seja um objeto, isso ainda aponta para uma instância dessa função aqui, porque Null é mais especial.
função fn () {this.User = 'small j'; return null;} var a = novo fn; console.log (A.User); // pequeno jSuplementos de pontos de conhecimento:
1. O padrão isso na versão estrita não é mais uma janela, mas indefinida.
2. O novo operador alterará o problema apontador da função. Embora tenhamos explicado isso acima, não discutimos essa questão em profundidade. Raramente é mencionado na Internet, por isso é necessário falar sobre isso aqui.
função fn () {this.num = 1;} var a = new fn (); console.log (a.num); // 1Por que isso aponta para um? Primeiro, a nova palavra -chave criará um objeto vazio e, em seguida, uma função Aplicar o método será chamado automaticamente para apontar isso para esse objeto vazio. Dessa forma, essa função será substituída por esse objeto vazio.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.