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


866

¿Por qué se nullconsidera un objecten JavaScript?

Está comprobando

if ( object == null )
      Do something

lo mismo que

if ( !object )
      Do something

?

Y también:

¿Cuál es la diferencia entre nully undefined?


66
Sería genial si la última pregunta se agrega en el título. Las respuestas aquí son impresionantes, pero el título puede no indicar que encontrará esta respuesta aquí
Marcos.borunda

66
¡Nulo no es un objeto en JavaScript! typeof null === 'object'pero eso es un error! Aquí hay un enlace Mira todos los videos y disfruta :)
CDR

1
Me gusta usar C / C ++ como la verdad axiomática de lo que es una variable indefinida y de valor NULL, ya que es muy sencillo. Luego vea cómo esas definiciones se comparan con las especificaciones de otros idiomas.
samis

Respuestas:


1488
(name is undefined)

Tu: ¿Qué es name? (*)
JavaScript name :? ¿Qué es un name? No sé de qué estás hablando. Nunca has mencionado ninguno nameantes. ¿Ves algún otro lenguaje de script en el lado (cliente)?

name = null;

Tu: ¿Qué es name?
JavaScript: no lo sé.

En breve; undefinedes donde no existe la noción de la cosa; no tiene ningún tipo, y nunca se ha mencionado antes en ese ámbito; nulles donde se sabe que existe, pero no se sabe cuál es el valor.

Una cosa para recordar es que null, conceptualmente, no es igual falseo similar "", incluso si se equiparan después de la conversión de tipos, es decir

name = false;

Tu: ¿Qué es name?
JavaScript: booleano falso.

name = '';

Tu: ¿Qué es name?
JavaScript: cadena vacía


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


14
Pero en JavaScript, la cadena vacía '' sigue siendo un booleano falso.
Andreas Grech

117
La cadena vacía no es booleana falsa, pero en el contexto de un condicional se interpreta como un valor falso (y) (coerción).
Bryan Matthews

22
Para el segundo caso, donde name = null, en lugar de 'No sé', JavaScript podría responder: El objeto nulo. Aparte de eso, me gusta el estilo de la respuesta.
Jean Vincent

16
En lugar de "No sé", diría que la respuesta nulles "nada". Nulo se define con precisión como sin valor. Vacío, nada, nada. Nada.
mikl

50
Me encanta ese estilo de respuesta. En general, "Nunca has mencionado ninguno name antes" es cierto. Sin embargo, declarar una variable sin asignarle un valor ( var somevar;), sorprendentemente resultará en undefined.
MC Emperor

142

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 == nullEs diferente verificar if ( !object ).

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

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

Entonces, si su objeto no es nulo , sino falso o 0 o "" , la verificación pasará porque:

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

@kentaromiura Para nosotros novatos de Javascript ... tal vez solo yo ... ¿cuál es esta sintaxis booleana (valor)? Casting a un booleano?
xr280xr

@ xr280xr Sí, es casting. Intenta String(null)ver otro ejemplo de casting. Incluso puedes hacer cosas tontas como Number(null + 2)... pero no deberías :-). Excelente respuesta de kentaromiura.
squidbe

Recordar typeofes un operador. No envolverías el operando entre paréntesis por la misma razón que no escribirías var sum = 1 +(1);.
alex

124

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

La diferencia entre nully undefinedes la siguiente:

  • 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
    

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

    > unknownVariable
    ReferenceError: unknownVariable is not defined
    
  • null: utilizado por los programadores para indicar "sin valor", 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 == nulles un caso límite, porque funciona para ambos nully undefined:

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

Una forma común de verificar si una variable tiene un valor es convertirla a booleana y ver si es true. ¡Esa conversión es realizada por la ifdeclaració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";
}

Inconveniente de este enfoque: se evalúan todos los siguientes valores false, por lo que debe tener cuidado (por ejemplo, las comprobaciones anteriores no pueden distinguir entre undefinedy 0).

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

Puede probar la conversión a booleana utilizando Booleancomo 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

1
¿Por qué referencia +0y por -0separado si +0 === -0?
Raynos

66
Probablemente porque todavía se puede distinguir +0y -0: 1/+0 !== 1/-0.
neo

1
Esta respuesta se vincula a una publicación que se vincula a esta respuesta como fuente ... probablemente significó vincular a esto en su lugar 2ality.com/2013/10/typeof-null.html
Ricardo Tomasi

