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

StackOverflow https://stackoverflow.com/questions/801032

Pregunta

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

Está comprobando 

if ( object == null )
      Do something

lo mismo que 

if ( !object )
      Do something

?

Y también:

¿Cuál es la diferencia entre null y undefined ?

¿Fue útil?

Solución 

(name is undefined)

Usted: ¿Qué es name ? (*)
JavaScript: nombre ? ¿Qué es un nombre ? No sé de qué estás hablando. Nunca has mencionado ningún nombre antes. ¿Está viendo algún otro lenguaje de scripting en el lado (cliente)? ??

name = null;

Usted: ¿Qué es el nombre ?
JavaScript: No lo sé.

En resumen; undefined es donde no existe una noción de la cosa; no tiene ningún tipo, y nunca se ha mencionado antes 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 algo así, incluso si se equiparan después del tipo de casting, es decir, 

name = false;

Usted: ¿Qué es el nombre ?
JavaScript: Booleano falso. 

name = '';

Usted: ¿Qué es el nombre ?
JavaScript: cadena vacía

*: name en este contexto se entiende como una variable que nunca se ha definido. Podría ser cualquier variable no definida, sin embargo, nombre es una propiedad de casi cualquier elemento de formulario HTML. Va camino, hace mucho tiempo y fue instituido mucho antes de la identificación. Es útil porque los identificadores deben ser únicos pero los nombres no tienen que ser.

Otros consejos

La diferencia se puede resumir en este fragmento: 

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

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

Comprobando

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

¡Este último es igual a ! Booleano (objeto) , porque el operador unario ! convierte automáticamente el operando correcto en un Booleano.

Dado que Boolean (nulo) es falso, entonces ! false === true .

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

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

null es no es un objeto , es un valor primitivo . Por ejemplo, no puede agregarle propiedades. A veces la gente asume erróneamente que es un objeto, porque typeof null devuelve " object " . Pero eso es en realidad un error (que incluso podría ser arreglado en ECMAScript 6).

La diferencia entre null y undefined es la siguiente:

  • no definido : utilizado por JavaScript y significa & # 8220; sin valor & # 8221 ;. Las variables no inicializadas, los parámetros que faltan 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

    Sin embargo, acceder a variables desconocidas produce una excepción: 

    > unknownVariable
ReferenceError: unknownVariable is not defined

  • null : utilizado por los programadores para indicar & # 8220; ningún valor & # 8221 ;, por ejemplo. como parámetro de 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 pueden producir resultados inesperados). El cheque x == null es un caso de borde, porque funciona tanto para null como undefined : 

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

