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

Quiero saber cual es la diferencia entre null y undefined en JavaScript.

preguntado el 22 de febrero de 11 a las 07:02

Siempre pense: null ¿Lo pones en vacío? undefined está vacío porque no se ha configurado. O null está vacío a propósito, mientras que undefined todavía está vacío. Básicamente, muestra intención. -

Yaya. Ver por ti mismo. console.log (nulo-indefinido). La diferencia entre nulo e indefinido es NaN. (Tenga en cuenta que esto es un intento de humor, antes de que me llame por no haber entendido bien la pregunta).

30 Respuestas

En JavaScript undefined significa que se ha declarado una variable pero aún no se le ha asignado un valor, como por ejemplo:

var testVar;
alert(testVar); //shows undefined
alert(typeof testVar); //shows undefined

null es un valor de asignación. Se puede asignar a una variable como una representación sin valor:

var testVar = null;
alert(testVar); //shows null
alert(typeof testVar); //shows object

De los ejemplos anteriores, queda claro que undefined y null son dos tipos distintos: undefined es un tipo en sí mismo (indefinido) mientras que null Es un objeto.

null === undefined // false
null == undefined // true
null === null // true

y

null = 'value' // ReferenceError
undefined = 'value' // 'value'

respondido 21 mar '21, 11:03

Cita del libro Professional JS For Web Developers (Wrox): "Es posible que se pregunte por qué el operador typeof devuelve 'objeto' para un valor que es nulo. Esto fue en realidad un error en la implementación original de JavaScript que luego se copió en ECMAScript. Hoy , se racionaliza que null se considera un marcador de posición para un objeto, aunque, técnicamente, es un valor primitivo ". - Capitán Sensible

la variable bien podría no estar definida en absoluto. por ejemplo: console.log (typeof (abc)); indefinido - Nir O.

El comentario de Nir O. es muy importante. Si quiero tener una variable que no tenga valor al principio, escribo "... = null", por ejemplo, "myvar = null". De esta manera, cuando escribo mal "if (myxar == null) {...}", el bloque if no se ejecuta. No tengo esta ventaja con undefined: myvar = undefined; myvar = 4; if (typeof myxar == "undefined") {...} - Wolfgang Adamec

@Wolfgang Adamec, la programación sin errores no se trata de errores de escritura. - Jorge Fuentes Gonzalez

entonces, básicamente, el valor nulo significa que una variable se ha establecido explícitamente como (sin valor = nulo) o se ha inicializado y definido como nada. Mientras que medios indefinidos. probablemente nunca se inicializó o, si lo fue, nunca se definió. - Muhammad Umer

Esta es la diferencia

(agregando caracteres debido a la falta de caracteres, por lo que puedo publicar esto).

Respondido 29 Jul 19, 09:07

¿Podría incluir la atribución de la fuente de la imagen, por favor? - Vega

@Vega Desafortunadamente, no, no recuerdo de dónde lo obtuve más que en imgur.com y probablemente sea de un repost, no de la fuente ORIGINAL. Ni siquiera el enlace incrustado aquí da ninguna pista de quién publicó esta versión, por lo que tampoco puedo buscarla. - Sebastián Norr

ja ja ja ... esta es la mejor explicación que jamás he visto! ¡frio! - Akbar Mirsiddikov

@SebastianNorr "No recuerdo de dónde lo saqué más que en imgur.com" -> así es undefined or null ¿en ese caso? - Erowlin

let toiletPaperIn2020 = undefined; - Lluvia

Elegí esto de aquí

El valor indefinido es un valor primitivo que se utiliza cuando a una variable no se le ha asignado un valor.

El valor nulo es un valor primitivo que representa la referencia nula, vacía o inexistente.

Cuando declaras una variable a través de var y no le das un valor, tendrá el valor indefinido. Por sí mismo, si intenta WScript.Echo () o alert () este valor, no verá nada. Sin embargo, si le agregas una cadena en blanco, de repente aparecerá:

var s;
WScript.Echo(s);
WScript.Echo("" + s);

Puede declarar una variable, establecerla en nula y el comportamiento es idéntico, excepto que verá "nulo" impreso frente a "indefinido". De hecho, esta es una pequeña diferencia.

Incluso puede comparar una variable que no está definida con nula o viceversa, y la condición será verdadera:

undefined == null
null == undefined

Sin embargo, se consideran dos tipos diferentes. Si bien undefined es un tipo en sí mismo, null se considera un valor de objeto especial. Puede ver esto usando typeof () que devuelve una cadena que representa el tipo general de una variable:

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

La ejecución de la secuencia de comandos anterior dará como resultado la siguiente salida:

