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


1088

Quiero saber cuál es la diferencia entre nully undefineden JavaScript.



1
Principalmente un duplicado de la comprobación
Dan Dascalescu

11
Siempre pensé: nullsi lo configuras como vacío, undefinedestá vacío porque no se ha configurado. O nullestá vacío a propósito, mientras undefinedtodavía está vacío. Básicamente muestra intención.
Muhammad Umer


15
Yaya. Ver por ti mismo. console.log (nulo-indefinido). La diferencia entre nulo e indefinido es NaN. (Tenga en cuenta que este es un intento de humor, antes de que me critique por haber malinterpretado la pregunta.)
Ivan

Respuestas:


1042

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

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

nullEs un valor de asignación. Se puede asignar a una variable como una representación de ningún valor:

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

De los ejemplos anteriores, está claro que undefinedy nullson dos tipos distintos: undefinedes un tipo en sí mismo (indefinido) mientras que nulles un objeto.

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

y

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

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

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

19
El comentario de Nir O. es muy importante. Si quiero tener una variable que no tiene valor al principio, escribo "... = nulo", por ejemplo, "myvar = nulo". De esta forma, 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

11
@Wolfgang Adamec, la programación sin errores no se trata de tipos erróneos.
Jorge Fuentes González

12
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 indefinido significa. probablemente nunca se inicializó o, si lo fue, nunca se definió.
Muhammad Umer

74

Elegí esto de aquí

El valor indefinido es un valor primitivo utilizado 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í solo, si intenta utilizar WScript.Echo () o alertar () este valor, no verá nada. Sin embargo, si agrega una cadena en blanco, de repente aparecerá:

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

Puede declarar una variable, establecerla como nula, y el comportamiento es idéntico, excepto que verá "nulo" impreso versus "indefinido". Esta es una pequeña diferencia de hecho.

Incluso puede comparar una variable que no está definida como 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, nulo 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 del script anterior dará como resultado el siguiente resultado:

undefined
object

Independientemente de que sean diferentes tipos, seguirán actuando de la misma manera si intentas 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 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 que no lo haga. Recomiendo configurar solo las variables como nulas y dejar indefinido el valor de las cosas que olvidó configurar. Al mismo tiempo, realmente te animo a que siempre configures cada variable. 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 variables como nulas es la mejor manera de evitar errores basados ​​en él.

Otra instancia en la que verá una ventana emergente indefinida es cuando use el operador de eliminación. Aquellos de nosotros de un mundo C podría 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 ese 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 recibirá una respuesta indefinida cuando lea un subíndice o miembro que nunca existió.

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


8
Realmente una buena respuesta. Pero solo para señalar, cuando seleccionó "undefined == null", la comprobación de tipo no fue estricta. Por lo tanto, volvió "verdadero". Si marca "undefined === null", devolverá falso.
wOlVeRiNe

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

66

Esta es la diferencia

(agregando caracteres debido a la falta de caracteres, así que puedo publicar esto).


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

1
@Vega Desafortunadamente no, no recuerdo de dónde lo obtuve sino en imgur.com y eso es probablemente de un reenvío, no de la fuente ORIGINAL. Ni siquiera el enlace incrustado aquí da idea de quién publicó esta versión, por lo que tampoco puedo buscarla.
Sebastian Norr

1
ja ja ja ... esta es la mejor explicación que he visto! ¡frio!
Akbar Mirsiddikov

36

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

piense en ello como un valor, como:

  • "foo" es una cuerda,
  • verdadero es booleano,
  • 1234 es el número,
  • nulo es indefinido.

La propiedad undefined indica que a una variable no se le ha asignado un valor, incluido nulo también. Me gusta

var foo;

la variable vacía definida es nullde tipo de datosundefined


Ambos representan un valor de una variable sin valor.

Y null no representa una 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 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

Así que cada uno tiene su propia forma de usar

indefinido, úselo para comparar el tipo de datos variables

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 

nulo también es un tipo de datos. Tanto indefinido como nulo son tipos de datos y valores
danwellman

99
nullAbsolutamente ES un tipo de datos: msdn.microsoft.com/en-us/library/ie/7wkd9z69(v=vs.94).aspx. El hecho de que typeof nulldevuelve objectes un error bien conocido y documentado en las primeras versiones de ECMAScript que se ha mantenido por compatibilidad con versiones anteriores. El enlace que usted realmente ha escrito en su comentario dice mitad de la página "typeof nula // objeto (error en ECMAScript, debe ser nulo)"! Entonces, por favor, muestre algún esfuerzo de búsqueda antes de comentar sobre votos
negativos

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

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

