Explore este ponteiro de ponteiro em JavaScript

Explore este ponteiro de ponteiro em JavaScript

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 = "Dream perseguindo"; 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 = "Dream perseguindo"; console.log (this.User); // console indefinido (this); // janela} janela.a ();

Assim como o código acima, o Alert é na verdade uma propriedade da janela e também é apontado 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ê quiser 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 = "perseguindo sonhos";} var a = new fn (); console.log (a.User); // Perseguindo sonhos

A 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 mudar a direção disso por nós mesmos. Para alterar a direção disso por nós mesmos, consulte o resumo da chamada, aplicar e vincular métodos no JavaScript, que explica em detalhes como alteramos manualmente a direção disso.

Atualize um pequeno problema quando este encontro retornar

 function fn () {this.User = 'Dream Chaser'; retornar {}; } var a = novo fn; console.log (A.User); //indefinido

Olhe para outro

 function fn () {this.User = 'Dream Chaser'; retornar function () {};} var a = new fn; console.log (A.User); //indefinido

Venha de novo

 function fn () {this.User = 'Catching Dreams'; retornar 1;} var a = novo fn; console.log (A.User); // Catching Dreams 'function fn () {this.User =' Catching Dreams '; retornar indefinido;} var a = novo fn; console.log (A.User); // pegando sonhos '

O que isso significa?

Se 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.

 function fn () {this.User = 'cutves'; retornar indefinido;} var a = novo fn; console.log (a); // fn {user: "cough '}

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.

 function fn () {this.User = 'Zhunting Dreams'; return null;} var a = novo fn; console.log (A.User); // sonhos zhunting

Suplementos 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); // 1

Por 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.