undefined
object

Independientemente de que sean de diferentes tipos, seguirán actuando de la misma manera si intenta acceder a un miembro de cualquiera de ellos, por ejemplo, es decir, lanzarán una excepción. Con WSH verá el temido "'varname' es nulo o no es un objeto" y eso es si tiene suerte (pero ese es un tema para otro artículo).

Puede establecer explícitamente una variable para que no esté definida, pero le recomiendo encarecidamente que no lo haga. Recomiendo solo configurar las variables en nulo y dejar indefinido el valor de las cosas que olvidó configurar. Al mismo tiempo, te animo a que siempre establezcas todas las variables. JavaScript tiene una cadena de alcance diferente a la de los lenguajes de estilo C, lo que confunde fácilmente incluso a los programadores veteranos, y establecer las variables en nulo es la mejor manera de evitar errores basados ​​en él.

Otra instancia en la que verá una ventana emergente indefinida es cuando utilice el operador de eliminación. Aquellos de nosotros de un mundo C podríamos interpretar incorrectamente esto como destruir un objeto, pero no es así. Lo que hace esta operación es eliminar un subíndice de una matriz o un miembro de un objeto. Para las matrices, no afecta la longitud, sino que el subíndice ahora se considera indefinido.

var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);

El resultado del script anterior es:

0.) a
1.) undefined
2.) c

También obtendrá una devolución de indefinido al leer un subíndice o miembro que nunca existió.

La diferencia entre nulo e indefinido es: JavaScript nunca establecerá nada en nulo, eso es lo que generalmente hacemos. Si bien podemos establecer variables como indefinidas, preferimos nulas porque no es algo que se haga por nosotros. Cuando está depurando, esto significa que todo lo que se establezca en nulo es obra suya y no de JavaScript. Más allá de eso, estos dos valores especiales son casi equivalentes.

respondido 14 mar '17, 04:03

Realmente una buena respuesta. Pero solo para señalar, cuando marcó "undefined == null", la verificación de tipos no fue estricta. Por lo tanto, devolvió "verdadero". Si marca "undefined === null", devolverá falso. - glotón

Vale la pena señalar que si bien este comentario fue cierto en el '11, con el advenimiento de los parámetros de función opcionales, la aparición de sistemas de verificación de tipo como Flow y la omnipresencia de React (todos los cuales tratan lo indefinido y nulo de manera muy diferente), la vieja sabiduría de generalmente, el uso de nulo en lugar de indefinido ya no es tan estricto. undefined es en realidad preferible a nulo en muchos casos en los que desea utilizar explícitamente el valor predeterminado (por ejemplo, para un parámetro opcional o una prop React opcional). - 0x24a537r9

nulo es una palabra clave especial que indica ausencia de valor.

Piense en ello como un valor, como:

  • "foo" es una cadena,
  • verdadero es booleano,
  • 1234 es el número,
  • null no está definido.

indefinido La propiedad indica que a una variable no se le ha asignado un valor que incluya nulo también. Como

var foo;

la variable vacía definida es null de tipo de datos undefined


Ambos representan un valor de una variable sin valor

Y DE null no representa un cadena que no tiene valor - cadena vacía-


Me gusta

var a = ''; 
console.log(typeof a); // string 
console.log(a == null); //false 
console.log(a == undefined); // false 

Ahora bien, si

var a;
console.log(a == null); //true
console.log(a == undefined); //true 

PERO

var a; 
console.log(a === null); //false 
console.log(a === undefined); // true

SO cada uno tiene su propia forma de usar

indefinido utilícelo para comparar el tipo de datos de la variable

nulo utilícelo para vaciar un valor de una variable

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

Respondido 21 Oct 14, 14:10

null también es un tipo de datos. Tanto undefined como null son tipos de datos y valores: danwellman

null Absolutamente ES un tipo de datos: msdn.microsoft.com/en-us/library/ie/7wkd9z69(v=vs.94).aspx. El hecho de que typeof null devoluciones object es un error bien conocido y documentado en las primeras versiones de ECMAScript que se ha mantenido por compatibilidad con versiones anteriores. El enlace que en realidad publicado en su comentario dice en la mitad de la página "tipo de objeto nulo // (error en ECMAScript, debería ser nulo)". Así que, por favor, muestre un esfuerzo de búsqueda antes de comentar sobre los votos negativos: danwellman

Las definiciones contradicen: "ausencia de valor" vs "no se le ha asignado un valor". ¿No es lo mismo? - Zon

