Qual é a diferença entre null e undefined em JavaScript?

Quero saber qual é a diferença entre nulle undefinedem JavaScript.

Em JavaScript, undefinedsignifica que uma variável foi declarada, mas ainda não foi atribuída um valor, como:

var TestVar;
alert(TestVar); //shows undefined
alert(typeof TestVar); //shows undefined

nullé um valor de atribuição. Pode ser atribuído a uma variável como uma representação sem valor:

var TestVar = null;
alert(TestVar); //shows null
alert(typeof TestVar); //shows object

A partir dos exemplos anteriores, é evidente que undefinede nulldois tipos distintos: undefinedé um si (indefinido) Tipo enquanto nullé um objecto.

null === undefined // false
null == undefined // true
null === null // true

e

null = 'value' // ReferenceError
undefined = 'value' // 'value'

Eu escolhi isso daqui

O valor indefinido é um valor primitivo usado quando uma variável não foi atribuída a um valor.

O valor nulo é um valor primitivo que representa a referência nula, vazia ou inexistente.

Quando você declara uma variável através de var e não atribui um valor a ela, ela terá o valor indefinido. Por si só, se você tentar WScript.Echo () ou alertar () esse valor, não verá nada. No entanto, se você anexar uma string em branco a ela, de repente ela aparecerá:

var s;
WScript.Echo(s);
WScript.Echo("" + s);

Você pode declarar uma variável, defini-la como nula e o comportamento é idêntico, exceto que você verá "nulo" impresso versus "indefinido". Esta é realmente uma pequena diferença.

Você pode até comparar uma variável indefinida como nula ou vice-versa, e a condição será verdadeira:

undefined == null
null == undefined

Eles são, no entanto, considerados dois tipos diferentes. Enquanto indefinido é um tipo exclusivo, nulo é considerado um valor de objeto especial. Você pode ver isso usando typeof (), que retorna uma string que representa o tipo geral de uma variável:

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

A execução do script acima resultará na seguinte saída:

undefined
object

Independentemente de serem tipos diferentes, eles ainda agirão da mesma forma se você tentar acessar um membro de um deles, por exemplo, ou seja, eles lançarão uma exceção. Com o WSH, você verá que o temido "'varname' é nulo ou não é um objeto" e isso se você tiver sorte (mas esse é um tópico para outro artigo).

Você pode definir explicitamente uma variável como indefinida, mas eu não aconselho isso. Eu recomendo apenas definir variáveis ​​como nulas e deixar indefinido o valor para as coisas que você esqueceu de definir. Ao mesmo tempo, recomendo que você sempre defina todas as variáveis. O JavaScript tem uma cadeia de escopo diferente da linguagem C, confundindo facilmente até os programadores veteranos e definir variáveis ​​como nulo é a melhor maneira de evitar bugs com base nele.

Outra instância em que você verá um pop-up indefinido é ao usar o operador de exclusão. Aqueles de nós do mundo C podem interpretar incorretamente isso como destruindo um objeto, mas não é assim. O que essa operação faz é remover um subscrito de uma matriz ou um membro de um objeto. Para matrizes, não afeta o comprimento, mas agora esse índice é considerado indefinido.

var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);

O resultado do script acima é:

0.) a
1.) undefined
2.) c

Você também será indefinido retornado ao ler um subscrito ou membro que nunca existiu.

A diferença entre nulo e indefinido é: JavaScript nunca definirá nada como nulo, geralmente é o que fazemos. Embora possamos definir variáveis ​​como indefinidas, preferimos null porque não é algo que é feito para nós. Quando você está depurando, isso significa que qualquer coisa definida como nula é sua e não JavaScript. Além disso, esses dois valores especiais são quase equivalentes.

(adicionando caracteres devido à falta de caracteres, por isso estou autorizado a postar isso.)

null é uma palavra-chave especial que indica uma ausência de valor.

pense nisso como um valor, como:

• "foo" é string,
• verdadeiro é booleano,
• 1234 é o número,
• null é indefinido.

propriedade indefinida indica que uma variável não recebeu um valor incluindo nulo também. Gostar

