this léxico versus dinâmico; revendo as arrow functions
Veja como o this dinâmico depende do local da chamada e como as funções de seta capturam o this léxico; use exemplos pequenos e claros
this léxico versus dinâmico; revendo as arrow functions é uma aula grátis de JavaScript Academy no CoddyKit. Esta é a aula 1 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de JavaScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de JavaScript Academy inclui 3 aulas no total.
Visão geral
Objetivo: saber para onde this aponta em cada situação.
- this dinâmico: definido pelo local da chamada
- this de uma função de seta: capturado lexicamente
- Armadilha comum: extrair um método faz this ser perdido
- Use funções de seta para manter this dentro das funções de retorno de chamada

Demonstração de this dinâmico
this dinâmico: chamar como obj.method() define this = obj; extrair a função faz o objeto ser perdido.
// Dynamic this depends on HOW we call the function
const person = {
name: "Ayla",
say: function () {
return "Hi " + this.name;
}
};
console.log("method call:", person.say()); // "Hi Ayla"
// Extract then call: this is lost
const talk = person.say;
console.log("extracted call:", talk()); // likely "Hi undefined" in strict mode -> this is undefined

Função de seta = this léxico
Uma função de seta obtém this do escopo da função ou do objeto ao redor quando é criada; seu valor não muda no momento da chamada.
// Arrow functions capture this from where they are created
const box = {
label: "blue",
showLater: function () {
// Arrow keeps this === box
const fn = () => "box:" + this.label;
return fn();
}
};
console.log("arrow captured this:", box.showLater()); // "box:blue"

Funções de retorno de chamada: mantenha this com funções de seta
Nas funções de retorno de chamada, uma função normal geralmente perde this; uma função de seta mantém o this externo intacto.
// Using a normal function in a callback can lose this
const widget = {
id: 7,
normal: function () {
setTimeout(function () {
// here this is not widget in many environments
console.log("normal cb this.id:", this && this.id);
}, 0);
},
arrow: function () {
setTimeout(() => {
// arrow keeps lexical this from arrow()
console.log("arrow cb this.id:", this.id);
}, 0);
}
};
widget.normal();
widget.arrow();

Correção simples para a extração
Se um método for extraído, envolva-o em uma pequena função de seta que capture o objeto ou vincule-o (na próxima lição). Mantenha tudo simples para iniciantes.
// If you must extract, wrap with an arrow capturing the object
const account = {
owner: "Mila",
label: function () { return "Owner:" + this.owner; }
};
// Lost this:
const lost = account.label;
console.log("lost:", lost()); // "Owner:undefined" (this missing)
// Fixed: create an arrow that closes over account
const safe = () => account.label();
console.log("fixed via arrow wrapper:", safe());

Boas práticas
Dicas:
- Métodos: chame com obj.method() para que this seja o objeto.
- Funções de retorno de chamada: prefira funções de seta para manter o this léxico.
- Métodos extraídos perdem this; envolva-os em uma função de seta ou use bind.

Questionário sobre this em funções de seta
Verificação rápida: comportamento de this em funções de seta.

Recapitulação
Recapitulação: this é dinâmico em funções normais (definido pelo local da chamada) e léxico em funções de seta (capturado no local de criação). Use funções de seta nas funções de retorno de chamada e envolva métodos extraídos para manter o comportamento simples.

Perguntas Frequentes
A aula “this léxico versus dinâmico; revendo as arrow functions” é grátis?
Sim — o texto completo de “this léxico versus dinâmico; revendo as arrow functions” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de JavaScript Academy, atualize para CoddyKit PRO. O curso de JavaScript Academy inclui 3 aulas no total.
O que vou aprender em “this léxico versus dinâmico; revendo as arrow functions”?
Veja como o this dinâmico depende do local da chamada e como as funções de seta capturam o this léxico; use exemplos pequenos e claros Você pratica JavaScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar JavaScript Academy?
Nenhuma experiência prévia é necessária. JavaScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 3.
Quanto tempo leva a aula “this léxico versus dinâmico; revendo as arrow functions”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de JavaScript Academy?
Sim. Cada aula de JavaScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- this léxico versus dinâmico; revendo as arrow functions
- Armadilhas da extração de métodos e aplicação parcial
- Alternativas funcionais — passar contexto, closures e pequenos auxiliares