Por que nulo é um objeto e qual a diferença entre nulo e indefinido?

Por que é nullconsiderado umobject em JavaScript?

Está verificando

if ( object == null )
      Do something

o mesmo que

if ( !object )
      Do something

?

E também:

Qual é a diferença entre nulle undefined?

(name is undefined)

Você: O que é name? ^(*)
JavaScript name :? O que é um name? Não sei do que você está falando. Você nunca mencionou isso nameantes. Você está vendo alguma outra linguagem de script no lado (cliente)?

name = null;

Você: O que é name?
JavaScript: não sei.

Em resumo; undefinedé onde não existe noção da coisa; não tem tipo e nunca foi mencionado anteriormente nesse escopo; nullé onde a coisa é conhecida por existir, mas não se sabe qual é o valor.

Uma coisa a lembrar é que nullnão é, conceitualmente, o mesmo que falseou aquilo , mesmo que sejam iguais ""após a conversão do tipo, ou seja,

name = false;

Você: O que é name?
JavaScript: booleano falso.

name = '';

Você: O que é name?
JavaScript: String vazia

^{*: nameneste contexto, entende-se como uma variável que nunca foi definida. Pode ser qualquer variável indefinida, no entanto, name é uma propriedade de praticamente qualquer elemento de formulário HTML. Vai muito, muito tempo atrás e foi instituído bem antes do id. É útil porque os IDs devem ser exclusivos, mas os nomes não precisam ser.}

A diferença pode ser resumida neste snippet:

alert(typeof(null));      // object
alert(typeof(undefined)); // undefined

alert(null !== undefined) //true
alert(null == undefined)  //true

Verificando

object == nullé diferente de verificar if ( !object ).

Este último é igual a ! Boolean(object), porque o unário! operador converte automaticamente o operando certo em um Booleano.

Desde Boolean(null)igual a falso então !false === true.

Portanto, se seu objeto não for nulo , mas falso ou 0 ou "" , a verificação será aprovada porque:

alert(Boolean(null)) //false
alert(Boolean(0))    //false
alert(Boolean(""))   //false

nullnão é um objeto , é um valor primitivo . Por exemplo, você não pode adicionar propriedades a ele. Às vezes, as pessoas assumem erroneamente que é um objeto, porque typeof nullretorna "object". Mas isso é realmente um bug (que pode até ser corrigido no ECMAScript 6).

A diferença entre nulle undefinedé a seguinte:

• undefined: usado por JavaScript e significa "sem valor". Variáveis ​​não inicializadas, parâmetros ausentes e variáveis ​​desconhecidas têm esse valor.

  > var noValueYet;
  > console.log(noValueYet);
  undefined
  
  > function foo(x) { console.log(x) }
  > foo()
  undefined
  
  > var obj = {};
  > console.log(obj.unknownProperty)
  undefined

  Acessar variáveis ​​desconhecidas, no entanto, produz uma exceção:

  > unknownVariable
  ReferenceError: unknownVariable is not defined

• null: usado pelos programadores para indicar “sem valor”, por exemplo, como parâmetro para uma função.

Examinando uma variável:

console.log(typeof unknownVariable === "undefined"); // true

var foo;
console.log(typeof foo === "undefined"); // true
console.log(foo === undefined); // true

var bar = null;
console.log(bar === null); // true

Como regra geral, você sempre deve usar === e nunca == no JavaScript (== executa todos os tipos de conversões que podem produzir resultados inesperados). A verificação x == nullé um caso delicado, porque funciona para ambos nulle undefined:

> null == null
true
> undefined == null
true

Uma maneira comum de verificar se uma variável tem um valor é convertê-la em booleano e verificar se é true. Essa conversão é realizada pela ifinstrução e pelo operador booleano! ("não").

function foo(param) {
    if (param) {
        // ...
    }
}
function foo(param) {
    if (! param) param = "abc";
}
function foo(param) {
    // || returns first operand that can't be converted to false
    param = param || "abc";
}

Desvantagem dessa abordagem: Todos os valores a seguir são avaliados false, então você deve ter cuidado (por exemplo, as verificações acima não podem distinguir entre undefinede 0).

