0Pricing
TypeScript Academy · Aula

Pontos problemáticos do JavaScript: erros em tempo de execução

Explore erros comuns de JavaScript que só aparecem em tempo de execução.

Pontos problemáticos do JavaScript: erros em tempo de execução é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 de 4. 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 TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Boas-vindas

Nesta lição, exploramos os erros em tempo de execução que motivaram a criação do TypeScript. O JavaScript é flexível, mas essa flexibilidade pode causar erros difíceis de encontrar.

O erro silencioso de coerção de tipos

O JavaScript faz a coerção de tipos silenciosamente. Somar um número a uma cadeia de caracteres retorna uma cadeia de caracteres, não um erro. Isso causa um comportamento inesperado em tempo de execução.
// JavaScript
let total = 5 + '10'; // '510' not 15
console.log(total);   // '510'

Acessando propriedades indefinidas

O JavaScript permite acessar propriedades inexistentes em objetos. O resultado é `undefined`, em vez de um erro, e isso costuma se propagar silenciosamente.
const user = { name: 'Alice' };
console.log(user.age); // undefined — no error thrown

Chamando valores que não são funções

Se uma variável contiver um valor que não é uma função e você a chamar, o JavaScript lançará um TypeError somente em tempo de execução, não durante o desenvolvimento.
const greet = 'hello';
greet(); // TypeError: greet is not a function

Erros de digitação em nomes de propriedades

Um erro de digitação no nome de uma propriedade retorna `undefined` sem nenhum aviso. É difícil detectar esses erros em bases de código grandes.
const config = { timeout: 3000 };
console.log(config.tiemout); // undefined — typo goes unnoticed

Tipos de argumentos incorretos

As funções do JavaScript aceitam qualquer argumento. Passar um tipo incorreto produz resultados inesperados, em vez de um erro claro.
function double(n) { return n * 2; }
console.log(double('5')); // 10 — but '5' * 2 uses coercion

Falhas por desreferência de valores nulos

Uma das falhas mais comuns em tempo de execução ocorre ao acessar uma propriedade de um valor nulo ou indefinido. As verificações estritas de nulos do TypeScript impedem esse tipo de erro.
let element = document.querySelector('.missing');
console.log(element.textContent); // TypeError: Cannot read properties of null

O problema da refatoração

Ao renomear uma função ou propriedade em JavaScript puro, não há nenhuma ferramenta que encontre todas as utilizações de forma confiável. O sistema de tipos do TypeScript permite fazer refatorações seguras em bases de código grandes.

Erros em tempo de execução versus erros em tempo de compilação

Os erros do JavaScript aparecem em tempo de execução, muitas vezes em produção. O TypeScript detecta muitos desses erros em tempo de compilação, antes mesmo que seu código seja executado.

O suporte da IDE piora sem tipos

Sem informações de tipos, sua IDE não consegue oferecer com confiabilidade preenchimento automático, navegação até a definição ou refatoração de renomeação. Os tipos tornam as ferramentas muito melhores.

A escala revela o problema

Scripts pequenos funcionam bem em JavaScript. Mas, à medida que os projetos crescem para milhares de arquivos e muitos colaboradores, a falta de tipos se torna uma fonte importante de erros e de sobrecarga de manutenção.

Verificação rápida

Qual comportamento do JavaScript a verificação estrita de nulos do TypeScript ajuda a evitar?

Recapitulação

A flexibilidade do JavaScript — coerção de tipos, propriedades indefinidas e ausência de verificações de argumentos — causa erros silenciosos que só aparecem em tempo de execução. O TypeScript foi criado para detectar esses erros antes que o código seja executado.

Perguntas Frequentes

A aula “Pontos problemáticos do JavaScript: erros em tempo de execução” é grátis?

Sim — o texto completo de “Pontos problemáticos do JavaScript: erros em tempo de execução” é 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 TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “Pontos problemáticos do JavaScript: erros em tempo de execução”?

Explore erros comuns de JavaScript que só aparecem em tempo de execução. Você pratica TypeScript 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 TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript 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 4.

Quanto tempo leva a aula “Pontos problemáticos do JavaScript: erros em tempo de execução”?

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 TypeScript Academy?

Sim. Cada aula de TypeScript 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

  1. Pontos problemáticos do JavaScript: erros em tempo de execução
  2. O que TypeScript adiciona ao JavaScript
  3. Compilação de TypeScript para JavaScript
  4. Quando usar TypeScript em seus projetos
← Voltar para TypeScript Academy