6.8 - Métodos auxiliares para null e undefined

No JavaScript, os valores null e undefined são utilizados para representar diferentes tipos de ausência de valor. Ao lidar com variáveis que podem ter esses valores, é útil conhecer alguns métodos auxiliares que podem facilitar a manipulação e verificação desses valores. Neste capítulo, exploraremos alguns dos principais métodos disponíveis para lidar com variáveis do tipo null e undefined, explicando-os de maneira clara e fornecendo exemplos detalhados para facilitar o entendimento.

6.8.1. Comparação estrita (===)

Você pode verificar se uma variável é null ou undefined usando uma comparação estrita (===). Isso retorna verdadeiro se a variável for null ou undefined e falso se não for.

let x = null;
let y;
console.log(x === null); 
// Saída: true

console.log(y === undefined); 
// Saída: true

6.8.2. Operadores

6.8.2.1. Operador de coalescência nula (??)

O operador de coalescência nula (??) pode ser usado para atribuir um valor padrão a uma variável se ela for null ou undefined.

let x = null;
let y;
let z = x ?? "Valor padrão para x";
let w = y ?? "Valor padrão para y";
console.log(z); 
// Saída: "Valor padrão para x"

console.log(w); 
// Saída: "Valor padrão para y"

6.8.2.2. Operador ternário

Você também pode usar o operador ternário para verificar se uma variável é null ou undefined e atribuir um valor padrão.

let x = null;
let y;
let z = x !== null ? x : "Valor padrão para x";
let w = y !== undefined ? y : "Valor padrão para y";
console.log(z); 
// Saída: "Valor padrão para x"

console.log(w); 
// Saída: "Valor padrão para y"

6.8.3. Função de verificação personalizada

Assim como para os tipos null e undefined, você pode criar sua própria função de verificação para determinar se uma variável é null ou undefined.

function isNullOrUndefined(value) {
  return value === null || value === undefined;
}

let x = null;
let y;
console.log(isNullOrUndefined(x)); 
// Saída: true

console.log(isNullOrUndefined(y)); 
// Saída: true

6.8.4 Diferença entre o Undefined e Null

No JavaScript, null e undefined são dois valores que frequentemente causam confusão devido às suas semelhanças. No entanto, eles têm significados distintos e são utilizados em contextos diferentes.

6.8.4.1 O que é null?

O valor null em JavaScript é utilizado para representar a ausência intencional de um valor. Ou seja, quando uma variável é null, significa que ela foi explicitamente atribuída como vazia ou sem valor.

6.8.4.2 O que é undefined?

Por outro lado, undefined em JavaScript indica que uma variável foi declarada, mas ainda não foi atribuída com um valor. Isso pode acontecer quando uma variável é declarada, mas nenhum valor é atribuído a ela.

6.8.4.3 Quando usar null?

O valor null é geralmente utilizado quando queremos indicar explicitamente a ausência de valor ou quando desejamos redefinir uma variável que tem valor para um estado sem valor.

Aqui está uma versão aprimorada do exemplo:

let name = 'Sara'; 

// Suponha que queremos redefinir a variável 'name' para indicar que não temos mais o nome de Sara
if(name === 'Sara') {
    name = null; 
    // Agora, a variável 'name' está explicitamente definida como sem valor
}

console.log(name); 
// Saída: null

6.8.4.4 Quando usar undefined?

O valor undefined, por outro lado, é utilizado pelo JavaScript para representar variáveis que foram declaradas, mas não inicializadas ou ainda não tiveram um valor atribuído. Ele também pode ser retornado por funções que não têm uma declaração de retorno explícita.

Exemplo de uso de undefined:

let age; 
// age é undefined

6.8.4.5 Principais diferenças entre null e undefined

• Inicialização: null é explicitamente atribuído a uma variável para indicar ausência de valor, enquanto undefined é o valor padrão atribuído a variáveis que foram declaradas, mas não inicializadas.

• Uso em funções: null é frequentemente usado para indicar que uma função não retornou um valor válido, enquanto undefined é o valor retornado por padrão quando uma função não tem uma declaração de retorno explícita.

• Verificação de tipo: typeof null retorna "object", enquanto typeof undefined retorna "undefined". Isso pode ser útil ao verificar tipos de variáveis em JavaScript.

Vamos ver alguns exemplos que destacam a diferença entre null e undefined:

// Definindo uma variável com valor null
let variableNull = null;
console.log('Valor da variável com null:', variableNull); 
// Saída: null

console.log('Tipo da variável com null:', typeof variableNull); 
// Saída: object

// Definindo uma variável sem valor atribuído
let variableUndefined;
console.log('Valor da variável sem valor atribuído:', variableUndefined); 
// Saída: undefined

console.log('Tipo da variável sem valor atribuído:', typeof variableUndefined); 
// Saída: undefined

// Função que retorna explicitamente null
function returnNull() {
  return null;
}

// Função que não tem retorno explícito
function returnUndefined() {
  // Sem retorno explícito
}

console.log('Retorno da função com null:', returnNull()); 
// Saída: null

console.log('Retorno da função com undefined:', returnUndefined()); 
// Saída: undefined

Em resumo, null e undefined são valores distintos em JavaScript, cada um com seu próprio significado e uso. Enquanto null é utilizado para indicar explicitamente a ausência de valor, undefined é o valor padrão para variáveis não inicializadas ou para retornos de funções sem declaração explícita de retorno. Ao entender essa diferença e usar os valores corretamente em seus scripts, você evitará comportamentos inesperados e tornará seu código mais legível e fácil de entender.

No próximo capítulo, exploraremos os operadores essenciais do JavaScript, como os aritméticos, de comparação e lógicos. Dominar esses operadores é fundamental para realizar cálculos, comparações e controlar o fluxo de execução do código, essencial para realizar expressões matemáticas e tomadas de decisão inteligentes em JavaScript!