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 men
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
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
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")
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
| 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
thisnã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
undefinedenullsã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;
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
- https://developer.mozilla.org/en-US/docs/Glossary/Binding
- https://ericlippert.com/2012/02/06/what-is-late-binding/
- https://tc39.es/ecma262/#sec-ecmascript-function-objects-call-thisargument-argumentslist
- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this
- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new
Créditos de Imagem
Foto de Ethan Smith na Unsplash
Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.