O JavaScript é uma linguagem de script que suporta funções avançadas, como programação funcional, fechamentos, herança baseada em protótipo, etc. O JavaScript parece ser fácil de começar no início, mas, como você o usa em profundidade, é realmente difícil dominar o Javscript e alguns conceitos básicos são incríveis. Entre eles, a palavra -chave isso no JavaScript é um conceito relativamente confuso. Em diferentes cenários, isso se tornará objetos diferentes. Há uma visão que apenas dominando corretamente essa palavra -chave no JavaScript, você pode inserir o limite do idioma JavaScript. Nos idiomas orientados a objetos principais (como Java, C#, etc.), isso significa claro e específico, isto é, apontando para o objeto atual. Geralmente ligado durante o período de compilação. Isso está ligado durante o tempo de execução no JavaScript, que é a razão essencial pela qual essa palavra -chave tem vários significados no JavaScript.
Devido ao seu recurso de ligação durante o tempo de execução, este no JavaScript pode ser um objeto global, um objeto atual ou qualquer objeto, que depende inteiramente da maneira como a função é chamada. Existem várias maneiras de chamar funções no JavaScript:
Chamado como método de objeto;
como uma chamada de função;
Chamado como construtor;
Use aplicar ou ligar para ligar.
Como diz o ditado, um personagem não é tão bom quanto uma forma, e uma forma não é tão boa quanto uma imagem. Para fazer as pessoas entender melhor o que JavaScript isso aponta? Aqui está uma imagem para explicar:
Na figura acima, eu chamo de "JavaScript nesta árvore de decisão" (no modo não rito). A seguir, é apresentado um exemplo para ilustrar como esse número pode nos ajudar a julgar isso:
var point = {x: 0, y: 0, moveto: function (x, y) {this.x = this.x + x; this.y = this.y + y; }}; // Explicação da árvore de decisão: a função Point.moveto (1,1) não é solicitada a nova, entra no veto, // é chamado com ponto (.) E depois aponta para o objeto de chamada antes .moveto, isto é, ponto de ponto.moveto (1,1); // Isso está ligado ao objeto atual, ou seja, objeto de pontoO ponto de função Point.Moveto é chamado com o novo? Isso obviamente não é. Indo para o ramo "não", isto é, a função é chamada com DOT (.)? ;
A função Point.Moveto é chamada com DOT (.), Ou seja, ele entra no ramo "sim", ou seja, isso aqui aponta para o ponto de objeto antes do ponto.moveto.
O diagrama de análise do que esse ponto no ponto da figura.Moveto a função é mostrada na figura a seguir:
Vamos dar outro exemplo, veja o seguinte código:
função func (x) {this.x = x; } func (5); // Esta é uma janela de objeto global, x é uma variável global // Análise de árvore de decisão: a função func () é chamada com nova? Para não, é chamado com o DOT ao inserir a função func ()? Para não, isso aponta para o objeto global Windowx; // x => 5O processo de determinação da função func () em "JavaScript nesta árvore de decisão" é a seguinte:
Func (5) a chamada de função é chamada com novo? Isso obviamente não é. Indo para o ramo "não", isto é, a função é chamada com DOT (.)? ;
A função Func (5) não é chamada com DOT (.), Ou seja, entra no ramo "não", ou seja, este ponto para a janela variável global, então isso.x é na verdade janela.x.
O diagrama de análise do que essa função FUNC aponta é mostrado na figura a seguir:
Para o método de chamar diretamente em função, vamos ver um exemplo complexo:
var point = {x: 0, y: 0, moveto: function (x, y) {// função interna var mOvex = function (x) {this.x = x; // O que isso aponta? janela }; // a função interna var movey = function (y) {this.y = y; // O que isso aponta? janela }; movex (x); movey (y); }}; Point.moveto (1,1); Point.x; // => 0 Point.Y; // => 0 x; // => 1 y; // => 1A chamada interna real das funções movex () e movey (). O processo de determinar isso dentro da função movex () no "JavaScript nesta árvore de decisão" é o seguinte:
A chamada de função movex (1) é chamada com novo? Isso obviamente não é. Indo para o ramo "não", isto é, a função é chamada com DOT (.)? ;
A função Movex (1) não é chamada com DOT (.), Ou seja, entra na ramificação "não", ou seja, isso aqui aponta para a janela variável global, então esta.x é na verdade janela.x.
Vamos dar uma olhada no exemplo de uma chamada de construtor:
ponto de função (x, y) {this.x = x; // esse ? this.y = y; // isso?} var np = novo ponto (1,1); np.x; // 1var p = ponto (2,2); px; // erro, p é um objeto vazio undefinedwindow.x; // 2O processo de determinar isso na função "Javascript nesta árvore de decisão" na função (1,1) é a seguinte:
var np = novo é o ponto (1,1) chamado chamado com novo? Obviamente, isso está entrando no ramo "sim", ou seja, isso aponta para o NP;
Então this.x = 1, ou seja, np.x = 1;
O processo de determinar isso no "JavaScript nesta árvore de decisão" da função (2,2) em var p = ponto (2,2) é o seguinte:
A chamada var p = Point (2,2) é chamada com a nova? Isso obviamente não é. Indo para o ramo "não", isto é, a função é chamada com DOT (.)? ;
A função de ponto (2,2) não é chamada com ponto (.)? Determinado como não, ou seja, digite o ramo "não", ou seja, isso aqui aponta para a janela variável global, então isso.x é na verdade janela.x;
This.x = 2 significa janela.x = 2.
Por fim, vamos dar uma olhada no exemplo de chamar funções com chamada e aplicar:
ponto de função (x, y) {this.x = x; this.y = y; this.moveto = function (x, y) {this.x = x; this.y = y; }} var p1 = novo ponto (0, 0); var p2 = {x: 0, y: 0}; p1.moveto.apply (p2, [10, 10]); // aplicar é na verdade p2.moveto (10, 10) p2.x // 10O processo de determinação da função p1.moveto.apply (p2, [10,10]) no "Javascript nesta árvore de decisão" é o seguinte:
Sabemos que os dois métodos se aplicam e chamam são extremamente poderosos e permitem alternar o contexto da execução da função, ou seja, o objeto ligado a isso. p1.moveto.apply (p2, [10,10]) é na verdade p2.moveto (10,10). Em seguida, p2.moveto (10,10) pode ser interpretado como:
A chamada de função é chamada com novo? Isso obviamente não é. Indo para o ramo "não", isto é, a função é chamada com DOT (.)? ;
A função P2.Moveto (10,10) é chamada com DOT (.), Isto é, entra no ramo "Sim", ou seja, isso aqui aponta para o objeto P2 em P2.Moveto (10,10). Antes, então p2.x = 10.
Em relação ao processo do ambiente de execução de funções JavaScript, uma descrição na Biblioteca de documentos do IBM DeveloperWorks se sente muito boa, e o trecho é o seguinte:
"As funções no JavaScript podem ser executadas como funções comuns ou como objetos, que é a principal razão pela qual isso é tão rico. Quando uma função é executada, um ambiente de execução (executionContext) é criado, e todos os comportamentos da função ocorrem nesse ambiente de execução. A cadeia de escopo inicializa a variável, primeiro a tabela de parâmetro formal da função, o valor correspondente na variável de argumentos. Undefinido e sua operação de atribuição será executada apenas quando a função é executada após o ambiente de execução (ExecutionContext) é criado com sucesso. O ambiente da função (ExecutionContext) é criado com sucesso e a função começa a executar linha por linha, e as variáveis necessárias são lidas no ambiente de execução (ExecutionContext) que foi construído antes.
Compreender essa passagem será de grande benefício para entender as funções JavaScript.