var foo;

variável vazia definida é nulldo tipo de dadosundefined

Ambos estão representando um valor de uma variável sem valor

AND null não representa uma string que não tem valor - string vazia-

Gostar

var a = ''; 
console.log(typeof a); // string 
console.log(a == null); //false 
console.log(a == undefined); // false 

Agora se

var a;
console.log(a == null); //true
console.log(a == undefined); //true 

MAS

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

Então, cada um tem sua própria maneira de usar

indefinido use-o para comparar o tipo de dados variável

null use-o para esvaziar o valor de uma variável

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

null : ausência de valor para uma variável; indefinido : ausência da própria variável;

..where variável é um nome simbólico associado a um valor.

O JS pode ser gentil o suficiente para iniciar implicitamente variáveis ​​recém-declaradas com nulo , mas isso não acontece.

Por favor leia o texto abaixo com atenção. Ele removerá todas as suas dúvidas sobre a diferença entre nulo e indefinido no JavaScript. Além disso, você pode usar a função de utilitário fornecida abaixo para determinar exatamente os tipos.

Em JavaScript, podemos ter os seguintes tipos de variáveis.

1. Variáveis ​​não declaradas
2. Variáveis ​​declaradas mas não atribuídas
3. Variáveis ​​atribuídas com literal indefinido
4. Variáveis ​​atribuídas com literal nulo
5. Variáveis ​​atribuídas com algo diferente de indefinido ou nulo

A seguir, explica cada um desses casos, um por um

1. Variáveis ​​não declaradas : o seguinte é válido para variáveis ​​não declaradas

   • Só pode ser verificado por typeof () que retorna a string 'undefined'
   • Não pode ser verificado com == ou === ou pelo operador if ou condicional ? (lança erro de referência)

2. Variáveis ​​declaradas mas não atribuídas

   • typeof retorna a string 'indefinida'
   • == verifique com retornos nulos verdadeiros
   • == verificar com retornos indefinidos true
   • === verificar com retornos nulos false
   • === verificar com retornos indefinidos true
   • se ou operador condicional ? retorna falso

3. Variáveis ​​atribuídas com literal indefinido : essas variáveis ​​são tratadas da mesma forma que as variáveis ​​declaradas, mas não atribuídas .

4. Variáveis ​​atribuídas com literal nulo

   • typeof retorna a string 'objeto'
   • == verifique com retornos nulos verdadeiros
   • == verificar com retornos indefinidos true
   • === verifique com retornos nulos verdadeiros
   • === verifique com retornos indefinidos false
   • se ou operador condicional ? retorna falso

5. Variáveis ​​atribuídas com algo diferente de indefinido ou nulo

   • typeof retorna uma das seguintes strings: 'string' , 'number' , 'boolean' , 'function' , 'object' , 'symbol'

A seguir, fornece o algoritmo para a verificação correta do tipo de uma variável:

1. Verifique se não foi declarado / não atribuído / atribuído com indefinido usando typeof . return se a string 'undefined' for retornada.
2. Verifique se há nulo usando === . retorne 'null' se verdadeiro .
3. Verifique o tipo real usando typeof . tipo de retorno se não for igual a 'objeto'
4. Chame Object.prototype.toString.call (o) para determinar o tipo de objeto real. Ele deve retornar uma string do tipo '[objectType do objeto]' para todos os objetos definidos em Javascript ou DOM . Para objetos definidos pelo usuário, ele retorna '[object Object]'

Você também pode usar a seguinte função de utilitário para determinar tipos. Atualmente, ele suporta todos os tipos de ECMA 262 2017.

