0Pricing
Frontend Academy · Aula

Modo estrito e eliminação de any

Ativar todas as opções estritas em tsconfig, utilizar unknown em vez de any, aplicar asserções de tipo com segurança e migrar um ficheiro com tipagem fraca para o modo estrito.

Modo estrito e eliminação de any é uma aula grátis de Frontend Academy no CoddyKit. Esta é a aula 4 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 Frontend Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Frontend Academy inclui 4 aulas no total.

Por que usar o modo estrito

strict: true em tsconfig.json ativa todos os sinalizadores de segurança do TypeScript — o padrão para projetos sérios. Ele detecta bugs de nulos, parâmetros sem tipo e atribuições inseguras em tempo de compilação.

O que o modo estrito habilita

O modo estrito é uma metaopção que habilita: noImplicitAny, strictNullChecks, strictFunctionTypes, strictBindCallApply, strictPropertyInitialization, alwaysStrict, noImplicitThis, useUnknownInCatchVariables.

strictNullChecks

Sem essa opção, null e undefined podem ser atribuídos a qualquer tipo — uma fonte constante de bugs. Com ela, é necessário tratar explicitamente os casos de null.

// Without strictNullChecks — runtime error:
function greet(name: string) { return name.toUpperCase(); }
greet(null); // compiler allows, crashes at runtime

// With strictNullChecks:
function greet(name: string | null) {
  if (name == null) return '';
  return name.toUpperCase();
}

noImplicitAny

Sem esse sinalizador, parâmetros sem anotação de tipo assumem any por padrão, contornando silenciosamente o sistema de tipos. Com noImplicitAny, é necessário fazer uma anotação neles.

// Without noImplicitAny:
function format(value) { return value.toUpperCase(); } // value: any

// With:
function format(value: string) { return value.toUpperCase(); }

strictPropertyInitialization

As propriedades de classes sem um inicializador definido passam a ser possivelmente undefined. Inicialize-as ou use o operador de atribuição definitiva !.

class User {
  name!: string;     // tell TS: I'll set this elsewhere
  age = 0;           // default initialiser
  email: string;     // ERROR with strictPropertyInitialization
  constructor(email: string) { this.email = email; } // FIX: init in ctor
}

Use unknown em vez de any

any desativa a verificação de tipos. unknown é seguro quanto aos tipos — é necessário restringi-lo antes de usá-lo. Prefira sempre unknown.

// any — no checks, bug magnet:
function parse(input: any) {
  return input.toUpperCase(); // compiler is fine, runtime may crash
}

// unknown — must narrow:
function parse(input: unknown) {
  if (typeof input === 'string') {
    return input.toUpperCase();
  }
  throw new Error('Expected string');
}

Faça asserções de tipo com segurança

Se for necessário fazer uma asserção (por saber mais do que TS), prefira a sintaxe as. Não faça asserções duplas (x as unknown as T) a menos que realmente não haja alternativa — isso é um sinal de código problemático.

const el = document.getElementById('app') as HTMLDivElement;
el.style.background = 'blue';

// Safer alternative: runtime check
const el = document.getElementById('app');
if (!(el instanceof HTMLDivElement)) throw new Error('app missing');
el.style.background = 'blue'; // narrowed to HTMLDivElement

Eliminando any de um projeto

Estratégia: ative o modo estrito e corrija os erros resultantes, um arquivo por vez. Use unknown e faça uma restrição de tipo. Adicione @ts-expect-error com um comentário TODO para pontos conhecidos como problemáticos, assim eles não poderão ser ignorados.

Regra de lint: no-explicit-any

Adicione @typescript-eslint/no-explicit-any à configuração do ESLint para impedir que novos usos de any sejam adicionados.

// .eslintrc.json
{
  "rules": {
    "@typescript-eslint/no-explicit-any": "error"
  }
}

strictFunctionTypes

Impõe a verificação contravariante dos parâmetros de função — evita atribuir funções com tipos de parâmetros mais abrangentes do que o esperado, o que causaria uma falha em tempo de execução.

Tipo da variável de captura

useUnknownInCatchVariables faz com que catch (e) infira e: unknown em vez de any. É necessário restringir o tipo antes de acessar propriedades.

try {
  doRisky();
} catch (e) {
  // e is unknown
  if (e instanceof Error) {
    console.error(e.message);
  } else {
    console.error('Unknown error', e);
  }
}

Dicas de migração

Ative o modo estrito em projetos novos desde o primeiro dia. Para projetos legados, habilite os sinalizadores de forma incremental. Comece com strictNullChecks (o maior benefício), depois use noImplicitAny. Use //@ts-expect-error em vez de //@ts-ignore, para que o comentário seja removido quando o problema for corrigido.

Verificação rápida

Por que unknown é mais seguro que any quando você não conhece o tipo de um valor?

Recapitulação: modo estrito

Ative strict: true para obter segurança completa. strictNullChecks exige o tratamento de nulos. noImplicitAny exige anotações nos parâmetros. Use strictPropertyInitialization para campos de classes. Prefira unknown a any — restrinja o tipo com guardas de tipo. Evite asserções duplas. Use no-explicit-any no lint. Migre o código legado, um arquivo por vez, usando marcadores @ts-expect-error.

Perguntas Frequentes

A aula “Modo estrito e eliminação de any” é grátis?

Sim — o texto completo de “Modo estrito e eliminação de any” é 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 Frontend Academy, atualize para CoddyKit PRO. O curso de Frontend Academy inclui 4 aulas no total.

O que vou aprender em “Modo estrito e eliminação de any”?

Ativar todas as opções estritas em tsconfig, utilizar unknown em vez de any, aplicar asserções de tipo com segurança e migrar um ficheiro com tipagem fraca para o modo estrito. Você pratica Frontend 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 Frontend Academy?

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

Quanto tempo leva a aula “Modo estrito e eliminação de any”?

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

Sim. Cada aula de Frontend 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 de literais de modelo
  2. Decoradores e metadados
  3. TypeScript com React: genéricos, FC e hooks
  4. Modo estrito e eliminação de any
← Voltar para Frontend Academy