Qual é a diferença entre nulo e indefinido em JavaScript?

Eu quero saber qual é a diferença entre null e undefined em JavaScript.

Em JavaScript, undefined significa 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, é claro que undefined e null são dois tipos distintos: undefined é um tipo próprio (undefined), enquanto null é um object.

 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 recebeu 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 lhe dá um valor, ela terá o valor indefinido. Por si só, se você tentar WScript.Echo () ou alert () este valor, você não verá nada. No entanto, se você append uma string em branco a ela, ela aparecerá de repente:

 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 é uma pequena diferença, de fato.

Você pode até comparar uma variável que é indefinida para 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 para si mesmo, null é considerado um valor de object especial. Você pode ver isso usando typeof (), que retorna uma string representando o tipo geral de uma variável:

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

Executar o 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 qualquer 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 object” e isso se você tiver sorte (mas esse é um tópico para outro artigo).

Você pode explicitamente definir uma variável para ser indefinida, mas eu recomendo fortemente contra ela. Eu recomendo apenas definir variables ​​como null e deixar indefinido o valor das coisas que você esqueceu de definir. Ao mesmo tempo, eu realmente encorajo você a sempre definir todas as variables. O JavaScript tem uma cadeia de escopo diferente das linguagens do estilo C, confundindo até mesmo programadores veteranos, e definir variables ​​como nulas é a melhor maneira de evitar bugs baseados nele.

Outra instância em que você verá pop-up indefinido é ao usar o operador delete. Aqueles de nós de um mundo C podem incorretamente interpretar isso como destruindo um object, mas não é assim. O que esta operação faz é remover um subscrito de um Array ou um membro de um object. Para Matrizes, não afeta o comprimento, mas sim que o índice é agora 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 receberá undefined retornado ao ler um subscrito ou membro que nunca existiu.

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

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

pense nisso como um valor, como:

  • “foo” é string,
  • true é booleano
  • 1234 é o número
  • null é indefinido.

undefined property indica que uma variável não foi atribuída a um valor incluindo null também. Gostar

 var foo; 

variável vazia definida é null de tipo de dados undefined


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 

SO cada um tem seu próprio jeito de usar

undefined use-o para comparar o tipo de dados da variável

null use-o para esvaziar um 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 variable é um nome simbólico associado a um valor.

JS poderia ser gentil o bastante para implicitamente iniciar variables ​​recém-declaradas com null , mas isso não acontece.

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

Em JavaScript, podemos ter os seguintes tipos de variables.

  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 ​​designadas com nulo literal
  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 : A seguir é válida para variables ​​não declaradas

    • Só pode ser verificado por typeof (), que retorna 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 string ‘undefined’
    • == verificar com nulo retorna verdadeiro
    • == verificar com retornos indefinidos true
    • === verificar com nulo retorna falso
    • === verificar com retornos indefinidos true
    • se ou operador condicional ? retorna falso
  3. Variáveis ​​atribuídas com literal undefined : Essas variables ​​são tratadas de maneira semelhante às Variáveis ​​Declaradas, mas Não Designadas .

  4. Variáveis ​​designadas com nulo literal

    • typeof retorna string ‘object’
    • == verificar com nulo retorna verdadeiro
    • == verificar com retornos indefinidos true
    • === verificar com nulo retorna verdadeiro
    • === verificar 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 verificação correta de tipo de uma variável:

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

Você também pode usar a seguinte function de utilidade para determinar tipos. Atualmente suporta todos os tipos 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 } 

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 

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

via JavaScript: o guia definitivo

Vou explicar undefined , null e Uncaught ReferenceError :

1 – Uncaught ReferenceError : variável não foi declarada no 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

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

  • ambos podem conter apenas um único valor, nulo e indefinido, respectivamente;
  • ambos não possuem propriedades ou methods e uma tentativa de ler qualquer propriedade de qualquer um resultará em um erro de tempo de execução (para todos os outros objects, você obtém um valor indefinido se tentar ler uma propriedade inexistente);
  • valores nulo e indefinido são considerados iguais entre si e para nada mais por 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 

undefined , NaN e Infinity são apenas nomes de variables ​​”superglobais” pré-inicializadas – elas são inicializadas em tempo de execução e podem ser substituídas por variables ​​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 permite usá-las como nomes de variables ​​ou propriedades

Outra diferença é que undefined é um tipo primitivo, enquanto null é um tipo de object (indicando a ausência de uma referência de object). 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 no modo como null e undefined são tratados em 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 false , é 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 em contexto numérico.

Note que null e undefined recebem um tratamento especial dos operadores == e != , Mas você pode testar a igualdade numérica verdadeira de aeb com a expressão (a >= b && a < = b) .

tl; dr

Use null para definir uma variável que você sabe que é um object.