Una forma común de verificar si una variable tiene un valor es convertirla en boolean y ver si es true . Esa conversión se realiza mediante la declaración if y el operador booleano. (& # 8220; no & # 8221;). 

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

Inconveniente de este enfoque: todos los valores siguientes se evalúan como false , por lo que debe tener cuidado (por ejemplo, las verificaciones anteriores no pueden & # 8217; t distinguir entre undefined y 0 ).

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

Puede probar la conversión a booleano utilizando Boolean como una función (normalmente es un constructor, que se usará con new ): 

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

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

Una propiedad cuando no tiene definición, no está definida. nulo es un objeto. Su tipo es objeto. nulo es un valor especial que significa " ningún valor. undefined no es un objeto, su tipo no está definido.

Puedes declarar una variable, establecerla en nula, y el comportamiento es idéntico, excepto que verás " null " Impreso frente a " indefinido " ;. Incluso puede comparar una variable que no esté definida a nula o viceversa, y la condición será verdadera: 

 undefined == null
 null == undefined

Consulte para más detalles.

y con tu nueva edición sí 

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

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

Marque aquí: Javascript gotcha

Primera parte de la pregunta:

  

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

Es un error de diseño de JavaScript que no pueden arreglar ahora. Debería haber sido de tipo nulo, no de tipo objeto o no tenerlo en absoluto. Necesita una comprobación adicional (a veces olvidada) al detectar objetos reales y es fuente de errores.

Segunda parte de la pregunta:

  

está comprobando
  

   if (object == null)
   Haz algo
  
  lo mismo que
  
   if (! object)
   Haz algo

Las dos comprobaciones siempre son falsas, excepto por:

  • el objeto no está definido o es nulo: ambos son verdaderos.

  • el objeto es primitivo, y 0, " " , o false: primer cheque falso, segundo verdadero.

Si el objeto no es un objeto primitivo, sino real, como new Number (0) , new String (" ") , o nuevo booleano (falso) , entonces ambas comprobaciones son falsas.

Entonces, si se interpreta que 'objeto' significa un objeto real, entonces ambas comprobaciones son siempre las mismas. Si se permiten primitivas, las comprobaciones son diferentes para 0, " " , y false.

En casos como object == null , los resultados no evidentes podrían ser una fuente de errores. El uso de == no se recomienda nunca, use === en su 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 objeto y undefined es de tipo indefinido.

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

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

En realidad, nulo e indefinido son idénticos, ya que ambos representan la no existencia. También lo hacen 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ía usar la menor cantidad posible.

'falso', 'verdadero' y '!' son otra bolsa de gusanos que podría simplificarse, por ejemplo, si (! x) y si (x) solo son suficientes, no es necesario que sea verdadero o falso.

Un var x declarado es de tipo indefinido si no se proporciona un 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. Por lo tanto, 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 diferentes de nada, pero todo es exactamente lo mismo en prendas diferentes y complicadas. La realidad es 

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

Y tal vez todos deberían lanzar excepciones. 

var x = null;

x se define como nulo

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

if (!x)

null se evalúa como falso

Una forma de dar sentido a 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 se encuentra en un estado de flujo. Lo siguiente devuelve nulo: 


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

       // But this returns undefined:

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

Todos los demás casos de no existencia se denotan como indefinidos (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 devuelva el valor nulo de un método usted mismo, entonces tendrá un valor 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 se ha declarado. En ese caso, use typeof para evitar un error de referencia: 

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

En resumen, compruebe si está nulo cuando está manipulando el DOM, tratando con Ajax o usando ciertas características de ECMAScript 5. Para todos los demás casos, es seguro verificar que no esté definido con igualdad estricta: 

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

Comparación de muchos cheques nulos 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

Cuadro de comparación de verificación nula de JavaScript

null y undefined son falsos para la igualdad de valores (null == undefined): ambos se colapsan a boolean false. No son el mismo objeto (nulo! == indefinido).

undefined es una propiedad del objeto global (" ventana " en los navegadores), pero es un tipo primitivo y no un objeto en sí. Es el valor predeterminado para las variables y las funciones sin inicializar que finalizan sin una declaración de retorno.

null es una instancia de Object. null se usa para los métodos DOM que devuelven objetos de colección para indicar un resultado vacío, lo que proporciona un valor falso sin indicar un error.

Algunas precisiones:

nulo e indefinido son dos valores diferentes. Uno representa la ausencia de un valor para un nombre y el otro representa la ausencia de un nombre.

Lo que sucede en un si es el siguiente para if (o) :

La expresión en los paréntesis o se evalúa, y luego el si patea el tipo de la expresión entre paréntesis, en nuestro caso o .

Los valores de

Falsía (que se verán obligados a falsos) en JavaScript son: '', nulo, no definido, 0 y falso .

Para agregar a la respuesta de ¿Cuál es la diferencia entre undefined y null , de la Guía definitiva de JavaScript en esta página :

  

Puede considerar que undefined representa a nivel de sistema, inesperado,   o una falta de valor similar a un error y null para representar el nivel del programa,   Ausencia normal, o esperada de valor. Si necesita asignar uno de   estos valores a una variable o propiedad o pasan uno de estos valores a   una función, null es casi siempre la opción correcta.

La siguiente función muestra por qué y es capaz de resolver la diferencia: 

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

Si llamas 

test();

Estás recibiendo

  

indefinido

     

nulo

El primer console.log (...) intenta obtener myProperty de myObj mientras aún no está definido, por lo que obtiene Atrás " indefinido " ;. Después de asignarle un valor nulo, el segundo console.log (...) devuelve obviamente " null " porque myProperty existe, pero tiene el valor null asignado.

Para poder consultar esta diferencia, JavaScript tiene null y undefined : mientras que null es como en otros idiomas, object, undefined no puede ser un objeto porque no hay ninguna instancia (incluso no hay una instancia de null ) disponible.

null es un objeto. Su tipo es nulo. undefined no es un objeto; su tipo no está definido.

Por ejemplo, window.someWeirdProperty no está definido, por lo que

" window.someWeirdProperty === null " se evalúa como falso mientras que

" window.someWeirdProperty === undefined " se evalúa como verdadero.

Además, compruebe que if (! o) no es lo mismo que verificar if (o == null) para o siendo falso .

La otra cosa divertida sobre null, en comparación con undefined, es que puede incrementarse. 

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

Esto es útil para configurar valores numéricos predeterminados para contadores. ¿Cuántas veces has establecido una variable en -1 en su declaración?

En Javascript null no es un tipo de objeto es un tipo de primitave .

¿Cuál es la diferencia? Sin definir se refiere a un puntero que no se ha establecido. Nulo se refiere al puntero nulo, por ejemplo, algo ha establecido manualmente una variable para que sea de tipo null

Mira esto: 

   <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 " Los principios de Javascript orientado a objetos " por Nicholas C. Zakas

  

¿Pero por qué un objeto cuando el tipo es nulo? (De hecho, esto ha sido reconocido como un error por TC39, el comité que diseña y mantiene JavaScript. Podría razonar que el valor nulo es un puntero de objeto vacío, lo que hace que "objeto" sea un valor de retorno lógico, pero eso sigue siendo confuso.)

Zakas, Nicholas C. (2014-02-07). Los principios de JavaScript orientado a objetos (ubicaciones de Kindle 226-227). Sin prensa de almidón. Versión Kindle.

Dicho esto: 

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.

La mejor manera de pensar en 'nulo' es recordar cómo se utiliza el concepto similar en las bases de datos, donde indica que un campo no contiene ningún valor. "

  • Sí, el valor del elemento es conocido; está 'definido'. Se se ha inicializado .
  • El valor del elemento es: " no hay ningún valor. "

Esta es una técnica muy útil para escribir programas que se depuran más fácilmente. Una variable 'indefinida' podría ser el resultado de un error ... (¿cómo lo sabrías?) ... pero si la variable contiene el valor 'nulo', sabes que " alguien, En algún lugar de este programa, configúralo como 'nulo'. " Por lo tanto, sugiero que, cuando necesite deshacerse del valor de una variable, no " elimine " ... póngalo en 'nulo'. El valor anterior quedará huérfano y pronto se recogerá la basura; el nuevo valor es, " no hay ningún valor (ahora). " En ambos casos, el estado de la variable es cierto: " obviamente, deliberadamente, se obtuvo de esa manera. & Quot;

  1. No definido significa que una variable ha sido declarada pero no se le ha asignado ningún valor, mientras que Null se puede asignar a una variable que representa " ningún valor " (Null es un operador de asignación)

2.Undefined es un tipo en sí mismo, mientras que Null es un objeto.

3.Javascript puede inicializar cualquier variable no asignada a undefined pero nunca puede establecer el valor de una variable en nulo. Esto tiene que hacerse programáticamente.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top