Como verificar se um valor é nulo em JavaScript

Neste artigo você vai aprender a como verificar um valor é nulo em JS, de uma maneira super simples e que vai resolver seu problema

Fala programador(a), beleza? Bora aprender mais sobre tipos de dados, validações e também JavaScript!

Para verificar se um valor é nulo, podemos comparar com null, utilizando o operador ===

Que verifica tipo e também valor, ou seja, só teremos true para essa comparação se o valor for null mesmo

Uma string vazia, seria validada como false, então tome cuidado com isso

Veja um exemplo:

if(x === null) {
	console.log("X é null!");
}

Em muitos casos, queremos apenas checar se uma string é vazia e acabamos confundindo com o tipo de dado null

Para este caso você pode utilizar:

if(!x) {
	console.log("X é vazio!");
}

Essa validação vai ser true caso o dado seja vazio, e consequentemente também retorna true para os nulls

Então acaba sendo a mais utilizada para estas verificações

Faça sua decisão e utilize a abordagem que é melhor para a situação que você precisa resolver!

Formação Recomendada

Formação Claude Code

Domine Claude Code do absoluto zero até o avançado

• 120 aulas
• 4 projetos
• 9h 45min

Conhecer formação

Conclusão

Neste artigo você aprendeu a como verificar se um valor é nulo em JavaScript

Utilizamos duas estratégias:

• valor === null: verifica se o tipo de dado é null;
• !valor: verificar se o valor é vazio;

Como dito no artigo, a primeira versão que vimos é um pouco limitada, não sendo amplamente aplicada em softwares, já a segunda é a mais utilizada

Pois geralmente queremos saber se o valor está preenchido ou não

Confira nossos cursos gratuitos no Youtube, com vídeos todos os dias!

Se inscreva e ative o sininho para receber as notificações e aprender mais ainda sobre desenvolvimento web!

Veja também nosso catálogo de cursos na Udemy, todos com exercícios e projetos práticos, nas mais diversas tecnologias

O link acima contém um cupom de desconto para os cursos!

Cuidado: o !valor pega mais coisa do que você imagina:

O !valor é prático, mas ele não checa só o null

Ele devolve true pra qualquer valor que o JavaScript considera falsy, e essa turma inclui o zero, a string vazia, o undefined e o NaN

console.log(!null)       // true
console.log(!undefined)  // true
console.log(!"")         // true
console.log(!0)          // true
console.log(!NaN)        // true

E é aí que mora o tropeço clássico: um campo de quantidade com valor 0 cai dentro do if de "campo vazio", mesmo sendo um dado totalmente válido

Então a regra é essa: se o 0 ou a string vazia forem valores legítimos no teu caso, o !valor não serve, beleza?

Nesse cenário tu volta pra comparação explícita com null

null e undefined são a mesma coisa?

Não são, e confundir os dois é o que faz a validação passar batido

O null é um valor que ALGUÉM colocou ali de propósito, dizendo "esse campo está vazio por decisão"

Já o undefined é a ausência total: variável declarada e nunca preenchida, propriedade que não existe no objeto, função que não retorna nada

let a = null
let b

console.log(a === null)      // true
console.log(b === null)      // false
console.log(b === undefined) // true

Repara no meio: o b está vazio, mas NÃO é null

Se o teu if só compara com null, ele deixa o undefined passar

E se tu quer pegar os dois de uma vez sem arrastar o 0 e a string vazia junto, existe um atalho:

if (x == null) {
console.log("X é null ou undefined!")
}

Sim, é o == de dois iguais, aquele que a gente costuma evitar

Esse é o único caso em que a comparação frouxa joga a teu favor: ela trata null e undefined como equivalentes e ignora o resto 🙂

Por que typeof null retorna "object"?

Muita gente tenta resolver isso com typeof e se dá mal

console.log(typeof null)       // "object"
console.log(typeof undefined)  // "undefined"

Pois é, o typeof de null diz que é objeto

Isso é um comportamento herdado da própria linguagem, mantido pra não quebrar código antigo que já existia por aí

A consequência prática é simples: typeof NÃO serve pra detectar null

Pra null tu compara direto com === null, e pro undefined o typeof funciona numa boa

Como verificar se um campo de um objeto é nulo:

Na vida real o null quase nunca está numa variável solta

Ele chega dentro de um objeto, geralmente vindo de uma resposta de API

const usuario = { nome: "Matheus", email: null }

if (usuario.email === null) {
console.log("Usuário sem email cadastrado!")
}

Até aqui tranquilo

O problema aparece quando o próprio objeto pode não vir

Se usuario for null e tu tentar ler usuario.email, o código quebra na hora

Então tu checa o caminho todo antes:

if (usuario && usuario.email !== null) {
console.log(usuario.email)
}

Ou, de forma mais curta, com o encadeamento opcional:

if (usuario?.email) {
console.log(usuario.email)
}

O ?. corta a leitura no meio caso o objeto não exista, em vez de estourar erro

Só lembra do que a gente viu lá em cima: essa última versão usa a lógica do falsy, então string vazia também cai fora

Perguntas frequentes sobre valores nulos em JavaScript:

Qual a diferença entre == null e === null?

O === null só é true quando o valor é null mesmo

Já o == null é true tanto pra null quanto pra undefined, e é justamente por isso que ele é útil aqui

Como verificar se um valor não é nulo?

É só inverter o operador: if (x !== null)

Se tu quer garantir que não é null nem undefined, usa if (x != null)

Como saber se uma string está vazia?

Pra string vazia especificamente, compara com "" ou olha o tamanho: if (x === "") {} ou if (x.length === 0) {}

Só cuida pra variável não ser null antes de chamar o .length, senão quebra

Um array ou objeto vazio é null?

Não, e isso confunde bastante

Pra saber se estão vazios tu olha o conteúdo: arr.length === 0 no array e Object.keys(obj).length === 0 no objeto