Pregunta ¿Por qué es nulo un objeto y cuál es la diferencia entre nulo e indefinido?


Por que es null considerado un object en JavaScript?

Está revisando

if ( object == null )
      Do something

lo mismo que

if ( !object )
      Do something

?

Y también:

Cuál es la diferencia entre null y undefined?


819
2018-04-29 05:47


origen


Respuestas:


(name is undefined)

Tú: Que es name? (*)
JavaScript:  name? Qué es un name? No sé de lo que estás hablando. No has mencionado alguna vez name antes de. ¿Estás viendo algún otro lenguaje de scripting en el lado (del cliente)?

name = null;

Tú: Que es name?
JavaScript: No lo sé.

En breve; undefined es donde no existe ninguna noción de la cosa; no tiene ningún tipo y nunca se ha hecho referencia a él en ese ámbito; null es donde se sabe que existe la cosa, pero no se sabe cuál es el valor.

Una cosa para recordar es que null no es, conceptualmente, lo mismo que false o "" o tal, incluso si igualan después del lanzamiento del tipo, es decir

name = false;

Tú: Que es name?
JavaScript: Booleano falso

name = '';

Tú: Que es name?
JavaScript: Cuerda vacía


*: name en este contexto se entiende como una variable que nunca ha sido definida. Podría ser cualquier variable indefinida. Sin embargo, el nombre es una propiedad de casi cualquier elemento de formulario HTML. Va camino, muy atrás y se instituyó mucho antes de la identificación. Es útil porque los identificadores deben ser únicos, pero los nombres no deben serlo.


1439
2018-04-29 13:31



La diferencia se puede resumir en este fragmento:

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

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

Comprobación

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

El último es igual a ! Boolean(object), porque el unario ! el operador automáticamente convierte el operando correcto en un booleano.

Ya que Boolean(null) es igual a falso entonces !false === true.

Entonces, si tu objetivo es no nulo, pero  falso o 0 o "", el cheque pasará porque:

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

137
2018-04-29 06:44



null es no es un objeto, es un valor primitivo. Por ejemplo, no puede agregarle propiedades. A veces las personas asumen erróneamente que es un objeto, porque typeof null devoluciones "object". Pero eso es en realidad un error (que incluso podría corregirse en ECMAScript 6).

La diferencia entre null y undefined es como sigue:

  • undefined: utilizado por JavaScript y significa "sin valor". Las variables no inicializadas, los parámetros faltantes y las variables desconocidas tienen ese valor.

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

    El acceso a variables desconocidas, sin embargo, produce una excepción:

    > unknownVariable
    ReferenceError: unknownVariable is not defined
    
  • null: utilizado por los programadores para indicar "sin valor", p. como un parámetro para una función.

Examinando una variable:

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 regla general, siempre debe usar === y nunca == en JavaScript (== realiza todo tipo de conversiones que puede producir resultados inesperados). El cheque x == null es un caso de borde, porque funciona tanto para null y undefined:

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

Una forma común de verificar si una variable tiene un valor es convertirla a boolean y ver si es true. Esa conversión es realizada por if declaración y el operador booleano! ("no").

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";
}

Desventaja de este enfoque: Todos los siguientes valores se evalúan como false, por lo que debe tener cuidado (por ejemplo, las verificaciones anteriores no pueden distinguir entre undefined y 0)

  • undefined, null
  • Booleanos: false
  • Números: +0, -0, NaN
  • Instrumentos de cuerda: ""

Puede probar la conversión a boolean mediante el uso de Boolean como una función (normalmente es un constructor, para ser utilizado con new)

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

113
2017-11-01 15:06



¿Cuál es la diferencia entre nulo e indefinido?

Una propiedad cuando no tiene definición, no está definida. null es un objeto. Su tipo es objeto. null es un valor especial que significa "sin valor. Indefinido no es un objeto, su tipo no está definido.

Puede declarar una variable, establecerla como nula y el comportamiento es idéntico, excepto que verá impreso "nulo" frente a "indefinido". Incluso puede comparar una variable que no está definida como nula o viceversa, y la condición será verdadera:

 undefined == null
 null == undefined

Referirse a Diferencia de JavaScript entre nulo e indefinido para más detalles.

y con tu nuevo editar 

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

cuando se prueba si el objeto es falso, ambos solo cumplen la condición al probar si falso, pero no cuando es verdad

