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

1086

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


fonte
2
possível duplicata de Por que existe um nullvalor em JavaScript?
Outis
1
Principalmente uma duplicata de JavaScript verificação de nulo vs. indefinido e diferença entre == e ===
Dan Dascalescu
11
Eu sempre pensei: nullvocê está definido como vazio, undefinedestá vazio porque não foi definido. Ou nullestá vazio de propósito, enquanto undefinedainda está vazio. Basicamente, mostra intenção.
Muhammad Umer
15
NaN. Veja por si mesmo. console.log (nulo-indefinido). A diferença entre nulo e indefinido é NaN. (Note-se que esta é uma tentativa de humor, antes que você me chama de mal-entendido a pergunta.)
Ivan

Respostas:

1040

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'
sebastiano
fonte
301
Citação do livro Professional JS for Web Developers (Wrox): "Você pode se perguntar por que o operador typeof retorna 'object' com um valor nulo. Na verdade, foi um erro na implementação JavaScript original que foi copiada no ECMAScript. Hoje , é racionalizado que null é considerado um espaço reservado para um objeto, mesmo que, tecnicamente, seja um valor primitivo ".
Captain Sensible
34
a variável também pode não estar definida. por exemplo: console.log (typeof (abc)); indefinido
Nir O.
19
O comentário de Nir O. é muito importante. Se eu quero ter uma variável que não tem valor no começo, escrevo "... = null", por exemplo "myvar = null". Dessa forma - quando digito "if (myxar == null) {...}" - o bloco if não é executado. Não tenho essa vantagem com undefined: myvar = undefined; myvar = 4; if (typeof myxar == "indefinido") {...}
Wolfgang Adamec
11
@ Wolfgang Adamec, programação livre de erros não é sobre erros de digitação.
Jorge Fuentes González
12
portanto, valor basicamente nulo significa que uma variável foi definida explicitamente como (sem valor = nulo) ou foi inicializada e definida como nada. Enquanto indefinido significa. provavelmente nunca foi inicializado ou, se foi, nunca foi definido.
Muhammad Umer
74

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.

ayush
fonte
8
Realmente uma boa resposta. Mas apenas para salientar, quando você marcou "undefined == null", a verificação de tipo não foi rigorosa. Por isso, retornou "true". Se você marcar "undefined === null", ele retornará false.
Wolverine
3
Vale a pena notar que, embora esse comentário fosse verdadeiro em 11, com o advento de parâmetros de função opcionais, o surgimento de sistemas de verificação de tipo como Flow e a difusão de React (todos os quais tratam indefinido e nulo de maneira muito diferente), a velha sabedoria de geralmente usar nulo em vez de indefinido não é mais tão rigoroso. undefined é realmente preferível a null em muitos casos em que você deseja usar explicitamente o valor padrão (por exemplo, para um parâmetro opcional ou um acessório React opcional).
0x24a537r9 15/02
66

Essa é a diferença

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

Sebastian Norr
fonte
1
Você poderia incluir a atribuição da fonte da imagem, por favor?
Vega
1
@Vega Infelizmente não, eu não me lembro de onde eu o peguei em outro lugar do imgur.com e isso provavelmente é de um repost, não da fonte ORIGINAL. Nem mesmo o link incorporado aqui dá alguma pista de quem postou esta versão, então também não posso procurá-la.
Sebastian Norr 18/02
1
ha ha ha ... esta é a melhor explicação que eu já vi! legal!
Akbar Mirsiddikov 01 de
36

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 
Mina Gabriel
fonte
null também é um tipo de dados. Ambos indefinido e nulos são tipos e valores de dados
danwellman
9
nullÉ absolutamente um tipo de dados: msdn.microsoft.com/en-us/library/ie/7wkd9z69(v=vs.94).aspx. O fato de typeof nullretornar objecté um bug bem conhecido e documentado nas versões anteriores do ECMAScript que permanecem com compatibilidade com versões anteriores. O link que você realmente postou no seu comentário diz na metade da página "typeof null // object (erro no ECMAScript, deve ser nulo)"! Então, por favor, mostrar algum esforço de pesquisa antes de comentar sobre down-votos
danwellman
1
As definições contradizem: "ausência de valor" vs "não foi atribuído um valor". Não é o mesmo?
Zon
3
Eu discordo desta resposta. Nulo e indefinido são tipos de dados distintos. null é do tipo null e undefined é do tipo undefined. Somente ao usar um operador de verdade (==) podemos ver que o javascript diz que é verdadeiro, mas uma comparação estrita (===) produz um falso.
precisa saber é
19

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.

Dmitry Sychov
fonte
25
var a = {}; a.n = undefined;' then ..a.hasOwnProperty ( 'n') == true` ... assim dizendo ausência de si mesma variável não é correto mais
Muhammad Umer
17

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 
}
Arup Hore
fonte
12

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

Kevin
fonte
11

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

BERGUIGA Mohamed Amine
fonte
9

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
Chris
fonte
9

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).

RG
fonte
8

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.

Bruno Lesieur
fonte
7

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.

Richard H
fonte
2
É importante notar que while undefinedpode significar que uma variável não foi declarada, mas não garante isso. Uma variável pode ser declarada como var thing;e será igual a undefined.
Yura
6

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 ]
Ray Toal
fonte
Melhor resposta! A maioria das respostas ignora o fato de que você pode definir o valor de uma variável comoundefined , como no let supervisor = undefinedcaso.
J. Bruni
Obrigado e sim, o equívoco de que algo é undefinedapenas se não foi declarado ou ainda não recebeu um valor é tão desenfreado e é realmente difícil comunicar com as pessoas (embora eu continue tentando). Então, muitas pessoas lixo JavaScript para ter tanto nulle undefined, mas estes valores não têm significados completamente distintos e, na maior parte, eles funcionam bem com seus significados pretendidos (IMHO, é claro).
Ray Toal
5

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'

dinesh_malhotra
fonte
Symbol é um novo tipo primitivo :)
Alexander Mills
4

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();
zangw
fonte
4

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.

Shivank Verma
fonte
3

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.

Praveen
fonte
1
Object.prototype.toString.call(null); // "[object Null]"
Paul S.
3

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

bholben
fonte
3

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

Sohail Arif
fonte
3

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.

Nulo e Indefinido

Alireza
fonte
2

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).

Srinivas Kothuri
fonte
2

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.

pousada
fonte
2

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)

RBT
fonte
1
undefined='bar'realmente não atribui nenhum valor undefined(imutável), apenas não gera um erro confuso.
Dmitri Zaitsev
1

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.

Empilhados
fonte
Esta resposta é enganosa ... veja a discussão na resposta aceita. Bottom line - null==undefinedé trueapenas por causa da conversão implícita (ou o termo equivalente em JS). Evidentemente, null===undefinedé falseporque usar quando você o usa ===também compara o tipo .
guyarad
1

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

Zaid Khan
fonte
1

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.

Sandip Nirmal
fonte
1

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:

Felicidades!

Leonid Titov
fonte
1
Com isso, aprendi realmente os isNaN(null)retornos false- o que me surpreendeu.
J. Bruni
0

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
Avid Programmer
fonte
0

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"
Valeriy Katkov
fonte
-2

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.

NavyaKumar
fonte