DEV Community

Cover image for This e Binding: por que o valor muda a cada chamada
Guilherme R.
Guilherme R.

Posted on Edited on

This e Binding: por que o valor muda a cada chamada

Introdução

O this é uma das partes do JavaScript que mais gera confusão, porque seu valor nem sempre é o que esperamos ao ler o código. Neste artigo, em vez de decorar uma lista de regras, vamos construir um modelo mental que explique de onde ela vem e permita deduzir o valor do this em cada situação. Para isso, vamos passar pelos seguintes tópicos essenciais para seu entendimento.

  • O que é Binding?
  • Early e Late Binding
  • O parâmetro implícito da chamada
  • As regras de Binding
  • Arrow function como exceção
  • Conclusão

O que é Binding?

Em programação, binding é a associação entre um identificador e aquilo que ele representa. Quando escrevemos const age = 30, criamos um binding: o nome age está ligado ao valor 30.

Toda variável é um binding, mas nem todo binding é uma variável. Parâmetros de função, nomes de classes e o próprio this também são bindings.

O que diferencia o this é quando e como a ligação é feita. Para uma variável comum, o valor que o identificador representa é determinado pelo lugar onde o código foi escrito (binding léxico). Já o this tem late binding: seu valor só é decidido no momento em que a função é chamada.

Early e Late Binding

O binding pode ser decidido em dois momentos diferentes, e é essa diferença que explica o comportamento do this.

No early binding, o vínculo é decidido com fatos estáticos, conhecidos pelo compilador antes do programa executar. No late binding, o vínculo é decidido com fatos dinâmicos, que só existem durante a execução. Essa formulação, em termos de fatos estáticos e dinâmicos, é usada por Eric Lippert, ex-membro do time do compilador do C# What is late binding.

Early Binding (hipotético)

Se o this do JavaScript tivesse early binding, seu valor seria vinculado pelo lugar onde a função foi escrita.

const john = {
    name: "John",
    greet() {
        console.log(`Hi, I'm ${this.name}`);
    }
};

const henry = {
    name: "Henry",
    greet: john.greet
};

henry.greet();

// Se o this tivesse early binding o resultado seria: Hi, I'm John
// Como o JS tem late binding o resultado será: Hi, I'm Henry

Enter fullscreen mode Exit fullscreen mode

Saiba que não é assim que funciona. Em funções comuns, o this tem late binding, fazendo com que seu valor seja vinculado a cada chamada, pelo ambiente de execução, de acordo com a forma como a função foi chamada. A principal exceção a essa regra são as arrow functions, que veremos adiante.

Late Binding (real)

function greet() {
    console.log(`Hi, I'm ${this.name}`)
};

const john = { name: 'John', greet };
const henry = { name: 'Henry', greet };

john.greet() // Hi, I'm John
henry.greet() // Hi, I'm Henry
Enter fullscreen mode Exit fullscreen mode

Perceba que a função greet não mudou em nada, o que mudou foi a chamada.


O parâmetro implícito da chamada

Vimos que o this tem late binding, ou seja, seu valor não é fixado onde a função foi escrita, é fixado a cada chamada, de acordo como ela foi feita, no entanto, se o valor vem da chamada, como ele chega até a função?

O próprio ECMAScript nos responde isso. O mecanismo que executa uma função é definido como [[Call]] ( thisArg, argList ), ou seja, ele recebe duas entradas: o valor do this e a lista de argumentos escritas na chamada. Com isso, fica claro que o this é entregue à função junto com os argumentos, mas sem aparecer entre eles.

Por isso, uma maneira prática de entendê-lo e deduzir seu valor é enxergá-lo como um parâmetro implícito da chamada que o JavaScript preenche sozinho de uma forma diferente conforme a maneira como a função é chamada.

No primeiro exemplo abaixo, passamos o valor de forma explícita apenas para fins de comparação:

function greetExplicit(self, greeting) {
    console.log(`${greeting}, I'm ${self.name}`);
};

const john = { name: 'John' };

greetExplicit(john, "Hi")
Enter fullscreen mode Exit fullscreen mode

Confira agora a versão com o this. Ele faz o papel do self, mas é o JavaScript quem o passa, olhando para a forma da chamada.

function greet(greeting) {
    console.log(`${greeting}, I'm ${this.name}`);
}

const john = { name: 'John', greet };

john.greet("Hi"); // Hi, I'm John
Enter fullscreen mode Exit fullscreen mode
Chamada Equivalente Valor do this
john.greet("Hi") greet(john, "Hi") john (o que vem imediatamente antes do ponto)
greet("Hi") greet(undefined, "Hi") undefined (strict) ou global
greet.call(x, "Hi") greet(x, "Hi") x escolhido por você
new greet("Hi") greet(newObject, "Hi") o novo objeto criado

O call é o caso mais revelador, pois permite definir de forma explícita o valor de um parâmetro implícito.

Importante frisar que o this não é exatamente um parâmetro, pois ele não aparece na argList, ele é um valor separado que é definido na maneira como a função é chamada e passado automaticamente pelo JavaScript.


Regras de binding

Para construir nosso modelo mental para deduzir o valor do this devemos pensar na seguinte pergunta: qual valor foi passado como thisArg nesta chamada? Através dessa pergunta podemos ter 4 possíveis respostas.

Regra 1: binding implícito (obj.method())

O this é o objeto por meio do qual o método foi acessado na hora da chamada, ou seja, o que vem antes do ponto.

Regra 2: binding padrão (funcao())

Como não há referência de propriedade, então o thisArg é undefined. O que a função enxerga como this depende do modo da função:

  • Modo estrito: o this é exatamente o que foi passado, ou seja, undefined
  • Modo não estrito: o undefined e null são trocados pelo objeto global

Regra 3: binding explícito (call, apply, bind)

Nesse caso o parâmetro que antes era implícito é preenchido em vez de deixar que o JavaScript preencha na chamada.

Regra 4: binding com new

Nas outras regras, o this vem de algo que já existe (o objeto antes do ponto, o valor definido no call, o global). Com new ninguém passa nada, a própria operação new cria um objeto novo e o entrega ao this.

function Person(name) {
    this.name = name
}

const john = new Person('John');
console.log(john.name); // John;
Enter fullscreen mode Exit fullscreen mode

Arrow function como exceção

Como vimos anteriormente, em funções comuns o JavaScript passa a cada chamada um parâmetro implícito, o thisArg. A arrow funciton é uma exceção: elas recebem esse valor, mas o ignoram. Em vez disso, procuram o this no escopo onde foram escritas, exatamente como procurariam uma variável comum. Caso não encontre na própria função, sobem pelos escopos externos até encontrar a variável. Por isso o this da arrow function é chamado de léxico, pois ele é resolvido pela posição no código e não pela forma da chamada.

Como o valor enviado pela chamada é descartado, nenhuma das regras que vimos consegue alterá-lo: call, apply, e bind não mudam o this de uma arrow function. Isso explica porque a arrow function tem um comportamento diferente do esperado como método de um objeto literal, já que as chaves { } não criam um escopo com this próprio.

Conclusão

O que fica deste artigo é a seguinte pergunta: qual valor foi passado como thisArg nesta chamada? Como this tem late binding, a resposta nunca está em onde a função foi escrita, mas na forma como ela foi chamada. Com essa pergunta em mente é possível deduzir o valor do this nas quatro regras que vimos (implícito, padrão, explícito e new). A única exceção são as arrow functions, que ignoram o thisArg e resolvem o this pelo escopo onde foram escritas.


Referências

Créditos de Imagem

Foto de Ethan Smith na Unsplash

Top comments (0)