19

nulo : ausencia de valor para una variable; indefinido : ausencia de variable en sí misma;

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

JS podría ser lo suficientemente amable como para iniciar implícitamente variables recién declaradas con nulo , pero no lo hace.


25
var a = {}; a.n = undefined;' then ..a.hasOwnProperty ('n') == true` ... así que decir que la ausencia de la variable en sí ya no es correcta
Muhammad Umer

17

Por favor lea lo siguiente cuidadosamente. Eliminará todas sus dudas con respecto a la diferencia entre nulo e indefinido en JavaScript. También puede usar la función de utilidad dada a continuación para determinar exactamente los tipos.

En JavaScript podemos tener los siguientes tipos de variables.

  1. Variables no declaradas
  2. Variables declaradas pero no asignadas
  3. Variables asignadas con literal indefinido
  4. Variables asignadas con nulo literal
  5. Variables asignadas con cualquier cosa que no sea indefinida o nula

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

  1. Variables no declaradas : lo siguiente es válido para las variables no declaradas

    • Solo se puede verificar con typeof () que devuelve la cadena 'undefined'
    • ¿No se puede verificar con == o === o con un operador if o condicional ? (arroja error de referencia)
  2. Variables declaradas pero no asignadas

    • typeof devuelve la cadena 'indefinido'
    • == comprobar con nulo devuelve verdadero
    • == verificación con retornos indefinidos verdadero
    • === comprobar con nulo devuelve falso
    • === comprobar con retornos indefinidos verdadero
    • si u operador condicional ? devuelve falso
  3. Variables asignadas con literal indefinido : Estas variables se tratan de manera similar a las Variables declaradas pero no asignadas .

  4. Variables asignadas con nulo literal

    • typeof devuelve la cadena 'objeto'
    • == comprobar con nulo devuelve verdadero
    • == verificación con retornos indefinidos verdadero
    • === comprobar con nulo devuelve verdadero
    • === comprobar con devoluciones indefinidas falso
    • si u operador condicional ? devuelve falso
  5. Variables asignadas con cualquier cosa que no sea indefinida o nula

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

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

  1. Verifique si no está declarado / no asignado / asignado con undefined usando typeof . devuelve si se devuelve la cadena 'undefined' .
  2. Verifique nulo usando === . devuelve 'nulo' si es verdadero .
  3. Verifique el tipo real usando typeof . tipo de retorno si no es igual a 'objeto'
  4. Llame a Object.prototype.toString.call (o) para determinar el tipo de objeto real. Devolverá una cadena de tipo '[object ObjectType]' para todos los objetos definidos en Javascript o DOM definidos. Para los objetos definidos por el usuario, devuelve '[objeto Object]'

También puede usar la siguiente función de utilidad para determinar los tipos. Actualmente es compatible con todos los tipos ECMA 262 2017.

function TypeOf(o,bReturnConstructor)
 {
   if(typeof o==='undefined') return 'undefined'
   if(o===null) return 'null'   
   if(typeof o!=='object') return typeof o

   var type=Object.prototype.toString.call(o)
  switch(type)
  {
     //Value types:4
     case '[object Number]': type='number';break;
     case '[object String]': type='string';break;
     case '[object Boolean]': type='boolean';break;
     case '[object Date]': type='date';break;


   //Error Types:7
     case '[object Error]': type='error';break;
     case '[object EvalError]': type='evalerror';break;
     case '[object RangeError]': type='rangeerror';break;
     case '[object ReferenceError]': type='referenceerror';break;
     case '[object SyntaxError]': type='syntaxerror';break;
     case '[object TypeError]': type='typeerror';break;
     case '[object URIError]': type='urierror';break;


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

    //Keyed Collection Types:2
     case '[object Map]': type='map';break;
     case '[object WeakMap]': type='weakmap';break;

    //Set Types:2
     case '[object Set]': type='set';break;
     case '[object WeakSet]': type='weakset';break;

    //Operation Types
    case '[object RegExp]': type='regexp';break;
    case '[object Proxy]': type='proxy';break;
    case '[object Promise]': type='promise';break;

    case '[object Object]': type='object';
             if(bReturnConstructor && o.constructor) type=o.constructor.toString().match(/^function\s*([^\s(]+)/)[1];
         break;
    default:
        type=type.split(' ')[1]
        type=type.substr(0,type.length-1)   

   }
    return type 
}

12

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

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


11

Voy a explicar undefined, nully Uncaught ReferenceError:

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


9

Indefinido significa que una variable ha sido declarada pero no tiene valor:

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

Nulo es una tarea:

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

9

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

  • ambos solo pueden contener un solo valor, nulo e indefinido respectivamente;
  • ambos no tienen propiedades o métodos y un intento de leer cualquiera de las propiedades dará como resultado un error de tiempo de ejecución (para todos los demás objetos, obtendrá un valor indefinido si intenta leer una propiedad inexistente);
  • los valores null y no definido se consideran iguales entre sí ya nada más por ==y !=operadores.

Sin embargo, las similitudes terminan aquí. Por una vez, hay una diferencia fundamental en la forma en que se implementan las palabras clave nulas e indefinidas . Esto no es obvio, pero considere el siguiente ejemplo:

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

undefined , NaN e Infinity son solo nombres de variables "superglobales" preinicializadas: se inicializan en tiempo de ejecución y pueden ser anuladas 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);