Use undefined para definir uma variável cujo tipo é misturado.


Este é o meu uso de 5 primitivos e tipo de object, e isso explica a diferença entre «caso de uso» de undefined ou null .

Corda

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

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

Número

Se você sabe que uma variável é apenas um número durante todo o ciclo de vida, por convenção, você poderia inicializá-la para 0 (ou NaN se 0 for um valor importante em 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ê sabe que uma variável é apenas booleana durante todo o ciclo de vida, por convenção, você pode inicializá-la como false :

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

Objeto

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

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

Nota: o uso inteligente off null deve ser a versão falsa de um Object, porque um Object é sempre true e porque typeof null object retorno typeof null . Isso significa que typeof myVarObject retorna um valor consistente para o tipo Object e null.

Todos

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

null é um valor especial que significa “sem valor”. null é um object especial porque typeof null retorna ‘object’.

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

Fonte

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

Vamos dizer que temos uma function simples

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

também na function acima if (a == null) é o mesmo que se (! a)

agora quando chamamos essa function 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 vai dar indefinido; nós declaramos uma variável mas não atribuímos nenhum valor a essa variável; mas se nós escrevermos

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

então null é um object. De certo modo, atribuímos um valor null a ‘a’

null é uma palavra-chave do idioma que é avaliada como um valor especial que é geralmente usado para indicar a ausência de um valor. Usar o operador typeof em null retorna a string “object”, indicando que null pode ser considerado como um valor de object especial que indica “nenhum object”. Na prática, no entanto, null é normalmente considerado como o único membro de seu próprio tipo, e pode ser usado para indicar “sem valor” para números e seqüências de caracteres, bem como objects. A maioria das linguagens de programação tem um equivalente ao nulo do JavaScript: você pode estar familiarizado com isso como nulo ou nulo.

O JavaScript também possui um segundo valor que indica ausência de valor. O valor indefinido representa um tipo mais profundo de ausência. É o valor de variables ​​que não foram inicializadas e o valor obtido quando você consulta o valor de uma propriedade de object ou elemento de matriz que não existe. O valor indefinido também é retornado por funções que não possuem valor de retorno e o valor dos parâmetros de function para os quais nenhum argumento é fornecido. undefined é uma variável global predefinida (não uma palavra-chave de linguagem como null) que é inicializada para o valor indefinido. No ECMAScript 3, undefined é uma variável de leitura / escrita e pode ser definido para qualquer valor. Este erro é corrigido no ECMAScript 5 e undefined é somente leitura nessa versão do idioma. Se você aplicar o operador typeof ao valor indefinido, ele retornará “indefinido”, indicando que esse valor é o único membro de um tipo especial.

Apesar dessas diferenças, tanto nulo quanto indefinido indicam ausência de valor e muitas vezes podem ser usados ​​de forma intercambiável. O operador de igualdade = = considera-os iguais. (Use o operador de igualdade estrito === para distingui-los.) Ambos são valores falsos – eles se comportam como falsos quando um valor booleano é requerido. Nem nulo nem indefinido tem propriedades ou methods. Na verdade, usando. ou [] para acessar uma propriedade ou método desses valores causa um TypeError.

Você pode considerar indefinido para representar uma ausência de valor no nível do sistema, inesperada ou semelhante a um erro, e null para representar a ausência de valor no nível do programa, normal ou esperada. Se você precisar atribuir um desses valores a uma variável ou propriedade ou passar um desses valores para uma function, o valor null será quase sempre a escolha correta.

OK, podemos ficar confusos quando ouvimos sobre null e undefined , mas vamos começar de maneira simples, ambos são falsos e semelhantes de muitas maneiras, mas parte estranha do JavaScript, fazem algumas diferenças significativas, por exemplo, typeof null is 'object' while typeof undefined é 'undefined' .

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

Mas se você verificá-las com == como abaixo, você verá que ambas são falsas:

 null==undefined; //true 

Além disso, você pode atribuir null a uma propriedade de object ou a uma primitiva, enquanto undefined pode simplesmente ser obtido não atribuindo nada.

Eu crio uma imagem rápida para mostrar as diferenças para você de relance.

Nulo e Indefinido

Ambos nulos e indefinidos em JavaScript indicam ausência de valor.

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

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

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

Como typeof retorna undefined, undefined é um tipo onde como null é um inicializador indica a variável aponta para nenhum object (virtualmente tudo em Javascript é um object).

null e undefined são ambos usados ​​para representar a ausência de algum valor.

 var a = null; 

a é inicializado e definido.

 typeof(a) //object 

null é um object em JavaScript

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

b é indefinido e não inicializado

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

Geralmente, atribuímos null a variables ​​não indefinidas.

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

Para o tipo null , há um e apenas um valor: null .

Então, para ambos, o label é tanto seu tipo quanto seu 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 faz mais

Na verdade, null é uma palavra-chave especial , não um identificador e, portanto, você não pode tratá-la como uma variável a ser atribuída.

No entanto, undefined é um identificador . No modo non-strict e modo strict , no entanto, você pode criar uma variável local do nome indefinido. Mas esta é 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, é atribuído o valor undefined . Isso significa que a variável não é alterada e pode receber qualquer valor no futuro. Isso também significa que você não sabe o valor que essa variável vai manter no momento da declaração.

Agora você pode atribuir explicitamente uma variável null . Isso significa que a variável não possui nenhum valor. Por exemplo – algumas pessoas não têm um nome do meio. Portanto, em tal caso, é melhor atribuir o valor null à variável middlename de um object person.

Agora, suponha que alguém esteja acessando a variável middlename do seu object person e 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á inferir facilmente que o middlename não possui nenhum valor e não é uma variável não tocada.

null – é um valor de atribuição. Qual é usado com variável para representar nenhum valor. (é um object)

undefined – É uma variável que não possui nenhum valor atribuído a ela. Então javascript irá atribuir um indefinido para ele. (é um tipo de dados)

undeclared – Se a variável não for criada, ela é conhecida como não declarada.

A diferença entre undefined e null é mínima, mas há uma diferença. Uma variável cujo valor é undefined nunca foi inicializada. Uma variável cujo valor é null recebeu explicitamente um valor null , o que significa que a variável foi explicitamente configurada para não ter valor. Se você comparar undefined e null usando a expressão null==undefined , eles serão iguais.

Por artigo completo de Ryan Morr sobre este assunto …

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

Veja Explorando o Abismo Eterno de Nulo e Indefinido

Com JavaScript, null é para objects, undefined é para variables, propriedades e methods.

Para ser nulo, um object deve ser definido, caso contrário, ele será indefinido.

Se você quiser testar se um object existe, isso gerará um erro se o object for indefinido:

Incorreta:

 if (myObj !== null && typeof myObj !== "undefined") 

Por causa disso, você deve testar o typeof () primeiro:

Corrigir:

 if (typeof myObj !== "undefined" && myObj !== null) 

Quando um valor é nulo, não é nada e não contém nada. Um valor vazio ou variável ainda está cheio; é apenas cheio de vazio. Vazio é diferente de null, que é simplesmente nada. Por exemplo, definir uma variável e definir seu valor como uma string vazia é semelhante a isto:

  var myVariable = ''; 

A variável myVariable está vazia, mas não é nula.

Undefined é um estado, às vezes usado como um valor, para representar uma variável que ainda não continha um valor. tal como var abcd ; . Este estado é diferente de null, embora ambos nulos e indefinidos possam avaliar da mesma maneira.

  • undefined significa que uma variável foi declarada, mas ainda não foi atribuído um valor.
  • null é um valor de atribuição. Pode ser atribuído a uma variável como uma representação sem valor.
  • undefined e null são dois tipos distintos:

undefined é um tipo em si (undefined), enquanto null é um object.

  • Variáveis ​​não atribuídas são inicializadas por JavaScript com um valor padrão de indefinido.
  • O JavaScript nunca define um valor como nulo. Isso deve ser feito de forma programática.

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

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ê terá como saída.

Agora,

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

e você terá 5 como saída. Essa é a principal diferença entre o indefinido e o nulo

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

undefined significa que uma variável recebeu um espaço na memory, 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 denotar quando você deseja que uma variável fique sem valor em um ponto posterior no código? Você pode usar o tipo null , que também é um tipo usado para definir a mesma coisa, ausência de um valor, mas não é o mesmo que undefined, já que neste caso você realmente tem o valor na memory. Esse valor é nulo

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

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

Verifique o log de console na ferramenta de desenvolvimento, ele será impresso como indefinido.

null é um object.Se você quer que alguma variável seja nula, então null é usado. Variável nula existe, mas o valor não é conhecido.Ele deve ser atribuído a uma variável pro grammaticamente. null não é inicializado automaticamente.

Exemplo: var MyName = null; console.log (typeof MyName); Verifique o log da csole na ferramenta de desenvolvimento, ele será um object.

Just to add my views –

A variable that is declared only, and never used anywhere, is removed off by an optimizing compiler in case of compiled languages like C++[or a warning is flagged in the IDE]. It ultimately means that the variable is non-existent because it’s memory is never allocated.

In case of javascript interpreter, [I guess] a variable is treated as existing only from the point onwards where it is given a value. Before that point, it’s type is “undefined”, and no memory is allocated for it. And, so its type is undefined.

A null in javascript is a value that represents an address, but that address points to nothing yet[non-existent reference]. Nevertheless, its a value.

Null is ALWAYS an unknown object that exists in memory, whereas undefined is not.