Ah, claro, como en C, donde las declaraciones de variables no inicializadas se consideran indefinidas (las versiones antiguas podrían contener datos de programas anteriores).
samis

55
"Pero eso es realmente un error (que incluso podría corregirse en ECMAScript 6)" - ¿fuente?
Gajus el

26

¿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 "sin valor. undefined no es un objeto, su tipo es undefined.

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

 undefined == null
 null == undefined

Consulte la diferencia de JavaScript entre nulo e indefinido para obtener más detalles.

y con tu nueva edición

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

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

Marque aquí: Javascript tiene


44
Debería usar ===, luego indefinido! == nulo: D
olliej

1
prestar atención a la última parte, es incorrecta ver mi respuesta;)
kentaromiura

66
! object no es lo mismo que "object == null" ... De hecho, son bastante diferentes. ! object devolverá verdadero si su objeto es 0, una cadena vacía, booleana falsa, indefinida o nula.
James

3
¿Es nulo realmente un objeto? El primer enlace que ha proporcionado verifica nulo por typeof, pero typeof (nulo) se evalúa como 'objeto' debido a un error de diseño del lenguaje.
c4il

2
nullNo es un objeto. Eso typeof null == 'object';devuelve verdadero es debido a un error que no se puede corregir en JavaScript (actualmente, pero puede cambiar en el futuro).
Mohamad

21

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 solucionar ahora. Debería haber sido tipo nulo, no tipo objeto, o no tenerlo en absoluto. Necesita una verificación adicional (a veces olvidada) al detectar objetos reales y es fuente de errores.

Segunda parte de la pregunta:

Está comprobando


if (object == null)
Do something

lo mismo que

if (!object)
Do something

Las dos verificaciones son siempre falsas, excepto por:

  • El objeto es indefinido o nulo: ambos verdaderos.

  • object es primitivo, y 0, ""o false: primero verifica falso, segundo verdadero.

Si el objeto no es una primitiva, sino un objeto real, al igual que new Number(0), new String("")o new Boolean(false), a continuación, ambos cheques son falsos.

Entonces, si 'objeto' se interpreta como un Objeto real, ambas verificaciones son siempre iguales. Si se permiten primitivas, las comprobaciones son diferentes para 0 "", y falso.

En casos como object==null, los resultados no obvios 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 undefined.

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

En JavaScript, null===undefinedno 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 haga 0, y ""para el caso también, y tal vez los contenedores vacíos []y {}. Muchos tipos de lo mismo, nada son una receta para los errores. Un tipo o ninguno es mejor. Intentaría usar la menor cantidad posible.

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

Un declarado var xes de tipo indefinido si no se proporciona ningún valor, pero debería ser el mismo que si x nunca se declarara. Otra fuente de error es un contenedor vacío de nada. 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 de nada, pero todo es lo mismo en diferentes prendas complicadas. La realidad es

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

Y tal vez todos deberían lanzar excepciones.


8
Gran respuesta, pero va un poco demasiado lejos con []: " En realidad, nulo e indefinido son idénticos ... y tal vez los contenedores vacíos [] y {} " . Probablemente podría convencerme de que {} debería ser algo sabor de nulo, pero mi impresión es que no debería. Pero de manera menos controvertida, una matriz vacía []tiene una .push()función comprensible , por lo que no hay un buen argumento para que [] sea nulo. $ 0.02.
ruffin

11
var x = null;

x se define como nulo

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

if (!x)

nulo se evalúa como falso


8

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 de Ajax


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

  • Nueva funcionalidad que está 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 inexistencia se denotan por indefinido (como lo señaló @Axel). Cada una de las siguientes impresiones "indefinidas":

    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 decide escribir var unitialised = null; o devuelva 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 se ha declarado. Para ese caso, use typeof para evitar un error de referencia:

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

En resumen, compruebe si hay valores nulos cuando manipula el DOM, trata con Ajax o usa ciertas características de ECMAScript 5. Para todos los demás casos, es seguro verificar si no está definido con igualdad estricta:

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

8

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

Tabla de comparación de cheques nulos de JavaScript


1
hace "var myUndefined"; define la variable (como una variable conocida con tipo desconocido)?
Qi Fan

6

nulo e indefinido son falsos para la igualdad de valores (nulo == indefinido): ambos colapsan a falso booleano. 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í mismo. Es el valor predeterminado para variables no inicializadas y funciones que terminan sin una declaración de retorno.

null es una instancia de Object. nulo se usa para 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.


5

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 ifva de la siguiente manera para if( o ):