¡Uy! nulo , verdadero y falso 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 en que se tratan nulo e indefinido 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 falso , es básicamente un tipo especial de "cero". undefined , por otro lado, es un verdadero "nada" y se convierte en NaN ("no es un número") cuando intenta usarlo en contexto numérico.

Tenga en cuenta que null e undefined reciben un tratamiento especial de ==y !=operadores, pero puede probar la verdadera igualdad numérica de a y b con la expresión (a >= b && a <= b).


8

tl; dr

Use nullpara establecer una variable que sepa que es un Objeto.

Se usa undefinedpara establecer una variable cuyo tipo es mixto.


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

Cuerda

Si sabe que una variable es solo una cadena durante 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 0(o NaNsi 0es un valor importante en su uso):

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

o

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

Booleano

Si sabe que una variable es solo un valor booleano mientras que todo el ciclo de vida, por convención, puede inicializarlo 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 durante 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 fuera de nulo es ser la versión falsa de un Objeto porque siempre es un Objeto true, y porque typeof nulldevuelve object. Eso significa typeof myVarObjectdevolver un valor consistente tanto para el objeto como para el tipo nulo.

Todas

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


7

nulles un valor especial que significa "sin valor". nulles un objeto especial porque typeof nulldevuelve 'objeto'.

Por otro lado, undefinedsignifica que la variable no se ha declarado o no se le ha dado un valor.


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

6

La mejor manera de entender 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, nully undefined. Usted es 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 undefinedporque nunca dijo nada sobre cuál era el valor deseado.

    let supervisor;
    assert(supervisor === undefined);
  2. Una propiedad de un objeto que nunca se ha establecido se evalúa undefinedporque 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 son enfáticamente no iguales entre sí.

    assert(null == undefined);
    assert(null !== undefined);
  4. nully undefinedafortunadamente tenemos diferentes tipos. nullpertenece al tipo Nullyundefined al tipo Undefined. Esto está en la especificación, pero nunca lo typeofsabrías debido a la 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 sabe nada sobre 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
  • Usando un letconst variable local o definida en su zona muerta temporal y recibiendo unReferenceError
  • Celdas vacías en matrices dispersas. Sí, estos ni siquiera undefinedson comparados ===con indefinidos.

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

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

Gracias, y sí, esa idea errónea de que algo es undefinedsolo si no se ha declarado o aún no se le ha dado un valor es tan desenfrenada y es realmente difícil transmitirla a las personas (aunque sigo intentándolo). Así que mucha gente basura JavaScript para poder tener tanto nully undefinedaunque estos valores no tienen significados completamente distintos y en su mayor parte que trabajar bien con sus significados previstos (en mi humilde opinión, por supuesto).
Ray Toal

5