Chequea aquí: Javascript gotcha


23
2018-04-29 05:52



Primera parte de la pregunta:

¿Por qué null se considera un objeto en JavaScript?

Es un error de diseño de JavaScript que no pueden solucionar ahora. Debería haber sido type null, no type object, o no tenerlo en absoluto. Se necesita un control adicional (a veces olvidado) cuando se detectan objetos reales y es fuente de errores.

Segunda parte de la pregunta:

Está revisando


if (object == null) 
Do something 

  lo mismo que

if (!object) 
Do something 





Los dos controles siempre son ambos falsos excepto por:

  • objeto no definido o nulo: ambos verdaderos.

  • objeto es primitivo, y 0, "", o falso: primero verifique falso, segundo verdadero.

Si el objeto no es primitivo, sino un Objeto real, como new Number(0), new String(""), o new Boolean(false), ambos controles son falsos

Entonces, si 'objeto' se interpreta como un Objeto real, entonces ambos controles son siempre los mismos. Si se permiten las primitivas, las verificaciones son diferentes para 0, ""y falso

En casos como object==null, los resultados no evidentes podrían ser una fuente de errores. Uso de == no se recomienda nunca, use === en lugar.

Tercera parte de la pregunta:

Y también:

  ¿Cuál es la diferencia entre nulo e indefinido?

En JavaScript, una diferencia es que null es de tipo type y undefined es de tipo undefined.

En JavaScript, null==undefined es verdadero y se considera igual si se ignora el tipo. Por qué decidieron eso, pero 0, "" y falso no son iguales, no sé. Parece ser una opinión arbitraria.

En JavaScript, null===undefined no es cierto ya que el tipo debe ser el mismo en ===.

En realidad, nulo e indefinido son idénticos, ya que ambos representan la no existencia. Entonces haz 0 y "" para el caso también, y tal vez los contenedores vacíos [] y {}. Tantos tipos de la misma nada son una receta para los errores. Un tipo o ninguno en absoluto es mejor. Intentaré utilizar el menor número posible.

'falso', 'verdadero' y '!' hay otra bolsa de gusanos que podría simplificarse, por ejemplo, if(!x) y if(x) solo son suficientes, no necesitas verdadero y falso.

A declarado var x es type undefined si no se proporciona ningún valor, pero debería ser el mismo que si nunca se hubiera declarado x. Otra fuente de error es un contenedor de nada vacío. Entonces, es mejor declararlo y definirlo juntos, como var x=1.

La gente da vueltas y vueltas en círculos tratando de descubrir todos estos tipos de nada, pero es exactamente lo mismo en ropa diferente y complicada. La realidad es

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

Y tal vez todos deberían arrojar excepciones.


18
2017-07-14 22:15



var x = null;

x se define como nulo

y no está definido; // porque no lo definí

if (!x)

null se evalúa como falso


10
2018-04-29 05:56



Una forma de dar sentido a lo nulo e indefinido es entender dónde ocurre cada uno.

Espere un valor de retorno nulo en las siguientes situaciones:

  • Métodos que consultan el DOM

    console.log(window.document.getElementById("nonExistentElement"));
    //Prints: null
    
  • Respuestas JSON recibidas de una solicitud Ajax


    {
      name: "Bob",
      address: null
    }
  • RegEx.exec.

  • Nueva funcionalidad que está en un estado de flujo. Lo siguiente devuelve null:


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

       // But this returns undefined:

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

Todos los demás casos de inexistencia se denotan por indefinido (como lo señala @Axel). Cada una de las siguientes impresiones "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());        

Por supuesto, si decides escribir var unitialised = null; o devuelve nulo de un método usted mismo, entonces tiene nulo en otras situaciones. Pero eso debería ser bastante obvio.

Un tercer caso es cuando desea acceder a una variable, pero ni siquiera sabe si ha sido declarada. Para ese caso use typeof para evitar un error de referencia:

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

En resumen, compruebe null cuando manipule el DOM, trate con Ajax o use ciertas características de ECMAScript 5. Para todos los demás casos, es seguro verificar indefinido con estricta igualdad:

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

7
2018-05-07 10:06



Comparación de muchas comprobaciones nulas diferentes en 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

JavaScript Null Check Comparison Chart


7
2018-04-29 15:23