No estoy de acuerdo con esta respuesta. Nulo e indefinido son tipos de datos distintos. null es de tipo null y undefined es de tipo undefined. Solo cuando usamos un operador veraz (==) podemos ver que javascript dice que es verdadero, pero una comparación estricta (===) produce un falso. - alaboudi

Lea atentamente lo siguiente. Debería eliminar todas sus dudas con respecto a la diferencia entre null y undefined en JavaScript. Además, puede usar la función de utilidad al final de esta respuesta para obtener tipos de variables más específicos.

En JavaScript podemos tener los siguientes tipos de variables:

  1. Variables no declaradas
  2. Variables declaradas pero no asignadas
  3. Variables asignadas con literal undefined
  4. Variables asignadas con literal null
  5. Variables asignadas con cualquier otra cosa que no sea undefined or null

A continuación se explica cada uno de estos casos uno por uno:

  1. Variables no declaradas

    • Solo se puede comprobar con el typeof operador que devuelve una cadena 'indefinido'
    • No se puede comprobar con el operador de igualdad flexible ( == undefined ), y mucho menos el operador de igualdad estricta ( === undefined ),
      al igual que declaraciones-if y operadores ternarios ( ? : ) - estos arrojan errores de referencia
  2. Variables declaradas pero no asignadas

    • typeof devuelve cadena 'indefinido'
    • == Comprobar con null devoluciones true
    • == Comprobar con undefined devoluciones true
    • === Comprobar con null devoluciones false
    • === Comprobar con undefined devoluciones true
    • Is falsedad a declaraciones-if y operadores ternarios ( ? : )
  3. Variables asignadas con literal undefined
    Estas variables se tratan exactamente igual que Variables declaradas pero no asignadas.

  4. Variables asignadas con literal null

    • typeof devuelve cadena 'objeto'
    • == Comprobar con null devoluciones true
    • == Comprobar con undefined devoluciones true
    • === Comprobar con null devoluciones true
    • === Comprobar con undefined devoluciones false
    • Is falsedad a declaraciones-if y operadores ternarios ( ? : )
  5. Variables asignadas con cualquier otra cosa que no sea undefined or null

    • typeof devuelve una de las siguientes cadenas: 'Empezando', 'booleano', 'función', 'número', 'objeto', 'cuerda', 'símbolo'

A continuación se proporciona el algoritmo para la verificación de tipo correcta de una variable:

  1. Consiguir el typeof nuestra variable y devolverla si no lo es 'objeto'
  2. Comprueba si hay null, ya que typeof null devoluciones 'objeto' así como
  3. Evaluar Object.prototype.toString.call (o) con una instrucción de cambio para devolver un valor más preciso. Object's toString El método devuelve cadenas que se parecen a '[nombre del constructor del objeto]' para objetos nativos / host. Para todos los demás objetos (objetos definidos por el usuario), siempre devuelve '[objeto Objeto]'
  4. Si esa última parte es el caso (la versión en cadena de la variable es '[objeto Objeto]') y el parámetro returnConstructorBooleano is true, intentará obtener el nombre del constructor por toString-haciéndolo y extrayendo el nombre de allí. Si no se puede contactar al constructor, 'objeto' se devuelve como de costumbre. Si la cadena no contiene su nombre, 'anónimo' es devuelto

(admite todos los tipos hasta ECMAScript 2020)