• undefined, null
• Booleanos: false
• Números: +0, -0,NaN
• Cordas: ""

Você pode testar a conversão em booleano usando Booleancomo uma função (normalmente é um construtor, para ser usado com new):

> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true

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

Uma propriedade quando não possui definição é indefinida. null é um objeto. Seu tipo é objeto. null é um valor especial que significa "nenhum valor. undefined não é um objeto, seu tipo é indefinido.

Você pode declarar uma variável, defini-la como nula e o comportamento é idêntico, exceto que você verá "nulo" impresso versus "indefinido". Você pode até comparar uma variável indefinida como nula ou vice-versa, e a condição será verdadeira:

 undefined == null
 null == undefined

Consulte Diferença de JavaScript entre nulo e indefinido para obter mais detalhes.

e com sua nova edição sim

if (object == null)  does mean the same  if(!object)

ao testar se o objeto é falso, ambos apenas atendem à condição ao testar se falso , mas não quando verdadeiro

Verifique aqui: Pegcha Javascript

Primeira parte da pergunta:

Por que null é considerado um objeto em JavaScript?

É um erro de design do JavaScript que eles não podem corrigir agora. Deveria ter sido do tipo nulo, não do tipo objeto, ou não possuir nenhum. Requer uma verificação extra (às vezes esquecida) ao detectar objetos reais e é fonte de bugs.

Segunda parte da pergunta:

Está verificando


if (object == null)
Do something

o mesmo que

if (!object)
Do something

As duas verificações são sempre falsas, exceto:

• O objeto é indefinido ou nulo: ambos são verdadeiros.

• O objeto é primitivo e 0, ""ou falso: primeiro verifica falso, segundo verdadeiro.

Se o objeto não é um primitivo, mas um objeto real, como new Number(0), new String(""), ou new Boolean(false), então ambas as verificações são falsas.

Portanto, se 'objeto' for interpretado como um Objeto real, as duas verificações serão sempre as mesmas. Se primitivas forem permitidas, as verificações serão diferentes para 0 "", e false.

Em casos como esse object==null, os resultados não óbvios podem ser uma fonte de erros. O uso de ==nunca é recomendado, use em ===vez disso.

Terceira parte da pergunta:

E também:

Qual é a diferença entre nulo e indefinido?

No JavaScript, uma diferença é que nulo é do tipo objeto e indefinido é do tipo indefinido.

Em JavaScript, null==undefinedé verdadeiro e considerado igual se o tipo for ignorado. Por que eles decidiram isso, mas 0 ""e falso não são iguais, eu não sei. Parece ser uma opinião arbitrária.

Em JavaScript, isso null===undefinednão é verdade, pois o tipo deve ser o mesmo ===.

Na realidade, nulo e indefinido são idênticos, pois ambos representam a inexistência. O mesmo acontece com 0, e ""também nesse caso, e talvez nos contêineres vazios []e {}. Muitos tipos do mesmo nada são uma receita para bugs. Um tipo ou nenhum é melhor. Eu tentaria usar o mínimo possível.

'false', 'true' e '!' Há outro pacote de worms que pode ser simplificado, por exemplo, if(!x)e por if(x)si só são suficientes, você não precisa de verdadeiro e falso.

Um declarado var xé do tipo indefinido se nenhum valor for fornecido, mas deve ser o mesmo que se x nunca foi declarado. Outra fonte de erro é um contêiner vazio. Portanto, é melhor declarar e defini-lo juntos, como var x=1.

As pessoas estão girando e girando em círculos tentando descobrir todos esses tipos diferentes de nada, mas é tudo a mesma coisa em roupas diferentes e complicadas. A realidade é

undefined===undeclared===null===0===""===[]==={}===nothing

E talvez todos devam lançar exceções.

var x = null;

x é definido como nulo

y não está definido; // porque eu não o defini

if (!x)

nulo é avaliado como falso

Uma maneira de entender nulo e indefinido é entender onde cada um ocorre.

Espere um valor de retorno nulo nas seguintes situações:

• Métodos que consultam o DOM

  console.log(window.document.getElementById("nonExistentElement"));
  //Prints: null