En JavasSript hay 5 tipos de datos primitivos String, Number, Boolean, null e undefined. Trataré de explicar 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 if (a == null) es igual que if (! 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

tan nulo es un objeto. de alguna manera hemos asignado un valor nulo a 'a'


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

4

Para el undefinedtipo, hay un único valor:undefined .

Para el nulltipo, hay un único valor:null .

Entonces, 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 valor
  • null tuvo un valor y ya no

En realidad, nulles una palabra clave especial , no un identificador, por lo que no puede tratarse como una variable a la que asignar.

Sin embargo, undefinedes un identificador . Sin embargo, tanto en el non-strictmodo como en el strictmodo, puede crear una variable local del nombre indefinido. ¡Pero esta es una idea terrible!

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

foo();

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

foo();

4

Cuando declara una variable en javascript, se le asigna el valor undefined. Esto significa que la variable está intacta y se le puede asignar cualquier valor en el futuro. También implica que no conoce el valor que esta variable va a tener 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 segundo nombre de un objeto persona.

Ahora suponga que alguien está accediendo a la variable de segundo nombre de su objeto de persona 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, el usuario puede inferir fácilmente que el segundo nombre no tiene ningún valor y que no es una variable intacta.


3

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

var a = null;

a se inicializa y se define.

typeof(a)
//object

nulo es un objeto en JavaScript

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

var b;

b es indefinido y no inicializado

las propiedades de objeto indefinidas también son indefinidas. Por ejemplo, "x" no está definida en el objeto c y si intenta acceder a cx, volverá indefinido.

Generalmente asignamos nulo a variables no indefinidas.


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

3

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

"En general, si necesita asignar un no valor a una variable o propiedad, pasarlo a una función o devolverlo desde una función, nulo es casi siempre la mejor opción. Para decirlo simplemente, JavaScript usa indefinido y los programadores deben use nulo ".

Ver Explorando el abismo eterno de nulos e indefinidos


3

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 falta 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


3

De acuerdo, es posible que nos confundamos cuando escuchemos nully undefined, pero comencemos de manera simple, ambos son falsos y similares en muchos aspectos, pero parte extraña de JavaScript, los diferencia un par de diferencias significativas, por ejemplo, typeof null es 'object'mientras typeof undefined es 'undefined'.

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

Pero si ==los marca de la siguiente manera, verá que ambos son falsos :

null==undefined; //true

También puede asignar nulla una propiedad de objeto o a una primitiva, mientrasundefined que simplemente se puede lograr al no asignar a nada.

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

Nulo e indefinido


2

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


2

En javascript, todas las variables se almacenan como pares de valores clave. Cada variable se almacena como variable_name: variable_value / reference .

undefined 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 usar este tipo como una tarea.

En ese caso, ¿cómo denotar cuando desea que una variable no tenga valor en un punto posterior del código? Puede 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 tiene el valor en la memoria. Ese valor es nulo

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


2

Quiero agregar una diferencia muy sutil entre nully undefinedque es bueno saber cuando intentas aprender Vanilla JavaScript (JS) desde cero:

  • nulles una palabra clave reservada en JS mientras que undefinedes 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 como ambas nully undefinedsiempre 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 JS interpreta el siguiente código como error:

var null = 'foo'

Da abajo error:

SyntaxError no capturado: token inesperado nulo

Mientras que el código a continuación se ejecuta con éxito, aunque no recomendaré hacerlo en la vida real:

var undefined = 'bar'

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


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

1

La diferencia entre undefinedy nulles mínima, pero hay una diferencia. Una variable cuyo valor es undefinednunca se ha inicializado. Una variable cuyo valor es nullexplícitamente dado un valor de null, lo que significa que la variable se configuró explícitamente para no tener ningún valor. Si compara undefinedy nullutilizando la null==undefinedexpresión, serán iguales.


Esta respuesta es engañosa ... vea la discusión en la respuesta aceptada. Línea inferior: null==undefinedes truesolo debido a la conversión implícita (o el término equivalente en JS). Evidentemente, null===undefinedes falseporque usar cuando lo usas ===también compara el tipo .
guyarad

1

Básicamente, indefinido es una variable global que JavaScript crea en el tiempo de ejecución, ya sea 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 salida.

Ahora,

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

y obtendrás 5 como salida. Esa es la principal diferencia entre lo indefinido y lo nulo


1

nulo : es un valor de asignación, que se utiliza con la variable para representar ningún valor (es un objeto).

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

undeclared : si no se crea una variable, se conoce como no declarada.


1

Mira esto. La salida vale más que 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:

¡Salud!


1
De esto aprendí que en realidad isNaN(null)regresa false, lo que me sorprendió.
J. Bruni

0

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 de número 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 no existente:

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, nulo 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 () podría invocarse con un argumento no 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 perdido.

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

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

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

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

0

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

  1. La 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 nullpero omiteundefined
    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"

-2

Si una variable no se inicializa, entonces no está definida. indefinido no es un objeto. Ejemplo: var MyName; console.log (typeof MyName);

Compruebe la herramienta de desarrollo de inicio de sesión de la consola, se imprimirá como indefinida.

nulo es un objeto. Si desea que alguna variable sea nula, se utiliza nulo. Existe una variable nula pero no se conoce el valor. Debe asignarse a una variable de forma programática. nulo no se inicializa automáticamente.

Ejemplo: var MyName = null; console.log (typeof MyName); Verifique la herramienta de desarrollo de inicio de sesión de csole, será un objeto.

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.