function TypeOf(o, returnConstructorBoolean) {
  const type = typeof o

  if (type !== 'object') return type
  if (o === null)        return 'null'

  const toString = Object.prototype.toString.call(o)

  switch (toString) {
    // Value types: 6
    case '[object BigInt]':            return 'bigint'
    case '[object Boolean]':           return 'boolean'
    case '[object Date]':              return 'date'
    case '[object Number]':            return 'number'
    case '[object String]':            return 'string'
    case '[object Symbol]':            return 'symbol'

    // Error types: 7
    case '[object Error]':             return 'error'
    case '[object EvalError]':         return 'evalerror'
    case '[object RangeError]':        return 'rangeerror'
    case '[object ReferenceError]':    return 'referenceerror'
    case '[object SyntaxError]':       return 'syntaxerror'
    case '[object TypeError]':         return 'typeerror'
    case '[object URIError]':          return 'urierror'

    // Indexed Collection and Helper types: 13
    case '[object Array]':             return 'array'
    case '[object Int8Array]':         return 'int8array'
    case '[object Uint8Array]':        return 'uint8array'
    case '[object Uint8ClampedArray]': return 'uint8clampedarray'
    case '[object Int16Array]':        return 'int16array'
    case '[object Uint16Array]':       return 'uint16array'
    case '[object Int32Array]':        return 'int32array'
    case '[object Uint32Array]':       return 'uint32array'
    case '[object Float32Array]':      return 'float32array'
    case '[object Float64Array]':      return 'float64array'
    case '[object ArrayBuffer]':       return 'arraybuffer'
    case '[object SharedArrayBuffer]': return 'sharedarraybuffer'
    case '[object DataView]':          return 'dataview'

    // Keyed Collection types: 2
    case '[object Map]':               return 'map'
    case '[object WeakMap]':           return 'weakmap'

    // Set types: 2
    case '[object Set]':               return 'set'
    case '[object WeakSet]':           return 'weakset'

    // Operation types: 3
    case '[object RegExp]':            return 'regexp'
    case '[object Proxy]':             return 'proxy'
    case '[object Promise]':           return 'promise'

    // Plain objects
    case '[object Object]':
      if (!returnConstructorBoolean)
        return type

      const _prototype = Object.getPrototypeOf(o)
      if (!_prototype)              
        return type

      const _constructor = _prototype.constructor
      if (!_constructor)            
        return type

      const matches = Function.prototype.toString.call(_constructor).match(/^function\s*([^\s(]+)/)
        return matches ? matches[1] : 'anonymous'

    default: return toString.split(' ')[1].slice(0, -1)
  }
}

Respondido el 05 de enero de 21 a las 05:01

nulo: ausencia de valor para una variable; indefinido: ausencia de la propia variable;

..donde variable es un nombre simbólico asociado con un valor.

JS podría tener la amabilidad de iniciar implícitamente las variables recién declaradas con nulo, pero no es así.

Respondido el 04 de Septiembre de 14 a las 16:09

var a = {}; a.n = undefined;' then ..a.hasOwnProperty ('n') == true` ... diciendo eso ausencia de variable en sí ya no es correcto - Muhammad Umer

Esa es una definición muy concisa, pero no es realmente precisa, por la razón que da. Una variable definida comienza con el valor undefined. - Steve Bennett

Puede considerar indefinido para representar una ausencia de valor a nivel de sistema, inesperada o similar a un error y nulo para representar una ausencia de valor a nivel de programa, normal o esperada.

a través de JavaScript: la guía definitiva

Respondido el 29 de junio de 14 a las 09:06

Realmente me gusta esta descripción. - Arad

Esto es lo que creo que también voy a usar. Si recibo un nulo, sé que el valor se estableció en nulo a propósito - stevenfowler16

Lo explicaré undefined, null y Uncaught ReferenceError:

1 - Uncaught ReferenceError : variable no ha sido declarado en su guión, no hay ninguna referencia a esta variable
2 - undefined: Variable declarada pero no inicializada
3 - null : Variable declarada y es un valor vacío

Respondido 18 Feb 16, 10:02

nulo y indefinido son dos tipos de objetos distintos que tienen lo siguiente en común:

  • ambos solo pueden tener un valor único, nulo y indefinido respectivement;
  • ambos no tienen propiedades o métodos y un intento de leer las propiedades de cualquiera resultará en un error en tiempo de ejecución (para todos los demás objetos, obtienes valor indefinido si intenta leer una propiedad inexistente);
  • valores nulo y indefinido se consideran iguales entre sí y nada más por == y != operadores.

Sin embargo, las similitudes terminan aquí. Por una vez, existe una diferencia fundamental en la forma en que las palabras clave nulo y indefinido son implementados. Esto no es obvio, pero considere el siguiente ejemplo:

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

indefinido, Yaya y Infinity son solo nombres de variables "superglobales" preinicializadas; se inicializan en tiempo de ejecución y pueden ser reemplazadas por una variable global o local normal con los mismos nombres.

Ahora, intentemos lo mismo con nulo:

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

Ups! nulo, verdadero y false son palabras clave reservadas: el compilador no le permitirá usarlas como nombres de variables o propiedades

Otra diferencia es que indefinido es un tipo primitivo, mientras que nulo es un tipo de objeto (que indica la ausencia de una referencia de objeto). Considera lo siguiente:

WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object

Además, hay una diferencia importante en la forma nulo y indefinido se tratan en contexto numérico:

var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1

var b = null; // the value null must be explicitly assigned 
WScript.Echo(b === null); // Prints: -1

WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)

WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)

WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)

WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)

nulo se convierte en 0 cuando se usa en expresiones aritméticas o comparaciones numéricas, de manera similar a false, es básicamente un tipo especial de "cero". indefinido, por otro lado, es un verdadero "nada" y se convierte en Yaya ("no es un número") cuando intenta utilizarlo en un contexto numérico.

