---
title: "Apagamento de tipos: o que chega ao motor"
url: "https://www.mikefluff.com/pt/experiments/js-ch04-type-erasure"
locale: "pt"
author: "Mikhail Savchenko (Mike Fluff)"
updated: "2026-11-18"
description: "Apagamento de tipos no TypeScript"
book: "https://www.mikefluff.com/pt/books/from-closures-to-autonomous-systems"
alternates:
  - locale: "en"
    url: "https://www.mikefluff.com/en/experiments/js-ch04-type-erasure"
    markdown: "https://www.mikefluff.com/en/experiments/js-ch04-type-erasure.md"
  - locale: "ru"
    url: "https://www.mikefluff.com/ru/experiments/js-ch04-type-erasure"
    markdown: "https://www.mikefluff.com/ru/experiments/js-ch04-type-erasure.md"
  - locale: "pt"
    url: "https://www.mikefluff.com/pt/experiments/js-ch04-type-erasure"
    markdown: "https://www.mikefluff.com/pt/experiments/js-ch04-type-erasure.md"
  - locale: "es"
    url: "https://www.mikefluff.com/es/experiments/js-ch04-type-erasure"
    markdown: "https://www.mikefluff.com/es/experiments/js-ch04-type-erasure.md"
---

# Apagamento de tipos: o que chega ao motor

*Apagamento de tipos no TypeScript*

## O que é o apagamento de tipos no TypeScript?

Apagamento de tipos quer dizer que os tipos do TypeScript só existem enquanto o programa é verificado e são removidos antes da execução. O compilador, ou a remoção de tipos embutida no Node, apaga interfaces e anotações e deixa JavaScript comum, então durante a execução ninguém sabe que uma variável foi declarada como número. O TypeScript verifica o texto do programa, não os valores que chegam: o resultado de JSON.parse tem o tipo any e pode receber qualquer tipo declarado sem verificação. Por isso valores de fora precisam ser conferidos por código que roda, por exemplo um parser escrito com uma biblioteca como o zod.

Desde a versão 23, o Node executa arquivos TypeScript sem compilar: corta as declarações de tipo e roda o que sobra. O point.ts do livro declara uma interface Point com x e y numéricos, uma função norm que devolve Math.hypot(p.x, p.y) e um objeto lido do JSON {"x": "3", "y": null}. O Node 24 imprime 3 string. O programa declarou que x é número e recebeu uma string, Math.hypot converteu a string em 3 e o null em 0 sem dizer nada, e ninguém percebeu.

Na primeira aba, o point.ts fica ao lado do texto que o Node executa de fato: as mesmas linhas, com espaços no lugar dos tipos, para que cada posição do arquivo continue onde estava. Edite o JSON “da rede” ou escolha outro e aperte Executar. O texto sem tipos roda no motor do seu navegador com um JSON.parse de verdade, e uma tabela mostra o que Point declarou, o que chegou e no que Math.hypot transformou isso. A segunda aba é o cov.ts: um array de gatos passado onde se espera um array de animais, um cachorro colocado nele e meow chamado no primeiro gato. Percorra linha por linha; a última quebra com a mensagem que o seu motor escreve.

No livro, o Node 24.16.0 executa arquivos .ts diretamente, com a remoção de tipos ligada por padrão desde as versões 23.6 e 22.18 e sem verificação de tipos. O point.ts imprime 3 string. O cov.ts passa no tsc --strict do TypeScript 5.6.3 sem erros, e node cov.ts quebra com TypeError: cats[0].meow is not a function.

A conclusão do capítulo é que três partes verificam tipos em JavaScript e nenhuma responde por tudo. O TypeScript lê o texto antes da execução e deixa passar de propósito o que seria incômodo demais proibir. O motor vê cada valor, mas se importa com velocidade, não com correção. O que vem de fora fica a cargo do parsing na entrada, que só funciona onde o programador o colocou.

_A página tem um experimento interativo que roda no navegador: https://www.mikefluff.com/pt/experiments/js-ch04-type-erasure_

## Fontes

- [Node.js documentation, Modules: TypeScript](https://nodejs.org/api/typescript.html)
- [TypeScript Design Goals (TypeScript wiki)](https://github.com/microsoft/TypeScript/wiki/TypeScript-Design-Goals)
- [Alexis King, Parse, don’t validate (2019)](https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/)

## Do livro

Ao lado dele no livro:

> O TypeScript define a compatibilidade de tipos pela estrutura do objeto. Qualquer objeto com x e y numéricos serve à descrição de Point, venha de onde vier, e para uma linguagem em que objetos são moldados com chaves e alterados em movimento isso é muito cômodo. O V8 também pensa na estrutura dos objetos, só que à sua maneira: suas formas são as classes ocultas do primeiro capítulo, a ordem dos campos e a forma como ficam na memória. Os dois sistemas descrevem a mesma coisa por lados diferentes e nunca se encontram. Tudo o que o TypeScript descobriu sobre as formas dos objetos é cortado antes de o código chegar ao motor, e o V8 descobre de novo o que o compilador do TypeScript sabia um segundo antes.

- Ler o capítulo: [Capítulo 4. Tipos verificados depois](https://www.mikefluff.com/pt/read/from-closures-to-autonomous-systems/ch04) (início livre, o resto no livro completo; Markdown: https://www.mikefluff.com/pt/read/from-closures-to-autonomous-systems/ch04.md)

- Livro: [JavaScript: das closures aos sistemas autônomos](https://www.mikefluff.com/pt/books/from-closures-to-autonomous-systems)
