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

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

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'

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.

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

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 : 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.

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 
}

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

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

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

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).

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.

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.

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 ]

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'

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

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.

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.

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

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

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.

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).

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.

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)

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.

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

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.

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:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators

¡Salud!

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

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"

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.