• Respostas JSON recebidas de uma solicitação Ajax

    {
      name: "Bob",
      address: null
    }

• RegEx.exec .

• Nova funcionalidade que está em um estado de fluxo. O seguinte retorna nulo:

        var proto = Object.getPrototypeOf(Object.getPrototypeOf({}));

       // But this returns undefined:

        Object.getOwnPropertyDescriptor({}, "a");

Todos os outros casos de inexistência são denotados por indefinidos (conforme observado por @Axel). Cada uma das seguintes impressões é "indefinida":

    var uninitalised;
    console.log(uninitalised);

    var obj = {};
    console.log(obj.nonExistent);

    function missingParam(missing){
        console.log(missing);
    }

    missingParam();

    var arr = [];
    console.log(arr.pop());        

Obviamente, se você decidir escrever var unitialised = null; ou retorne nulo de um método, você terá nulos ocorrendo em outras situações. Mas isso deve ser bastante óbvio.

Um terceiro caso é quando você deseja acessar uma variável, mas nem sabe se ela foi declarada. Nesse caso, use typeof para evitar um erro de referência:

if(typeof unknown !== "undefined"){
    //use unknown
}

Em resumo, verifique se há nulo ao manipular o DOM, lidar com o Ajax ou usar determinados recursos do ECMAScript 5. Para todos os outros casos, é seguro verificar indefinidamente com igualdade estrita:

if(value === undefined){
  // stuff
}

Comparação de muitas verificações nulas diferentes no JavaScript:

http://jsfiddle.net/aaronhoffman/DdRHB/5/

// Variables to test
var myNull = null;
var myObject = {};
var myStringEmpty = "";
var myStringWhiteSpace = " ";
var myStringHello = "hello";
var myIntZero = 0;
var myIntOne = 1;
var myBoolTrue = true;
var myBoolFalse = false;
var myUndefined;

...trim...

http://aaron-hoffman.blogspot.com/2013/04/javascript-null-checking-undefined-and.html

nulo e indefinido são falsos para igualdade de valor (nulo == indefinido): ambos são recolhidos para booleano false. Eles não são o mesmo objeto (nulo! == indefinido).

undefined é uma propriedade do objeto global ("janela" nos navegadores), mas é um tipo primitivo e não um objeto em si. É o valor padrão para variáveis ​​e funções não inicializadas que terminam sem uma declaração de retorno.

null é uma instância de Object. null é usado para métodos DOM que retornam objetos de coleção para indicar um resultado vazio, que fornece um valor falso sem indicar um erro.

Algumas precisões:

nulo e indefinido são dois valores diferentes. Um representa a ausência de um valor para um nome e o outro representa a ausência de um nome.

O que acontece de uma maneira ifé a seguinte if( o ):

A expressão entre parênteses o é avaliada e, em seguida, ifinicia-se a coação do valor da expressão entre parênteses - no nosso caso o.

Os valores de falsidade (que serão coagidos a falsos) no JavaScript são: '', nulo, indefinido, 0 e falso .

Para adicionar à resposta de Qual é a diferença entre undefinedenull , no JavaScript Definitive Guide 6th Edition, p.41 nesta página :

Você pode considerar undefineda nullausência de valor no nível do sistema, inesperada ou semelhante a erro e representar a ausência de valor no nível do programa, normal ou prevista. Se você precisar atribuir um desses valores a uma variável ou propriedade ou passar um desses valores para uma função, nullé quase sempre a escolha certa.

nullé um objeto. Seu tipo é nulo. undefinednão é um objeto; seu tipo é indefinido.

A função a seguir mostra por que e é capaz de resolver a diferença:

function test() {
        var myObj = {};
        console.log(myObj.myProperty);
        myObj.myProperty = null;
        console.log(myObj.myProperty);
}

Se você ligar

test();

Você está recebendo

Indefinido

nulo

As primeiras console.log(...)tentativas para obter myPropertya partir myObjenquanto ele ainda não está definida - por isso, recebe de volta "indefinido". Depois de atribuir nulo a ele, o segundo console.log(...)retorna obviamente "nulo" porque myPropertyexiste, mas tem o valornull atribuído a ele.

