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

Question

Por que é null considerado um object em JavaScript?

está verificando

if ( object == null )
      Do something

o mesmo que

if ( !object )
      Do something

?

E também:

O que é a diferença entre null e undefined?

Answer 1

(name is undefined)

Você: O que é name ^(*)
? JavaScript: name? O que é um name? Eu não sei o que você está falando. Você não já mencionado qualquer name antes. Você está vendo alguma outra linguagem de script do lado (client)?

name = null;

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

Em suma; undefined é onde existe nenhuma noção da coisa; que não tem nenhum tipo, e isso nunca foi mencionado antes nesse âmbito; null é onde a coisa se sabe que existe, mas não se sabe qual é o valor.

Uma coisa a lembrar é que null não é, conceitualmente, o mesmo que false ou "" ou tal, mesmo se eles igualam depois de conversão de tipos, i.

name = false;

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

name = '';

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

---

^{*: name neste contexto se entende como uma variável que nunca foi definida. Poderia ser qualquer variável indefinida, no entanto, o nome é uma propriedade de praticamente qualquer elemento de formulário HTML. Vai muito, caminho de volta e foi instituído bem antes id. É útil porque ids deve ser exclusivo, mas os nomes não tem que ser.}

Answer 2

A diferença pode ser resumida neste trecho:

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

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

Verificar

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

O último é igual a ! Boolean(object), porque o operador ! unário lançar automaticamente o operando para a direita em um valor booleano.

Desde Boolean(null) igual !false === true seguida falsa.

Portanto, se seu objetivo é não nulo , e false ou 0 ou "" , a verificação vai passar porque:

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

Answer 3

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

A diferença entre null e undefined é o seguinte:

• undefined: usada por JavaScript e significa “nenhum valor”. variáveis ??não inicializadas, parâmetros desaparecidas 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
  

  Acessando variáveis ??desconhecidas, no entanto, produz uma exceção:

  > unknownVariable
  ReferenceError: unknownVariable is not defined
  

• null: usado por programadores para indicar “nenhum valor”, por exemplo, como um 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ê deve sempre usar === e nunca == em JavaScript (== executa todos os tipos de conversões que pode produzir resultados inesperados). O x == null cheque é um caso extremo, porque ele funciona tanto para null e undefined:

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

Uma maneira comum de verificar se uma variável tem um valor é para convertê-lo para booleano e ver se é true. Essa conversão é executada pela instrução if eo 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 desta abordagem: Todos os seguintes valores avaliar a false, então você tem que ter cuidado (por exemplo, as verificações acima não pode distinguir entre undefined e 0)

.

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

É possível testar a conversão para booleano usando Boolean como uma função (normalmente é um construtor, para ser usado com new):

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

Answer 4

O que é a diferença entre nulo e indefinido ??

A propriedade quando ele não tem uma definição, é indefinido. nulo é um objecto. Seu tipo é objeto. nulo é um valor especial que significa "nenhum valor. indefinida não é um objeto, seu tipo é indefinido.

Você pode declarar uma variável, defina-o como nulo, e o comportamento é idêntico, exceto que você vai ver "null" impressa versus "indefinida". Você mesmo pode comparar uma variável que não está definido como nulo ou vice-versa, ea condição será verdadeira:

 undefined == null
 null == undefined

Consulte JavaScript diferença entre nulo e indefinido para mais detalhes.

e com o seu novo Editar Sim

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

quando testar se o objeto é falso, ambos só satisfazer a condição de quando o teste se false , mas não quando true

Confira aqui: Javascript pegadinha

Answer 5

A primeira parte da pergunta:

Por que é nula considerada um objeto em JavaScript?

É um erro de projeto JavaScript eles não podem corrigir agora. Deveria ter sido tipo nulo, e não tipo de objeto, ou não tê-lo em tudo. Ele exige uma verificação extra (por vezes esquecido) ao detectar objetos reais e é fonte de bugs.