Tenga en cuenta que nulo y indefinido recibir un trato especial de == y != operadores, pero puede probar la verdadera igualdad numérica de a y b con la expresión (a >= b && a <= b).

Respondido el 18 de diciembre de 16 a las 12:12

Indefinido significa que se ha declarado una variable pero no tiene valor:

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

Nulo es una asignación:

var var2= null;
alert(var2); //null
alert(typeof var2); //object

Respondido 22 Feb 11, 10:02

null es un valor especial que significa "sin valor". null es un objeto especial porque typeof null devuelve 'objeto'.

Por otra parte, undefined significa que la variable no ha sido declarada o no se le ha dado un valor.

Respondido el 04 de Septiembre de 18 a las 22:09

Es importante tener en cuenta que, si bien undefined puede significar que una variable no ha sido declarada, pero no garantiza eso. Una variable se puede declarar como var thing; y será igual a undefined. - Yura

tl; dr

Utiliza la null para establecer una variable, sabes que es un Objeto.

Utiliza la undefined para establecer una variable cuyo tipo sea mixto.


Este es mi uso de las 5 primitivas y el tipo de objeto, y eso explica la diferencia entre el «caso de uso» de undefined or null.

Cordón

Si sabe que una variable es solo una cadena mientras todo el ciclo de vida, por convención, puede inicializarla, para "":

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

Número

Si sabe que una variable es solo un número durante todo el ciclo de vida, por convención, puede inicializarla para 0 (o NaN if 0 es un valor importante en su uso):

