Dev.to WebDev 🛠 Dev 👁 0 📖 6 min read

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 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;

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

📰 Read the original article on Dev.to WebDev

Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.