A segunda parte da pergunta:

está verificando

if (object == null)
Do something

o mesmo que

if (!object)
Do something

Os dois cheques são sempre ambas falsas, exceto para:

• objeto é indefinido ou nulo:. Ambas verdadeiras

• objeto é primitiva, e 0, "", ou falso:. Primeiro falsa verificação, segundo true

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

Então, se 'objeto' é interpretado como um objeto real, em seguida, ambas as verificações são sempre os mesmos. Se primitivos são permitidos em seguida, os cheques são diferentes para 0, "", e falso.

Em casos como object==null, os resultados unobvious poderia ser uma fonte de erros. Uso de == não é recomendado sempre, uso === vez.

Quanto à terceira parte da questão:

E também:

Qual é a diferença entre nulo e indefinido?

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

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

Em JavaScript, null===undefined não é verdade, pois o tipo deve ser o mesmo em ===.

Na realidade, nulos e indefinidos são idênticos, uma vez que ambos representam não-existência. Então faça 0, e "" para que o assunto também, e talvez os recipientes vazios [] e {}. Assim, muitos tipos do mesmo nada são uma receita para bugs. Um tipo ou nenhum é melhor. Gostaria de tentar usar o mínimo possível.

'falso', 'true' e '!' são um outro saco de vermes que poderiam ser simplificados, por exemplo, if(!x) e if(x) sozinhos são suficientes, você não precisa de verdadeiro e falso.

Um declarou var x é tipo indefinido se nenhum valor é dado, mas deve ser o mesmo que se x não foi declarado em tudo. Outra fonte bug é um recipiente nada vazio. Então, é melhor declarar e defini-lo juntos, como var x=1.

As pessoas estão dando voltas e voltas em círculos tentando descobrir todos esses vários tipos de nada, mas é tudo exatamente a mesma coisa com roupas diferentes complicado. A realidade é

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

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

Answer 6

var x = null;

x é definido como nulo

y não é definida; // porque eu não defini-lo

if (!x)

nulo é avaliado como false

Answer 7

Uma maneira de fazer o sentido de nulos e indefinidos é entender onde cada ocorre.

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

• Métodos que consulta o DOM

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

• respostas JSON recebidos de uma solicitação do Ajax

    {
      name: "Bob",
      address: null
    }

• RegEx.exec .

• A nova funcionalidade que está em um estado de fluxo. Os seguintes retorna nulo:

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

       // But this returns undefined:

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

Todos os outros casos de não-existência são indicados por indefinido (como observado por @Axel). Cada um dos seguintes impressões "indefinido":

    var uninitalised;
    console.log(uninitalised);

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

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

    missingParam();

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

É claro que se você decidir escrever var unitialised = null; ou retornar nulo a partir de um método de si mesmo, então você tem nula ocorrendo em outras situações. Mas isso deve ser bastante óbvio.

Um terceiro caso é quando você deseja acessar uma variável, mas você não sabe mesmo se tiver sido declarado. Para que o uso caso typeof para evitar um erro de referência:

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

Na verificação de resumo para nulo quando você está manipulando o DOM, lidar com Ajax, ou usando certos ECMAScript 5 características. Para todos os outros casos é seguro para verificar se há indefinido com igualdade estrita:

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

Answer 8

Comparação de muitas verificações nulos diferentes em 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-nulo-checking-undefined-and.html

Answer 9

null e undefined são ambas falsas para valor igualdade (== null indefinido): ambos colapso para booleano falso. Eles não são o mesmo objeto (null! == indefinido).

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

nulo é uma instância de objeto. null é usado para métodos DOM que a coleta de retorno objetos para indicar um resultado vazio, o que proporciona um valor falso sem indicar um erro.

Answer 10

Algumas precisões:

null e undefined são dois valores diferentes. Um está representando a ausência de um valor para um nome e o outro está representando a ausência de um nome.

---