function TypeOf(o,bReturnConstructor)
 {
   if(typeof o==='undefined') return 'undefined'
   if(o===null) return 'null'   
   if(typeof o!=='object') return typeof o

   var type=Object.prototype.toString.call(o)
  switch(type)
  {
     //Value types:4
     case '[object Number]': type='number';break;
     case '[object String]': type='string';break;
     case '[object Boolean]': type='boolean';break;
     case '[object Date]': type='date';break;


   //Error Types:7
     case '[object Error]': type='error';break;
     case '[object EvalError]': type='evalerror';break;
     case '[object RangeError]': type='rangeerror';break;
     case '[object ReferenceError]': type='referenceerror';break;
     case '[object SyntaxError]': type='syntaxerror';break;
     case '[object TypeError]': type='typeerror';break;
     case '[object URIError]': type='urierror';break;


    //Indexed Collection and Helper Types:13
     case '[object Array]': type='array';break;
     case '[object Int8Array]': type='int8array';break;
     case '[object Uint8Array]': type='uint8array';break;
     case '[object Uint8ClampedArray]': type='uint8clampedarray';break;
     case '[object Int16Array]': type='int16array';break;
     case '[object Uint16Array]': type='uint16array';break;
     case '[object Int32Array]': type='int32array';break;
     case '[object Uint32Array]': type='uint32array';break;
     case '[object Float32Array]': type='float32array';break;
     case '[object Float64Array]': type='float64array';break;
     case '[object ArrayBuffer]': type='arraybuffer';break;
     case '[object SharedArrayBuffer]': type='sharedarraybuffer';break;
     case '[object DataView]': type='dataview';break;

    //Keyed Collection Types:2
     case '[object Map]': type='map';break;
     case '[object WeakMap]': type='weakmap';break;

    //Set Types:2
     case '[object Set]': type='set';break;
     case '[object WeakSet]': type='weakset';break;

    //Operation Types
    case '[object RegExp]': type='regexp';break;
    case '[object Proxy]': type='proxy';break;
    case '[object Promise]': type='promise';break;

    case '[object Object]': type='object';
             if(bReturnConstructor && o.constructor) type=o.constructor.toString().match(/^function\s*([^\s(]+)/)[1];
         break;
    default:
        type=type.split(' ')[1]
        type=type.substr(0,type.length-1)   

   }
    return type 
}

Você pode considerar indefinido para representar uma ausência de valor no nível do sistema, inesperada ou semelhante a erro e nulo para representar a ausência de valor no nível do programa, normal ou esperada.

via JavaScript: O Guia Definitivo

Vou explicar undefined, nulle Uncaught ReferenceError:

1 - Uncaught ReferenceError: variável não foi declarada em seu script, não há referência a esta variável
2 - undefined: Variável declarada mas não inicializada
3 - null: Variável declarada e é um valor vazio

Indefinido significa que uma variável foi declarada, mas não tem valor:

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

Nulo é uma tarefa:

var var2= null;
alert(var2); //null
alert(typeof var2); //object

null e undefined são dois tipos de objetos distintos que têm o seguinte em comum:

• ambos podem conter apenas um único valor, nulo e indefinido, respectivamente;
• ambos não têm propriedades ou métodos e uma tentativa de ler qualquer uma das propriedades resultará em um erro em tempo de execução (para todos os outros objetos, você obtém valor indefinido se tentar ler uma propriedade inexistente);
• valores nulos e indefinidos são considerados iguais entre si e a nada mais pelos operadores ==e !=.

As semelhanças, no entanto, terminam aqui. Pela primeira vez, há uma diferença fundamental na maneira como as palavras-chave nulas e indefinidas são implementadas. Isso não é óbvio, mas considere o seguinte exemplo:

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

indefinido , NaN e Infinity são apenas nomes de variáveis ​​"superglobal" pré-inicializadas - são inicializadas em tempo de execução e podem ser substituídas por variáveis ​​globais ou locais normais com os mesmos nomes.

Agora, vamos tentar a mesma coisa com null :

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

Opa! null , true e false são palavras-chave reservadas - o compilador não permitirá que você as use como nomes de variáveis ​​ou propriedades

Outra diferença é que indefinido é um tipo primitivo, enquanto nulo é um tipo de objeto (indicando a ausência de uma referência a objeto). Considere o seguinte:

WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object

Além disso, há uma diferença importante na maneira como nulo e indefinido são tratados no contexto numérico:

var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1

var b = null; // the value null must be explicitly assigned 
WScript.Echo(b === null); // Prints: -1

WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)

WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)

WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)

WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)

null torna-se 0 quando usado em expressões aritméticas ou comparações numéricas - da mesma forma que falso , é basicamente apenas um tipo especial de "zero". indefinido , por outro lado, é um verdadeiro "nada" e se torna NaN ("não é um número") quando você tenta usá-lo no contexto numérico.

Note-se que nula e indefinido receber um tratamento especial a partir ==e !=operadores, mas você pode testar a verdadeira igualdade numérica de um e b com a expressão (a >= b && a <= b).

tl; dr

Use nullpara definir uma variável que você sabe que é um Objeto.

Use undefinedpara definir uma variável cujo tipo é misto.

Esse é o meu uso das 5 primitivas e do tipo Objeto, e que explica a diferença entre «caso de uso» de undefinedou null.

Corda

Se você souber que uma variável é apenas uma string, durante todo o ciclo de vida, por convenção, você pode inicializá-la para "":

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

Número

Se você souber que uma variável é apenas um número durante todo o ciclo de vida, por convenção, poderá inicializá-la para 0(ou NaNse 0for um valor importante no seu uso):

(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"

ou

(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"

boleano

Se você souber que uma variável é apenas um booleano enquanto todo o ciclo de vida, por convenção, você pode inicializá-la para false:

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

Objeto

Se você souber que uma variável é apenas um Objeto enquanto todo o ciclo de vida, por convenção, você pode inicializá-la para null:

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

Nota: o uso inteligente de nulo deve ser a versão falsa de um Objeto porque um Objeto é sempre truee porque typeof nullretorna object. Isso significa typeof myVarObjectretornar valor consistente para o objeto e o tipo nulo.

Todos

Se você souber que uma variável possui um tipo misto (qualquer tipo durante todo o ciclo de vida), por convenção, você pode inicializá-la para undefined.

nullé um valor especial que significa "sem valor". nullé um objeto especial porque typeof nullretorna 'objeto'.

Por outro lado, undefinedsignifica que a variável não foi declarada ou não recebeu um valor.

A melhor maneira de entender a diferença é primeiro limpar sua mente do funcionamento interno do JavaScript e apenas entender as diferenças de significado entre:

let supervisor = "None"
    // I have a supervisor named "None"

let supervisor = null
    // I do NOT have a supervisor. It is a FACT that I do not.

let supervisor = undefined
    // I may or may not have a supervisor. I either don't know
    // if I do or not, or I am choosing not to tell you. It is
    // irrelevant or none of your business.

Há uma diferença de significado entre esses três casos, e o JavaScript distingue os dois últimos casos com dois valores diferentes, nulle undefined. Você é livre para usar esses valores explicitamente para transmitir esses significados.

Então, quais são alguns dos problemas específicos do JavaScript que surgem devido a essa base filosófica?

1. Uma variável declarada sem inicializador obtém o valor undefinedporque você nunca disse nada sobre qual era o valor pretendido.

   let supervisor;
   assert(supervisor === undefined);

2. Uma propriedade de um objeto que nunca foi definido é avaliada undefinedporque ninguém nunca disse nada sobre essa propriedade.

   const dog = { name: 'Sparky', age: 2 };
   assert(dog.breed === undefined);

3. nulle undefinedsão "semelhantes" um ao outro porque Brendan Eich disse isso. Mas eles não são enfaticamente iguais entre si.

   assert(null == undefined);
   assert(null !== undefined);

4. nulle undefinedfelizmente tem tipos diferentes. nullpertence ao tipo Nulle undefinedao tipo Undefined. Isso está nas especificações, mas você nunca saberia isso por causa da typeofestranheza que não repetirei aqui.

5. Uma função que chega ao final de seu corpo sem uma declaração de retorno explícita retorna, undefinedpois você não sabe nada sobre o que ela retornou.

A propósito, existem outras formas de "nada" no JavaScript (é bom ter estudado Filosofia ...)

• NaN
• Usando uma variável que nunca foi declarada e recebendo um ReferenceError
• Usando uma variável local letou constdefinida em sua zona morta temporal e recebendo umReferenceError

• Células vazias em matrizes esparsas. Sim, eles não são iguais, undefinedembora sejam comparados ===com os indefinidos.

  $ node
  > const a = [1, undefined, 2]
  > const b = [1, , 2]
  > a
  [ 1, undefined, 2 ]
  > b
  [ 1, <1 empty item>, 2 ]

No JavasSript, existem 5 tipos de dados primitivos: String, Number, Boolean, null e undefined. Vou tentar explicar com um exemplo simples

digamos que temos uma função simples

 function test(a) {

     if(a == null){
        alert("a is null");
     } else {
        alert("The value of a is " + a);
     }
  }

também na função acima se (a == null) for igual a se (! a)

Agora, quando chamamos essa função sem passar o parâmetro a

   test(); it will alert "a is null";
   test(4); it will alert "The value of a is " + 4;

Além disso

var a;
alert(typeof a); 

isso dará indefinido; declaramos uma variável, mas não atribuímos nenhum valor a essa variável; mas se escrevermos

var a = null;
alert(typeof a); will give alert as object

tão nulo é um objeto. de certa forma, atribuímos um valor nulo a 'a'

Para o undefinedtipo, existe um e apenas um valor: undefined.

Para o nulltipo, existe um e apenas um valor: null.

Portanto, para os dois, o rótulo é do tipo e do valor.

A diferença entre eles. Por exemplo:

• null é um valor vazio
• undefined é um valor ausente

Ou:

• undefined ainda não teve um valor
• null tinha um valor e não tem mais

Na verdade, nullé uma palavra-chave especial , não um identificador e, portanto, você não pode tratá-la como uma variável à qual atribuir.

No entanto, undefinedé um identificador . No non-strictmodo e no strictmodo, no entanto, você pode criar uma variável local do nome indefinida. Mas essa é uma ideia terrível!

function foo() {
    undefined = 2; // bad idea!
}

foo();

function foo() {
    "use strict";
    undefined = 2; // TypeError!
}

foo();

Quando você declara uma variável em javascript, ele recebe o valor undefined. Isso significa que a variável está intocada e pode ser atribuído qualquer valor no futuro. Isso também implica que você não sabe o valor que essa variável manterá no momento da declaração.

Agora você pode atribuir explicitamente uma variável null. Isso significa que a variável não tem nenhum valor. Por exemplo - algumas pessoas não têm um nome do meio. Portanto, nesse caso, é melhor atribuir o valor nulo à variável middlename de um objeto de pessoa.

Agora, suponha que alguém esteja acessando a variável middlename do objeto de sua pessoa e ela tenha o valor undefined. Ele não saberia se o desenvolvedor esqueceu de inicializar essa variável ou se não tinha nenhum valor. Se tiver o valor null, o usuário poderá deduzir facilmente que o nome do meio não tem nenhum valor e não é uma variável intocada.

nulo e indefinido são usados ​​para representar a ausência de algum valor.

var a = null;

a é inicializado e definido.

typeof(a)
//object

null é um objeto em JavaScript

Object.prototype.toString.call(a) // [object Object]

var b;

b é indefinido e não inicializado

propriedades de objeto indefinidas também são indefinidas. Por exemplo "x" não está definido no objeto c e se você tentar acessar cx, ele retornará indefinido.

Geralmente, atribuímos nulo a variáveis ​​não indefinidas.

Por artigo completo de Ryan Morr sobre este assunto ...

"Geralmente, se você precisar atribuir um valor não a uma variável ou propriedade, passá-lo para uma função ou retorná-lo de uma função, nulo é quase sempre a melhor opção. Para simplificar, o JavaScript usa indefinido e os programadores devem use null ".

Veja Explorando o eterno abismo de nulo e indefinido

Nulo e indefinido no JavaScript indicam ausência de valor.

var a = null; //variable assigned null value
var b;  // undefined

Apesar do fato de ambos existirem por falta de valor, mas: Indefinido na verdade significa que a variável não é inicializada. Funções que não retornam nada e parâmetros de função para os quais nenhum valor é fornecido, um valor indefinido é retornado. Use o operador de igualdade estrita === para distinguir entre nulo e indefinido.

Referência: http://www.thesstech.com/javascript/null-and-undefined

OK, podemos ficar confusos quando ouvimos falar sobre nulle undefined, mas vamos começar com simplicidade, os dois são falsos e similares de várias maneiras, mas a parte estranha do JavaScript faz algumas diferenças significativas, por exemplo, typeof null é 'object'enquanto typeof undefined é 'undefined'.

typeof null; //"object"
typeof undefined; //"undefined";

Mas se você as verificar ==como abaixo, verá que ambas são falsas :

null==undefined; //true

Além disso, você pode atribuir nulla uma propriedade de objeto ou a uma primitiva, enquanto isso undefinedpode ser alcançado simplesmente não atribuindo a nada.

Crio uma imagem rápida para mostrar as diferenças para você rapidamente.

Como typeof retorna indefinido, undefined é um tipo em que null é um inicializador que indica que a variável aponta para nenhum objeto (praticamente tudo em Javascript é um objeto).

Em javascript, todas as variáveis ​​são armazenadas como pares de valores-chave. Cada variável é armazenada como variable_name: variable_value / reference .

indefinido significa que uma variável recebeu um espaço na memória, mas nenhum valor foi atribuído a ela. Como prática recomendada, você não deve usar esse tipo como uma atribuição.

Nesse caso, como indicar quando você deseja que uma variável fique sem valor posteriormente no código? Você pode usar o tipo nulo , que também é usado para definir a mesma coisa, ausência de valor, mas não é o mesmo que o indefinido, pois nesse caso você realmente tem o valor na memória. Esse valor é nulo

Ambos são semelhantes, mas o uso e o significado são diferentes.

Quero adicionar uma diferença muito sutil entre nulle undefinedque é bom saber quando você está tentando aprender o Vanilla JavaScript (JS) desde o início:

• nullé uma palavra-chave reservada em JS, enquanto undefinedé uma variável no objeto global do ambiente de tempo de execução em que você está.

Ao escrever o código, essa diferença não é identificável como ambas nulle undefinedsempre é usada no RHS de uma instrução JavaScript. Mas quando você os usa no LHS de uma expressão, pode observar facilmente essa diferença. Portanto, o interpretador JS interpreta o código abaixo como erro:

var null = 'foo'

Dá abaixo erro:

SyntaxError não capturado: token inesperado nulo

Embora o código abaixo seja executado com êxito, embora eu não recomende isso na vida real:

var undefined = 'bar'

Isso funciona porque undefinedé uma variável no objeto global (objeto da janela do navegador no caso de JS do lado do cliente)

A diferença entre undefinede nullé mínima, mas há uma diferença. Uma variável cujo valor é undefinednunca foi inicializada. Uma variável cujo valor é nullrecebeu explicitamente um valor de null, o que significa que a variável foi definida explicitamente para não ter valor. Se você comparar undefinede nullusando a null==undefinedexpressão, eles serão iguais.

Basicamente, Indefinido é uma variável global que o javascript cria no tempo de execução, se nulo significa que nenhum valor foi atribuído à variável (na verdade, nulo é um objeto).

Vamos dar um exemplo:

        var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

Indefinido é o que você obterá como saída.

Agora,

        x=5;
        y=null;
        z=x+y;

e você receberá 5 como saída. Essa é a principal diferença entre Undefined e null

null - é um valor de atribuição, usado com a variável para representar nenhum valor (é um objeto).

undefined - é uma variável que não possui nenhum valor atribuído a ela, portanto o JavaScript atribui um indefinido a ela (é um tipo de dados).

não declarado - Se uma variável não é criada, é conhecida como não declarada.

Veja isso. A saída vale mais que mil palavras.

var b1 = document.getElementById("b1");

checkif("1, no argument"                        );
checkif("2, undefined explicitly",     undefined);
checkif("3, null explicitly",               null);
checkif("4, the 0",                            0);
checkif("5, empty string",                    '');
checkif("6, string",                    "string");
checkif("7, number",                      123456);

function checkif (a1, a2) {
	print("\ncheckif(), " + a1 + ":");
	if (a2 == undefined) {
		print("==undefined:    YES");
	} else {
		print("==undefined:    NO");
	}
	if (a2 === undefined) {
		print("===undefined:   YES");
	} else {
		print("===undefined:   NO");
	}
	if (a2 == null) {
		print("==null:         YES");
	} else {
		print("==null:         NO");
	}
	if (a2 === null) {
		print("===null:        YES");
	} else {
		print("===null:        NO");
	}
	if (a2 == '') {
		print("=='':           YES");
	} else {
		print("=='':           NO");
	}
	if (a2 === '') {
		print("==='':          YES");
	} else {
		print("==='':          NO");
	}
	if (isNaN(a2)) {
		print("isNaN():        YES");
	} else {
		print("isNaN():        NO");
	}
	if (a2) {
		print("if-?:           YES");
	} else {
		print("if-?:           NO");
	}
		print("typeof():       " + typeof(a2));
}

function print(v) {
	b1.innerHTML += v + "\n";
}

<!DOCTYPE html>
<html>
<body>
<pre id="b1"></pre>
</body>
</html>

Veja também:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators

Felicidades!

Ambos os valores especiais implicam um estado vazio.

A principal diferença é que indefinido representa o valor de uma variável que ainda não foi inicializada, enquanto nulo representa uma ausência intencional de um objeto.

O número da variável é definido, no entanto, não é atribuído com um valor inicial:

let number;
number; // => undefined

A variável numérica é indefinida, o que indica claramente uma variável não inicializada

O mesmo conceito não inicializado acontece quando uma propriedade de objeto não existente é acessada:

const obj = { firstName: 'Dmitri' };
obj.lastName; // => undefined

Como a propriedade lastName não existe em obj, o JavaScript avalia corretamente obj.lastName como indefinido.

Em outros casos, você sabe que uma variável espera reter um objeto ou uma função para retornar um objeto. Mas, por algum motivo, você não pode instanciar o objeto. Nesse caso, nulo é um indicador significativo de um objeto ausente.

Por exemplo, clone () é uma função que clona um objeto JavaScript simples. Espera-se que a função retorne um objeto:

function clone(obj) {
  if (typeof obj === 'object' && obj !== null) {
    return Object.assign({}, obj);
  }
  return null;
}
clone({name: 'John'}); // => {name: 'John'}
clone(15);             // => null
clone(null);           // => null

No entanto, clone () pode ser chamado com um argumento não-objeto: 15 ou nulo (ou geralmente um valor primitivo, nulo ou indefinido). Nesse caso, a função não pode criar um clone, portanto retorna nulo - o indicador de um objeto ausente.

O operador typeof faz a distinção entre os dois valores:

typeof undefined; // => 'undefined'
typeof null;      // => 'object'

O operador de qualidade estrita === diferencia corretamente indefinido de nulo:

let nothing = undefined;
let missingObject = null;
nothing === missingObject; // => false

Além de um significado diferente, existem outras diferenças:

1. A destruição de objetos funciona de maneira diferente para esses dois valores:

   const { a = "default" } = { a: undefined }; // a is "default"
   const { b = "default" } = { b: null };      // b is null

2. JSON.stringify () mantém nullmas omiteundefined

   const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
   console.log(json); // prints {"nullValue":null}

3. operador typeof

   console.log(typeof undefined); // "undefined"
   console.log(typeof null);      // "object" instead of "null"

Se uma variável não for inicializada, será indefinida. undefined não é um objeto. Exemplo: var MyName; console.log (typeof MyName);

Verifique a ferramenta de desenvolvimento de logon do console, ela será impressa como indefinida.

nulo é um objeto. Se você deseja que alguma variável seja nula, então nulo é usado. existe uma variável nula, mas o valor não é conhecido. null não é inicializado automaticamente.

Exemplo: var MyName = null; console.log (typeof MyName); Verifique a ferramenta de desenvolvimento csole log in, será um objeto.