0Pricing
TypeScript Academy · Aula

null, undefined e verificações estritas de null

Trate null e undefined com segurança usando o modo estrito.

null, undefined e verificações estritas de null é uma aula grátis de TypeScript 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 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

No JavaScript, null e undefined são fontes comuns de erros durante a execução. As verificações estritas de nulos do TypeScript obrigam você a tratá-los explicitamente.

null versus undefined

`undefined` significa que uma variável foi declarada, mas não recebeu um valor. `null` indica uma ausência intencional de valor. Ambos são tipos separados no TypeScript.
let a: undefined = undefined;
let b: null = null;

Sem verificações estritas de nulos

Sem `strictNullChecks`, null e undefined são subtipos de todos os tipos. Esse é o padrão em versões mais antigas do TypeScript e, em geral, não é seguro.
// strictNullChecks: false (unsafe default)
let name: string = null; // allowed — dangerous!

Ativando as verificações estritas de nulos

Com `strictNullChecks: true` (incluído em `strict`), null e undefined só podem ser atribuídos aos próprios tipos ou a tipos união explícitos.
// strictNullChecks: true
let name: string = null; // Error!
let maybeName: string | null = null; // OK

Propriedades opcionais

As propriedades de objetos marcadas com `?` são implicitamente do tipo `T | undefined`. Você precisa tratar o caso em que elas estão ausentes.
interface Config {
  host: string;
  port?: number; // number | undefined
}

const c: Config = { host: 'localhost' };
console.log(c.port?.toString()); // optional chaining

Refinando tipos anuláveis

Use uma verificação com if para refinar uma união com null ou undefined antes de acessar propriedades.
function greet(name: string | null): string {
  if (name === null) return 'Guest';
  return 'Hello, ' + name;
}

Encadeamento opcional (?.)

O operador `?.` retorna `undefined` imediatamente se o lado esquerdo for null ou undefined, evitando uma falha durante a execução.
const user = getUser();
const city = user?.address?.city; // undefined if any step is null

Coalescência de nulos (??)

O operador `??` retorna o lado direito somente quando o lado esquerdo é null ou undefined — ao contrário de `||`, que é acionado por qualquer valor falso.
const port = config.port ?? 3000; // 3000 if port is null/undefined
const label = name ?? 'Anonymous';

Operador de asserção não nula (!)

O operador pós-fixado `!` informa ao TypeScript que você tem certeza de que um valor não é null nem undefined. Use-o somente quando tiver certeza absoluta.
const el = document.getElementById('root')!;
el.textContent = 'Loaded'; // no null check needed

Retornando null versus undefined

Prefira retornar `null` para indicar um resultado vazio intencional e `undefined` para valores ausentes ou opcionais. Mantenha a consistência em todo o código.
function findUser(id: number): User | null {
  return db.find(u => u.id === id) ?? null;
}

strictNullChecks evita o erro de bilhões de dólares

Tony Hoare chamou null de seu “erro de bilhões de dólares”. strictNullChecks do TypeScript evita falhas causadas por null e undefined ao obrigar você a tratar esses valores explicitamente.

Verificação rápida

O que o operador `??` (coalescência de nulos) retorna no lado direito?

Recapitulação

Ative strictNullChecks para evitar erros causados por null e undefined. Use tipos união para permitir valores anuláveis, encadeamento opcional (?.) para percorrer valores com segurança e coalescência de nulos (??) para fornecer valores padrão.

Perguntas Frequentes

A aula “null, undefined e verificações estritas de null” é grátis?

Sim — o texto completo de “null, undefined e verificações estritas de null” é 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 “null, undefined e verificações estritas de null”?

Trate null e undefined com segurança usando o modo estrito. 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 4 de 4.

Quanto tempo leva a aula “null, undefined e verificações estritas de null”?

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