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


Quiero saber cuál es la diferencia entre null y undefined en JavaScript


826
2018-02-22 10:30


origen


Respuestas:


En JavaScript, undefined significa que una variable ha sido declarada pero todavía 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 de ningún valor:

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

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

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

y

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

825
2018-02-22 10:31



Escogí esto de aquí 

El valor indefinido es un valor primitivo que se usa cuando una variable no tiene   se le ha asignado un valor

El valor nulo es un valor primitivo que representa el nulo, vacío,   o referencia 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 alerta () este valor, no verá nada. Sin embargo, si agrega una cadena en blanco, aparecerá de repente:

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

Puede declarar una variable, establecerla como nula y el comportamiento es idéntico, excepto que verá impreso "nulo" frente a "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. Mientras que undefined es un tipo para sí mismo, null se considera un valor de objeto especial. Puedes 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));

Ejecutar el script anterior dará como resultado el siguiente resultado:

undefined
object

Independientemente de que sean tipos diferentes, seguirán actuando de la misma forma si intenta acceder a un miembro de cualquiera de los dos, p. 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 que una variable no esté definida, pero desaconsejo encarecidamente. Recomiendo establecer las variables a nulo y dejar indefinido el valor de las cosas que olvidaste establecer. Al mismo tiempo, realmente te animo a que siempre establezcas 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 las variables como nulas es la mejor manera de evitar errores basados ​​en él.

Otra instancia en la que verá una ventana emergente no definida es cuando usa el operador de eliminación. Aquellos de nosotros de un C-mundo podrían interpretar incorrectamente esto como la destrucción de 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 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 se le devolverá indefinido al leer un subíndice o miembro que nunca existió.

La diferencia entre nulo e indefinido es: JavaScript nunca establecerá nada como nulo, eso es lo que hacemos habitualmente. Si bien podemos establecer las variables como indefinidas, preferimos nulas porque no es algo que alguna vez se haga por nosotros. Cuando está depurando esto significa que cualquier cosa configurada como nula es de su propiedad y no de JavaScript. Más allá de eso, estos dos valores especiales son casi equivalentes.


58
2018-02-22 10:34



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

Piense en ello como un valor, como:

  • "foo" es una cuerda,
  • true es booleano,
  • 1234 es número,
  • null no está definido.

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

var foo;

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


Ambos representan un valor de una variable sin valor

Y null no representa un cuerda eso 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

ASI QUE cada uno tiene su propia manera de usar

indefinido Úselo para comparar el tipo de datos variables

nulo Úselo para vaciar un valor de una variable

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

27
2017-10-25 20:58



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

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

JS podría tener la amabilidad de iniciar implícitamente nuevas variables declaradas con nulo, pero no es así


13
2017-07-03 13:59



Por favor, lea lo siguiente cuidadosamente. Eliminará todas sus dudas con respecto a la diferencia entre nulo y indefinido en JavaScript También puede usar la función de utilidad que se proporciona 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 literal nulo
  5. Variables asignadas con cualquier otra cosa que no sea indefinido o nulo

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 puede ser revisado por tipo de() que devuelve cadena 'indefinido'
    • No se puede verificar con == o === o por Si u operador condicional ?         (arroja el error de referencia)
  2. Variables declaradas pero no asignadas

    • tipo de devuelve cadena 'indefinido'
    • == Comprobar con nulo devoluciones cierto
    • == Comprobar con indefinido devoluciones cierto
    • === Comprobar con nulo devoluciones falso
    • === Comprobar con indefinido devoluciones cierto
    • Si u operador condicional ? devoluciones falso
  3. Variables asignadas con literal  indefinido: Estas variables se tratan de manera similar a la Variables declaradas pero no asignadas.

  4. Variables asignadas con literal  nulo

    • tipo de devuelve cadena 'objeto'
    • == Comprobar con nulo devoluciones cierto
    • == Comprobar con indefinido devoluciones cierto
    • === Comprobar con nulo devoluciones cierto
    • === Comprobar con indefinido devoluciones falso
    • Si u operador condicional ? devuelve falso
  5. Variables asignadas con cualquier otra cosa que no sea  indefinido o nulo

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

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

  1. Comprobar no declarado/sin asignar/asignado con  indefinido utilizando tipo de. devolver si cadena 'indefinido' es regresado.
  2. Comprobar nulo utilizando ===. regreso 'nulo' Si cierto.
  3. Verifique el tipo real usando tipo de. tipo de retorno si no es igual a 'objeto'
  4. Llamada Object.prototype.toString.call (o) para determinar el tipo de objeto real. Devolverá una cadena de tipo '[object ObjectType]'para todo el construido en Javascript o DOM Objetos definidos. Para objetos definidos por el usuario, regresa '[objeto Objeto]'

También puede usar la siguiente función de utilidad para determinar tipos. Actualmente es compatible con todos los tipos de 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 
}

10
2017-09-21 13:05



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

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

Null es una tarea:

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

7
2018-02-22 10:34



Puede considerar indefinido para representar una ausencia de valor a nivel de sistema, inesperada 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


7
2018-06-29 08:37



Lo explicaré undefined, null y Uncaught ReferenceError:

1 - Uncaught ReferenceError : variable no ha sido declarado en su secuencia de comandos, no hay referencia a este vaiverable
2 - undefined: Variable declarada pero no inicializada
3 - null : Variable declarada y es un valor vacío


7
2018-02-10 15:09



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

  • ambos solo pueden tener un solo valor, nulo y 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, obtienes valor indefinido si intentas leer una propiedad inexistente);
  • valores nulo y indefinido se consideran iguales entre sí y a nada más por == y != operadores.

Sin embargo, las similitudes terminan aquí. Por una vez, hay 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 infinito son solo nombres de variables "superglobales" preinicializadas; se inicializan en tiempo de ejecución y pueden anularse con la 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);

Oops! nulo, cierto y falso son palabras clave reservadas: el compilador no le permitirá usarlas como variables o nombres de propiedades

Otra diferencia es que indefinido es un tipo primitivo, mientras 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 el camino 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 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". indefinido, por otro lado, es un verdadero "nada" y se convierte Yaya ("no es un número") cuando intenta usarlo en contexto numérico.

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


7
2018-03-16 04:20



tl; dr

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

Utilizar undefined para 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 undefined o null.

Cuerda

Si sabes que una variable es solo una cadena mientras que todo el ciclo de vida, por convención, podrías 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, mientras que todo el ciclo de vida, por convención, puede inicializarlo, para 0 (o NaN Si 0 es 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 booleano, mientras que todo el ciclo de vida, por convención, podría inicializarlo, para false:

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

Objeto

Si sabes que una variable es solo un Objeto mientras todo el ciclo de vida, por convención, puedes inicializarlo, para null:

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

Nota: el uso inteligente de nulo es ser el falsy versión de un Objeto porque un Objeto es siempre true, y porqué typeof null regreso object. Eso significa typeof myVarObject devuelve un valor constante para Objeto y tipo nulo.

Todas

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


5
2018-01-19 18:15



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.

Fuente.


4
2018-02-22 10:35