O que acontece em uma if é o seguinte para if( o ):

A expressão entre parênteses o é avaliada, e então os if nos chutes tipo coagir o valor da expressão entre parênteses -. No nosso caso o

Falsas (que vai ser coagido a falsa) valores em JavaScript são: '', null, indefinido, 0, e false .

Answer 11

Para adicionar a resposta de Qual é o differrence entre undefined e null , a partir de JavaScript Definitive Guia desta página :

Você pode considerar undefined para representar sistema de nível, inesperado, ou erro semelhante absense de valor e null para representar em nível de programa, ausência normal, ou esperado de valor. Se você precisa de um atribuir de esses valores para uma variável ou propriedade ou passar um desses valores para uma função, null é quase sempre a escolha certa.

Answer 12

A seguir mostra funções por que e é capaz de trabalhar fora a diferença:

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

Se você chamar

test();

Você está recebendo

indefinido

nulo

As primeiras tentativas console.log(...) para obter myProperty de myObj enquanto ele ainda não está definida - por isso, recebe de volta "indefinido". Depois de atribuir nulo para ele, o segundo console.log(...) retornos obviamente "nulo" porque myProperty existe, mas tem a null valor atribuído a ele.

De modo a ser capaz de consultar esta diferença, JavaScript tem null e undefined: Enquanto null é - assim como em outros idiomas um objeto, undefined pode não ser um objeto porque não há nenhuma instância (ainda não uma instância null) disponível.

Answer 13

null é um objeto. Seu tipo é nulo. undefined não é um objecto; seu tipo é indefinido.

Answer 14

Por exemplo window.someWeirdProperty é indefinido, então

avalia "window.someWeirdProperty === null" false enquanto

avalia "window.someWeirdProperty === undefined" a verdade.

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

Answer 15

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

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

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

Answer 16

Em Javascript null não é um tipo object é um tipo primitave.

Qual é a diferença? Undefined refere-se a um ponteiro que não foi definido. nulo refere-se ao ponteiro nulo por exemplo algo definiu manualmente uma variável a ser do tipo null

Answer 17

Olhe para isto:

   <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

Answer 18

De "Os Princípios de Javascript Object-Oriented" por Nicholas C. Zákas

Mas por um objeto quando o tipo é nulo? (Na verdade, esta tem sido reconhecida como um erro por TC39, a comissão de que os projetos e mantém JavaScript. Você poderia argumentar que nulo é um ponteiro de objeto vazio, fazendo "objeto" um valor de retorno lógico, mas que ainda é confuso.)

Zákas, Nicholas C. (2014/02/07). Os Princípios de Orientação a Objetos JavaScript (Kindle Locais 226-227). No Starch Press. Kindle Edition.

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.

Answer 19

A melhor maneira de pensar sobre 'null' é recordar como o conceito semelhante é usado em bancos de dados, onde se indica que um campo contém "nenhum valor".

• Sim, o valor do item é conhecido; it é 'definido'. É tem foi inicializado.
• O valor do artigo é: "não há nenhum valor"

Esta é uma técnica muito útil para escrever programas que são mais-facilmente depurado. Uma variável 'indefinido' pode ser o resultado de um erro ... (como você sabe?) ... mas se a variável contém o valor 'null', você sabe que "alguém, em algum lugar neste programa, defini-lo para 'null'." Portanto, sugiro que, quando você precisa para se livrar do valor de uma variável, não 'delete' ... configurá-lo para 'nulo.' O valor antigo será órfãs e em breve será coleta de lixo; o novo valor é, "não há nenhum valor (agora)." Em ambos os casos, o estado da variável é certa: "obviamente, deliberadamente, só ficaram assim."

Answer 20

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

2.Undefined é um tipo em si, enquanto Null é um objeto.

3.Javascript pode-se inicializar qualquer variável não atribuída a indefinido, mas ele nunca pode definir o valor de uma variável para null. Isto tem que ser feito através de programação.