TypeScript Academy · Aula

O tipo any e por que evitá-lo

Entenda o tipo any e quando ele frustra o propósito do TypeScript.

Aula 2 de 413 etapas

O tipo any e por que evitá-lo é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 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

O tipo `any` é a saída de emergência do TypeScript: ele desativa toda a verificação de tipos de uma variável. Nesta lição, você entenderá quando ele aparece e por que deve minimizar seu uso.

O que any faz

Uma variável tipada como `any` pode conter qualquer valor e aceita qualquer operação. O TypeScript deixa de verificá-la completamente.
let x: any = 5;
x = 'hello';       // OK
x = true;          // OK
x.nonExistent();   // No error — but crashes at runtime!

Como any se espalha

Atribuir uma variável `any` a uma variável tipada contamina a variável tipada. `any` se espalha silenciosamente pelo seu código.
let data: any = fetchData();
let name: string = data.name; // name is now effectively any

Quando o TypeScript infere any

Se você declarar uma variável sem valor inicial e sem anotação de tipo, o TypeScript infere `any`. Ative `noImplicitAny` para transformar isso em um erro de compilação.
let value; // inferred as any — dangerous!
value = 42;
value = 'hello';

// Fix:
let value2: number;

A sinalização noImplicitAny

A opção do compilador `noImplicitAny` (ativada por `strict`) obriga você a anotar os tipos, em vez de usar `any` como alternativa padrão.
// tsconfig.json
{ "compilerOptions": { "noImplicitAny": true } }

// Now this is an error:
function process(data) { } // Error: Parameter has implicit any type

Usos legítimos de any

Às vezes, `any` é inevitável: durante a migração de JavaScript, ao lidar com bibliotecas de terceiros sem tipos ou ao trabalhar com dados realmente dinâmicos. Use-o com moderação e de forma localizada.
// Acceptable: narrow scope, clearly documented
function parseJson(raw: string): any {
  return JSON.parse(raw); // validate with Zod afterwards
}

Asserções de tipo como alternativa

Em vez de `any`, use asserções de tipo (`as Type`) quando você souber mais do que o compilador. Isso é mais seguro porque você se compromete com um tipo específico.
const raw = JSON.parse(text) as { name: string; age: number };
console.log(raw.name); // typed correctly

any versus object

O tipo `object` aceita qualquer valor não primitivo, mas não permite o acesso arbitrário a propriedades, ao contrário de `any`. Ele oferece uma pequena camada de segurança.
let o: object = { x: 1 };
// o.x; // Error — object doesn't allow property access

let a: any = { x: 1 };
a.x; // OK — but no safety

any desativa o preenchimento automático

Além de reduzir a segurança, usar `any` desativa o preenchimento automático e a navegação do ambiente de desenvolvimento integrado. Você perde todos os benefícios das ferramentas fornecidas pelo TypeScript.

Substituindo any por unknown

Para dados externos que você não controla, prefira `unknown`. Ele obriga você a refinar o tipo antes de usá-lo, ao contrário de `any`, que permite fazer qualquer coisa.
let input: unknown = getInput();
// input.toUpperCase(); // Error — must narrow first
if (typeof input === 'string') {
  console.log(input.toUpperCase()); // OK
}

O custo de any

Pense em `any` como uma dívida. Cada uso torna seu código menos seguro. Procure não ter nenhum tipo `any` no código de produção. Use a regra @typescript-eslint/no-explicit-any do ESLint.

Verificação rápida

Qual opção do compilador faz o TypeScript relatar um erro quando uma variável tem o tipo `any` implícito?

Recapitulação

O tipo `any` desativa a verificação de tipos do TypeScript e se espalha pelo código. Ative noImplicitAny, substitua `any` por `unknown` para dados externos e use asserções de tipo em casos específicos.
Grátis para começar

Aprenda TypeScript com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
101
Aulas
352

Perguntas Frequentes

A aula “O tipo any e por que evitá-lo” é grátis?

Sim — o texto completo de “O tipo any e por que evitá-lo” é 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 “O tipo any e por que evitá-lo”?

Entenda o tipo any e quando ele frustra o propósito do TypeScript. 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 2 de 4.

Quanto tempo leva a aula “O tipo any e por que evitá-lo”?

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. Tipos primitivos: string, number, boolean
  2. O tipo any e por que evitá-lo
  3. unknown versus any: a escolha mais segura
  4. null, undefined e verificações estritas de null
← Voltar para TypeScript Academy