Para poder consultar essa diferença, o JavaScript tem nulle undefined: Enquanto nullé - assim como em outros idiomas, um objeto undefinednão pode ser um objeto porque não há instância (mesmo que não seja uma nullinstância) disponível.

Por exemplo window.someWeirdProperty é indefinido, então

"window.someWeirdProperty === null" avalia como falso enquanto

"window.someWeirdProperty === undefined" avalia como verdadeiro.

Além disso checkif if (!o)não é o mesmo que a verificação if (o == null)para oser false.

A outra coisa divertida sobre o nulo, em comparação com o indefinido, é que ele pode ser incrementado.

x = undefined
x++
y = null
y++
console.log(x) // NaN
console.log(y) // 0

Isso é útil para definir valores numéricos padrão para contadores. Quantas vezes você definiu uma variável para -1 em sua declaração?

Em Javascript null não é um objecttipo, é umprimitave tipo.

Qual é a diferença? Indefinido refere-se a um ponteiro que não foi definido. Nulo refere-se ao ponteiro nulo, por exemplo, algo definiu manualmente uma variável para ser do tiponull

Veja isso:

   <script>
function f(a){
  alert(typeof(a));
  if (a==null) alert('null');
  a?alert(true):alert(false);
}
</script>
                                          //return:
<button onclick="f()">nothing</button>    //undefined    null    false
<button onclick="f(null)">null</button>   //object       null    false
<button onclick="f('')">empty</button>    //string               false
<button onclick="f(0)">zero</button>      //number               false
<button onclick="f(1)">int</button>       //number               true
<button onclick="f('x')">str</button>     //string               true

De "Os Princípios do Javascript Orientado a Objetos", de Nicholas C. Zakas

Mas por que um objeto quando o tipo é nulo? (De fato, isso foi reconhecido como um erro pelo TC39, o comitê que cria e mantém o JavaScript. Você pode considerar que nulo é um ponteiro de objeto vazio, tornando o "objeto" um valor de retorno lógico, mas isso ainda é confuso.)

Zakas, Nicholas C. (07-02-2014). Os princípios do JavaScript orientado a objetos (Locais 226-227 do Kindle). Sem Starch Press. Edição Kindle.

Dito isto:

var game = null; //typeof(game) is "object"

game.score = 100;//null is not an object, what the heck!?
game instanceof Object; //false, so it's not an instance but it's type is object
//let's make this primitive variable an object;
game = {}; 
typeof(game);//it is an object
game instanceof Object; //true, yay!!!
game.score = 100;

Caso indefinido:

var score; //at this point 'score' is undefined
typeof(score); //'undefined'
var score.player = "felix"; //'undefined' is not an object
score instanceof Object; //false, oh I already knew that.

A melhor maneira de pensar em 'nulo' é lembrar como o conceito semelhante é usado nos bancos de dados, onde indica que um campo não contém "nenhum valor".

• Sim, o valor do item é conhecido; ele é 'definido'. Ele tem sido inicializado.
• O valor do item é: "não há valor".

Essa é uma técnica muito útil para escrever programas que são mais facilmente depurados. Uma variável 'indefinida' pode ser o resultado de um bug ... (como você saberia?) ... mas se a variável contiver o valor 'null', você saberá que "alguém, em algum lugar deste programa, defina-o como 'null.' "Portanto, sugiro que, quando você precisar se livrar do valor de uma variável, não" exclua "... defina-o como 'null.' O valor antigo ficará órfão e em breve será coletado do lixo; o novo valor é "não há valor (agora)". Nos dois casos, o estado da variável é certo: "obviamente, deliberadamente, foi assim".

1. Indefinido significa que uma variável foi declarada, mas não foi atribuído nenhum valor, enquanto Null pode ser atribuído a uma variável que representa "nenhum valor" (Null é um operador de atribuição)

Indefinido é um tipo em si, enquanto Nulo é um objeto.

3.Javascript pode inicializar qualquer variável não atribuída como indefinida, mas nunca pode definir o valor de uma variável como nulo. Isso deve ser feito programaticamente.