Se evalúa la expresión entre paréntesis o, y luego las ifpatadas al coaccionar el valor de la expresión entre paréntesis, en nuestro caso o.

Los valores de falsa (que se convertirán en falsos) en JavaScript son: '', nulo, indefinido, 0 y falso .


5

Para agregar a la respuesta de ¿Cuál es la diferencia entre undefinedynull , de JavaScript Definitive Guide 6th Edition, p.41 en esta página :

Puede considerar undefinedrepresentar nulluna ausencia de valor a nivel de sistema, inesperada o similar a un error y representar la ausencia de valor a nivel de programa, normal o esperada. Si necesita asignar uno de estos valores a una variable o propiedad o pasar uno de estos valores a una función, nulles casi siempre la opción correcta.


3

nullEs un objeto. Su tipo es nulo. undefinedno es un objeto; Su tipo es indefinido.


11
mal - ambos nully undefinedson valores primitivos - typeof null === 'object'es un error de lenguaje, porqueObject(null) !== null
Christoph

No, no es. Object () echó el trabajo de esa manera, ver ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf - 15.2.2.1 new Object ([value]) ... 8. (El valor del argumento no se suministró o su tipo era Nulo o Indefinido.) Cree un nuevo objeto ECMAScript nativo. La propiedad [[Prototype]] del objeto recién construido se establece en el objeto Prototype Object. La propiedad [[Clase]] del objeto recién construido se establece en "Objeto". El objeto recién construido no tiene propiedad [[Value]]. Devuelve el objeto nativo recién creado.
kentaromiura

3
@ Christoph: Quiero decir, tienes razón. null debe ser un tipo, lo que quiero decir es que no puede verificarlo de esa manera porque: alert (new Object ()! == new Object ()); / * verdadero, la nueva istance no es la misma istance / alert (Object (null) .constructor == {} .constructor); / true como en spec / alert (Object (null) .prototype == {} .prototype); / true como en spec / alert (instancia nula de Object); / obviamente falso, nulo significa no instanciado * / Pero básicamente es un error de especificación XD ver: uselesspickles.com/blog/2006/06/12/… y javascript.crockford.com/remedial.html
kentaromiura

2

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();

Te estas poniendo

indefinido

nulo

Los primeros console.log(...)intentos para obtener myPropertya partir de myObjcuando aún no está definido - por lo que vuelve "indefinido". Después de asignarle nulo, el segundo console.log(...)devuelve obviamente "nulo" porque myPropertyexiste, pero tiene el valor nullasignado.

Para poder consultar esta diferencia, JavaScript tiene nully undefined: Mientras nulles, al igual que en otros idiomas, un objeto, undefinedno puede ser un objeto porque no hay una instancia (ni siquiera una nullinstancia) disponible.


2

Por ejemplo window.someWeirdProperty, no está definido, entonces

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

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

Checkif Por otra parte if (!o), no es la misma que la comprobación if (o == null)de oestar false.


¿Puedes explicar la diferencia entre las dos condiciones
Rahul

lea mi respuesta, quiere decir que si o es igual a 0, falso o "" el valor booleano es falso: var undef, varios = [0, "", nulo, falso, undef]; for (var obj en varios) {alert (! obj); // 4 veces falso en IE, 5 en FF;)}
kentaromiura

2

La otra cosa divertida de nulo, en comparación con indefinido, es que se puede incrementar.

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

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


2

En Javascript null no es un objecttipo, es un primitavetipo.

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


2

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

1

De "Los principios de Javascript orientado a objetos" por Nicholas C. Zakas

Pero, ¿por qué un objeto cuando el tipo es nulo? (De hecho, TC39, el comité que diseña y mantiene JavaScript, ha reconocido esto como un error. Podría razonar que 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). No Starch Press. Versión Kindle.

Eso dijo:

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.

1

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

  • Sí, se conoce el valor del artículo; que se 'define'. Se ha inicializado.
  • El valor del artículo es: "no hay 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 en 'nulo'. "Por lo tanto, sugiero que, cuando necesite deshacerse del valor de una variable, no" elimine "... configúrelo en 'nulo'. El valor anterior quedará huérfano y pronto se recolectará basura; el nuevo valor es "no hay valor (ahora)". En ambos casos, el estado de la variable es seguro: "obviamente, de manera deliberada, se puso de esa manera".


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

2. Indefinido es un tipo en sí mismo, mientras que Nulo es un objeto.

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

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.