(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"

or

(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"

Boolean

Si sabe que una variable es solo un booleano mientras que todo el ciclo de vida, por convención, puede inicializarla, para false:

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

Objeto

Si sabe que una variable es solo un Objeto mientras todo el ciclo de vida, por convención, puede inicializarla, para null:

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

Nota: el uso inteligente de nulo debe ser el falsedad versión de un objeto porque un objeto siempre es true, y porqué typeof null retorno object. Eso significa typeof myVarObject devuelve un valor coherente tanto para el objeto como para el tipo nulo.

Todos

Si sabe que una variable tiene un tipo mixto (cualquier tipo durante todo el ciclo de vida), por convención, puede inicializarla para undefined.

respondido 17 mar '17, 10:03

La mejor manera de comprender la diferencia es primero despejar su mente del funcionamiento interno de JavaScript y simplemente comprender las diferencias de significado entre:

let supervisor = "None"
    // I have a supervisor named "None"

let supervisor = null
    // I do NOT have a supervisor. It is a FACT that I do not.

let supervisor = undefined
    // I may or may not have a supervisor. I either don't know
    // if I do or not, or I am choosing not to tell you. It is
    // irrelevant or none of your business.

Hay una diferencia de significado entre estos tres casos, y JavaScript distingue los dos últimos casos con dos valores diferentes, null y undefined. Eres libre de usar esos valores explícitamente para transmitir esos significados.

Entonces, ¿cuáles son algunos de los problemas específicos de JavaScript que surgen debido a esta base filosófica?

  1. Una variable declarada sin un inicializador obtiene el valor undefined porque nunca dijiste nada sobre cuál era el valor pretendido.

    let supervisor;
    assert(supervisor === undefined);
    
  2. Una propiedad de un objeto que nunca se ha establecido se evalúa como undefined porque nadie dijo nada sobre esa propiedad.

    const dog = { name: 'Sparky', age: 2 };
    assert(dog.breed === undefined);
    
  3. null y undefined son "similares" entre sí porque Brendan Eich lo dijo. Pero enfáticamente no son iguales entre sí.

    assert(null == undefined);
    assert(null !== undefined);
    
  4. null y undefined afortunadamente tienen diferentes tipos. null pertenece al tipo Null y undefined al tipo Undefined. Esto está en la especificación, pero nunca lo sabría debido a la typeof rareza que no repetiré aquí.

  5. Una función que llega al final de su cuerpo sin una declaración de retorno explícita devuelve undefined ya que no sabes nada de lo que devolvió.

Por cierto, hay otras formas de "nada" en JavaScript (es bueno haber estudiado Filosofía ...)

  • NaN
  • Usando una variable que nunca ha sido declarada y recibiendo un ReferenceError
  • El uso de un let or const variable local definida en su zona muerta temporal y recibiendo una ReferenceError
  • Celdas vacías en matrices dispersas. Si, estos ni siquiera son undefined aunque comparan === a indefinido.

    $ node
    > const a = [1, undefined, 2]
    > const b = [1, , 2]
    > a
    [ 1, undefined, 2 ]
    > b
    [ 1, <1 empty item>, 2 ]
    

Respondido el 21 de Septiembre de 18 a las 18:09

¡La mejor respuesta! La mayoría de las respuestas ignoran el hecho de que puede definir el valor de una variable como undefinedcomo en el let supervisor = undefined caso. - J. Bruni

Gracias, y sí, esa idea errónea de que algo es undefined solo si no se ha declarado o aún no se le ha dado un valor es tan desenfrenado y es realmente difícil de comunicar a la gente (aunque sigo intentándolo). Mucha gente tira JavaScript por tener ambos null y undefined pero estos valores do tienen significados completamente distintos y en su mayor parte funcionan bien con sus significados previstos (en mi humilde opinión, por supuesto). - rayo toal

En JavasSript hay 5 tipos de datos primitivos String, Number, Boolean, null e undefined. Intentaré explicarlo con un simple ejemplo.

digamos que tenemos una función simple

 function test(a) {

     if(a == null){
        alert("a is null");
     } else {
        alert("The value of a is " + a);
     }
  }

también en la función anterior si (a == nulo) es igual que si (! a)

ahora cuando llamamos a esta función sin pasar el parámetro a

   test(); it will alert "a is null";
   test(4); it will alert "The value of a is " + 4;

Además,

var a;
alert(typeof a); 

esto dará indefinido; hemos declarado una variable pero no hemos asignado ningún valor a esta variable; pero si escribimos

var a = null;
alert(typeof a); will give alert as object

por lo que nulo es un objeto. de alguna manera le hemos asignado un valor nulo a 'a'

Respondido 18 Feb 14, 18:02

El símbolo es un nuevo tipo primitivo :) - Alexander Mills

Cuando declaras una variable en javascript, se le asigna el valor undefined. Esto significa que la variable no se modifica y se le puede asignar cualquier valor en el futuro. También implica que no conoce el valor que tendrá esta variable en el momento de la declaración.

Ahora puede asignar explícitamente una variable null. Significa que la variable no tiene ningún valor. Por ejemplo, algunas personas no tienen un segundo nombre. Entonces, en tal caso, es mejor asignar el valor nulo a la variable de nombre medio de un objeto persona.

Ahora suponga que alguien está accediendo a la variable de segundo nombre de su objeto person y tiene el valor undefined. No sabría si el desarrollador olvidó inicializar esta variable o si no tenía ningún valor. Si tiene el valor null, entonces el usuario puede inferir fácilmente que el segundo nombre no tiene ningún valor y no es una variable intacta.

Respondido 07 Oct 17, 11:10

Bien, podemos confundirnos cuando nos enteramos null y undefined, pero comencemos de manera simple, ambos son falsedad y similares en muchos sentidos, pero una parte extraña de JavaScript, hacen que sean un par de diferencias significativas, por ejemplo, tipo de null is 'object' mientras tipo de undefined is 'undefined'.

typeof null; //"object"
typeof undefined; //"undefined";

Pero si los revisas con == como abajo, ves que ambos son falsedad:

null==undefined; //true

También puedes asignar null a una propiedad de objeto oa una primitiva, mientras que undefined simplemente se puede lograr no asignando nada.

Creo una imagen rápida para mostrarte las diferencias de un vistazo.

Nulo e indefinido

Respondido el 31 de enero de 19 a las 11:01

Para el undefined type, hay uno y solo un valor: undefined.

Para el null type, hay uno y solo un valor: null.

Así que para ambos la etiqueta es tanto su tipo como su valor.

La diferencia entre ellos. Por ejemplo:

  • null es un valor vacío
  • undefined es un valor faltante

o:

  • undefined aún no ha tenido un valor
  • null tenía un valor y ya no

En realidad, null es un palabra clave especial, no un identificador y, por lo tanto, no puede tratarlo como una variable para asignar.

Sin embargo, undefined es un identificador. En ambos non-strict el modo y strict modo, sin embargo, puede crear una variable local con el nombre indefinido. ¡Pero esta es una idea terrible!

function foo() {
    undefined = 2; // bad idea!
}

foo();

function foo() {
    "use strict";
    undefined = 2; // TypeError!
}

foo();

Respondido el 25 de diciembre de 15 a las 08:12

nulo e indefinido se utilizan para representar la ausencia de algún valor.

var a = null;

a se inicializa y define.

typeof(a)
//object

null es un objeto en JavaScript

Object.prototype.toString.call(a) // [object Object]

var b;

b no está definido ni inicializado

las propiedades de objeto indefinidas también están indefinidas. Por ejemplo, "x" no está definida en el objeto cy si intenta acceder a cx, devolverá undefined.

Generalmente asignamos nulos a variables no indefinidas.

Respondido 19 Jul 14, 15:07

Object.prototype.toString.call(null); // "[object Null]" - Paul s.

Según el completo artículo de Ryan Morr sobre este tema ...

"Generalmente, si necesita asignar un valor sin valor a una variable o propiedad, pasarlo a una función o devolverlo desde una función, null es casi siempre la mejor opción. En pocas palabras, JavaScript usa undefined y los programadores deberían utilizar nulo ".

Ver Explorando el abismo eterno de lo nulo y lo indefinido

respondido 07 nov., 15:21

Tanto Null como undefined en JavaScript indican ausencia de valor.

var a = null; //variable assigned null value
var b;  // undefined

A pesar de que ambos existen por ausencia de valor, pero: Indefinido en realidad significa que la variable no está inicializada. Funciones que no devuelven nada y parámetros de función para los que no se proporciona ningún valor, se devuelve un valor indefinido. Utilice el operador de igualdad estricta === para distinguir entre nulo e indefinido.

Referencia: http://www.thesstech.com/javascript/null-and-undefined

respondido 16 mar '16, 18:03

En javascript, todas las variables se almacenan como pares clave-valor. Cada variable se almacena como nombre_variable: valor_variable / referencia.

indefinido significa que a una variable se le ha dado un espacio en la memoria, pero no se le asigna ningún valor. Como práctica recomendada, no debe utilizar este tipo como tarea.

En ese caso, ¿cómo denotar cuándo desea que una variable no tenga valor en un punto posterior del código? Puedes usar el tipo nulo , que también es un tipo que se usa para definir lo mismo, ausencia de un valor, pero no es lo mismo que indefinido, ya que en este caso realmente tienes el valor en la memoria. Ese valor es nulo

Ambos son similares, pero el uso y el significado son diferentes.

Respondido el 14 de enero de 17 a las 03:01

Quiero agregar una diferencia muy sutil entre null y undefined lo cual es bueno saber cuando está tratando de aprender Vanilla JavaScript (JS) desde cero:

  • null es una palabra clave reservada en JS mientras undefined es una variable en el objeto global del entorno de tiempo de ejecución en el que se encuentra.

Al escribir código, esta diferencia no es identificable ya que ambos null y undefined siempre se utilizan en RHS de una declaración de JavaScript. Pero cuando los usa en LHS de una expresión, puede observar esta diferencia fácilmente. Entonces, el intérprete de JS interpreta el siguiente código como error:

var null = 'foo'

Da el siguiente error:

Error de sintaxis no detectado: token nulo inesperado

Si bien el siguiente código se ejecuta correctamente, no recomendaré hacerlo en la vida real:

var undefined = 'bar'

Esto funciona porque undefined es una variable en el objeto global (objeto de la ventana del navegador en el caso de JS del lado del cliente)

Respondido 01 Jul 19, 03:07

undefined='bar' realmente no asigna ningún valor a undefined (que es inmutable), simplemente no arroja un error de manera confusa. - Dmitri Zaitsev

Además de un significado diferente, existen otras diferencias:

  1. Desestructuración de objetos funciona de manera diferente para estos dos valores:
    const { a = "default" } = { a: undefined }; // a is "default"
    const { b = "default" } = { b: null };      // b is null
    
  2. JSON.stringify () mantiene null pero omite undefined
    const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
    console.log(json); // prints {"nullValue":null}
    
  3. tipo de operador
    console.log(typeof undefined); // "undefined"
    console.log(typeof null);      // "object" instead of "null"
    

contestado el 28 de mayo de 20 a las 17:05

Como typeof devuelve undefined, undefined es un tipo en el que null es un inicializador que indica que la variable no apunta a ningún objeto (prácticamente todo en Javascript es un objeto).

Respondido 06 ago 12, 06:08

Mira esto. La salida vale mil palabras.

var b1 = document.getElementById("b1");

checkif("1, no argument"                        );
checkif("2, undefined explicitly",     undefined);
checkif("3, null explicitly",               null);
checkif("4, the 0",                            0);
checkif("5, empty string",                    '');
checkif("6, string",                    "string");
checkif("7, number",                      123456);

function checkif (a1, a2) {
	print("\ncheckif(), " + a1 + ":");
	if (a2 == undefined) {
		print("==undefined:    YES");
	} else {
		print("==undefined:    NO");
	}
	if (a2 === undefined) {
		print("===undefined:   YES");
	} else {
		print("===undefined:   NO");
	}
	if (a2 == null) {
		print("==null:         YES");
	} else {
		print("==null:         NO");
	}
	if (a2 === null) {
		print("===null:        YES");
	} else {
		print("===null:        NO");
	}
	if (a2 == '') {
		print("=='':           YES");
	} else {
		print("=='':           NO");
	}
	if (a2 === '') {
		print("==='':          YES");
	} else {
		print("==='':          NO");
	}
	if (isNaN(a2)) {
		print("isNaN():        YES");
	} else {
		print("isNaN():        NO");
	}
	if (a2) {
		print("if-?:           YES");
	} else {
		print("if-?:           NO");
	}
		print("typeof():       " + typeof(a2));
}

function print(v) {
	b1.innerHTML += v + "\n";
}
<!DOCTYPE html>
<html>
<body>
<pre id="b1"></pre>
</body>
</html>

Ver también:

¡Aclamaciones!

Respondido 19 Feb 20, 10:02

De esto realmente aprendí que isNaN(null) devoluciones false - lo que me sorprendió. - J. Bruni

La diferencia entre los undefined y null es mínimo, pero hay una diferencia. Una variable cuyo valor es undefined nunca se ha inicializado. Una variable cuyo valor es null se le dio explícitamente un valor de null, lo que significa que la variable se estableció explícitamente para que no tuviera valor. Si comparas undefined y null mediante el uso de la null==undefined expresión, serán iguales.

Respondido 07 ago 15, 20:08

Esta respuesta es engañosa ... vea la discusión en la respuesta aceptada. Línea de fondo - null==undefined is true solo por la conversión implícita (o el término equivalente en JS). Evidentemente, null===undefined is false porque usar cuando usas === compara el tipo también. - Chico

Básicamente, Indefinido es una variable global que javascript crea en el tiempo de ejecución si nulo significa que no se ha asignado ningún valor a la variable (en realidad, nulo es en sí mismo un objeto).

Tomemos un ejemplo:

        var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

Indefinido eso es lo que obtendrá como resultado.

Ahora,

        x=5;
        y=null;
        z=x+y;

y obtendrá 5 como salida. Esa es la principal diferencia entre Indefinido y nulo

Respondido el 18 de diciembre de 16 a las 12:12

nulo - Es un valor de asignación, que se usa con variable para representar ningún valor (es un objeto).

indefinido - Es una variable que no tiene ningún valor asignado, por lo que JavaScript le asignará un indefinido (es un tipo de datos).

no declarado - Si una variable no se crea en absoluto, se conoce como no declarada.

Respondido el 03 de enero de 19 a las 04:01

Ambos valores especiales implican un estado vacío.

La principal diferencia es que indefinido representa el valor de una variable que aún no se ha inicializado, mientras que nulo representa una ausencia intencional de un objeto.

El número de variable está definido, sin embargo, no se le asigna un valor inicial:

let number;
number; // => undefined

La variable numérica no está definida, lo que indica claramente una variable no inicializada.

El mismo concepto no inicializado ocurre cuando se accede a una propiedad de objeto inexistente:

const obj = { firstName: 'Dmitri' };
obj.lastName; // => undefined

Debido a que la propiedad lastName no existe en obj, JavaScript evalúa correctamente obj.lastName como indefinido.

En otros casos, sabe que una variable espera contener un objeto o una función para devolver un objeto. Pero por alguna razón, no puede crear una instancia del objeto. En tal caso, null es un indicador significativo de un objeto perdido.

Por ejemplo, clone () es una función que clona un objeto JavaScript simple. Se espera que la función devuelva un objeto:

function clone(obj) {
  if (typeof obj === 'object' && obj !== null) {
    return Object.assign({}, obj);
  }
  return null;
}
clone({name: 'John'}); // => {name: 'John'}
clone(15);             // => null
clone(null);           // => null

Sin embargo, clone () puede invocarse con un argumento que no sea de objeto: 15 o nulo (o generalmente un valor primitivo, nulo o indefinido). En tal caso, la función no puede crear un clon, por lo que devuelve nulo, el indicador de un objeto faltante.

tipo de El operador hace la distinción entre los dos valores:

typeof undefined; // => 'undefined'
typeof null;      // => 'object'

El operador de calidad estricto === diferencia correctamente indefinido de nulo:

let nothing = undefined;
let missingObject = null;
nothing === missingObject; // => false

respondido 18 nov., 19:10

La diferencia de significado entre indefinido y nulo es un accidente del diseño de JavaScript, y no importa la mayor parte del tiempo. En los casos en los que realmente tenga que preocuparse por estos valores, le recomiendo tratarlos como en su mayoría intercambiables.

Desde el Javascript elocuente primer libro

Respondido 18 Feb 21, 06:02

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.