primitivos - undefined javascript

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

Question

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

Answer 1

Podría considerar que no definido representa una ausencia de valor a nivel de sistema, inesperada o similar a un error y nula para representar la ausencia de valor a nivel de programa, normal o esperada.

a través de JavaScript: La Guía Definitiva

Answer 2

Tanto Null como undefined en JavaScript indican ausencia de valor.

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

A pesar del hecho de que ambos existen por ausencia de valor, pero: No definido 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

Answer 3

Bien, podemos confundirnos cuando escuchamos acerca de null e undefined , pero comencemos de manera simple, ambos son falsos y similares de muchas maneras, pero una parte extraña de JavaScript hace que tengan algunas diferencias significativas, por ejemplo, typeof null is ''object'' mientras que typeof undefined es ''undefined'' .

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

Pero si los marca con == como se muestra a continuación, verá que ambos son falsos:

null==undefined; //true

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

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

Answer 4

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

Answer 5

Con JavaScript, null es para objetos, indefinido es para variables, propiedades y métodos.

Para ser nulo, un objeto tiene que ser definido, de lo contrario será indefinido.

Si desea probar si un objeto existe, esto generará un error si el objeto no está definido:

Incorrecto:

if (myObj !== null && typeof myObj !== "undefined") 

Debido a esto, primero debes probar typeof ():

Correcto:

if (typeof myObj !== "undefined" && myObj !== null) 

Answer 6

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 mantendrá en el momento de la declaración.

Ahora puedes 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 middlename de un objeto person.

Ahora suponga que alguien está accediendo a la variable middlename de su objeto personal 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 middlename no tiene ningún valor y no es una variable intacta.

Answer 7

Cuando un valor es nulo, no es nada y no contiene nada. Un valor vacío o variable todavía está lleno;Está lleno de vacío. El vacío es diferente de nulo, que simplemente no es nada. Por ejemplo, definir una variable y establecer su valor en una cadena vacía se ve así:

 var myVariable = ''''; 

La variable myVariable está vacía, pero no es nula.

Undefinedes un estado, a veces usado como un valor, para representar una variable que aún no ha contenido un valor. tales como var abcd; . Este estado es diferente de nulo, aunque tanto nulo como indefinido se pueden evaluar de la misma manera.

Answer 8

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

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 (undefined) mientras que null es un objeto.

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

y

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

Answer 9

En JavasSript hay 5 tipos de datos primitivos: String, Number, Boolean, null y 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 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

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

Answer 10

Escogí esto de here

El valor no definido 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 declara una variable a través de var y no le asigna 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". Esta es una pequeña diferencia de hecho.

Incluso puede comparar una variable que no está definida a 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 de todo 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 igual si intentas acceder a uno de los miembros, por ejemplo, es decir, lanzarán una excepción. Con WSH verás el temido "''varname'' es nulo o no un objeto" y eso es si tienes suerte (pero eso es un tema para otro artículo).

Puede establecer explícitamente una variable como indefinida, pero le recomiendo que no lo haga. Recomiendo solo establecer las variables en nulo y dejar sin definir el valor de las cosas que se olvidó de establecer. 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 en nulo es la mejor manera de evitar errores basados ​​en ella.

Otra instancia en la que verá una ventana emergente indefinida es cuando utiliza 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 un Array o un miembro de un Objeto. Para Arrays 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 obtendrá devuelto 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 hacemos normalmente. Si bien podemos establecer variables a indefinidas, preferimos null porque no es algo que se haga por nosotros. Cuando estás depurando, esto significa que cualquier cosa configurada como nula es cosa tuya y no de JavaScript. Más allá de eso, estos dos valores especiales son casi equivalentes.

Answer 11

Explicaré undefined , null y Uncaught ReferenceError :

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

Answer 12

La diferencia entre undefined y null es mínima, pero hay una diferencia. Una variable cuyo valor undefined está undefined nunca se ha inicializado. A una variable cuyo valor es null se le asignó explícitamente un valor null , lo que significa que la variable se estableció explícitamente para que no tuviera ningún valor. Si comparas undefined y un null utilizando la expresión null==undefined , serán iguales.

Answer 13

La mejor manera de entender la diferencia es despejar primero su mente del funcionamiento interno de JavaScript y simplemente entender 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 e 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 undefined porque nunca dijo nada acerca de 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 como undefined porque nadie dijo nada sobre esa propiedad.

   const dog = { name: ''Sparky'', age: 2 };
   assert(dog.breed === undefined);

3. null e 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 e undefined afortunadamente tienen diferentes tipos. null pertenece al tipo Null y undefined al tipo Undefined . Esto está en la especificación, pero nunca lo typeof debido al tipo de 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
• Usar una variable local let o const definida en su zona muerta temporal y recibir un ReferenceError

• Células vacías en matrices dispersas. Sí, estos ni siquiera están undefined aunque se comparan === con indefinidos.

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

Answer 14

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

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

Null es una tarea:

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

Answer 15

Para el tipo undefined , hay un solo valor: undefined .

Para el tipo null , hay un solo 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 perdido

O:

• undefined no ha tenido un valor todavía
• null tenía un valor y ya no lo tiene

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

Sin embargo, undefined es un identificador . Sin embargo, tanto non-strict modo non-strict como en el strict , puede crear una variable local del nombre no definido. ¡Pero esta es una idea terrible!

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

foo();

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

foo();

Answer 16

Per artículo completo de Ryan Morr sobre este tema ...

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

Ver Explorando el Eterno Abismo de Nulo e Indefinido.

Answer 17

Por favor, lea atentamente lo siguiente. Eliminará todas sus dudas con respecto a la diferencia entre nulo e indefinido en JavaScript. También puede utilizar 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 nulo literal.
5. Variables asignadas con algo distinto de 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 se puede verificar con typeof () que devuelve la cadena ''undefined''
   • ¿No se puede verificar con == o === o mediante un operador condicional ? (arroja un error de referencia)

2. Variables declaradas pero no asignadas

   • typeof devuelve la cadena ''undefined''
   • == comprobar con null devuelve true
   • == verificar con devoluciones indefinidas verdadero
   • === comprobar con null devuelve falso
   • === verificar con undefined devuelve true
   • Si o 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 null devuelve true
   • == verificar con devoluciones indefinidas verdadero
   • === comprobar con null devuelve true
   • === verificar con devoluciones indefinidas falso
   • Si o operador condicional ? devuelve falso

5. Variables asignadas con algo distinto de indefinido o nulo

   • typeof devuelve una de las siguientes cadenas: ''string'' , ''number'' , ''boolean'' , ''function'' , ''object'' , ''symbol''

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

1. Verifique si no ha sido declarado / no asignado / asignado con undefined utilizando typeof . devolver si se devuelve la cadena ''indefinido'' .
2. Compruebe si hay null utilizando === . devuelve ''null'' si es verdadero .
3. Compruebe el tipo real utilizando typeof . devuelve el tipo 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 integrados en Javascript o DOM definidos. Para los objetos definidos por el usuario devuelve ''[objeto Objeto]''

También puede utilizar la siguiente función de utilidad para determinar los tipos. Actualmente soporta 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 
}

Answer 18

null y undefined son ambos se utilizan para representar la ausencia de algún valor.

var a = null;

a está inicializado y definido.

typeof(a)
//object

null es un objeto en JavaScript

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

var b;

b es indefinido y no inicializado

Las propiedades de objetos indefinidos también son indefinidas. Por ejemplo, "x" no está definido en el objeto c y si intenta acceder a cx, devolverá indefinido.

Generalmente asignamos nulo a variables no indefinidas.

Answer 19

tl; dr

Use null para establecer una variable que sabe que es un objeto.

Use undefined para establecer una variable cuyo tipo sea 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 sabe que una variable es solo una cadena mientras todo el ciclo de vida, por convención, podría inicializarla, a "" :

("") ? 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 inicializarlo, a 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 valor booleano mientras todo el ciclo de vida, por convención, podría inicializarla, en 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, podría inicializarlo, a null :

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

Nota: el uso inteligente fuera de nulo es la versión falsa de un Objeto porque un Objeto siempre es true , y porque el object devuelve tipo typeof null . Eso significa que 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, mientras que todo el ciclo de vida), por convención, puede inicializarlo a undefined .

Answer 20

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

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

Answer 21

null es una palabra clave de lenguaje que se evalúa en un valor especial que generalmente se usa para indicar la ausencia de un valor. El uso del operador typeof en null devuelve la cadena "objeto", lo que indica que se puede considerar nulo como un valor de objeto especial que indica "sin objeto". Sin embargo, en la práctica, null se suele considerar como el único miembro de su propio tipo, y se puede usar para indicar "sin valor" para números y cadenas, así como para objetos. La mayoría de los lenguajes de programación tienen un equivalente a nulo de JavaScript: puede que esté familiarizado con él como nulo o nulo.

JavaScript también tiene un segundo valor que indica la ausencia de valor. El valor indefinido representa un tipo más profundo de ausencia. Es el valor de las variables que no se han inicializado y el valor que obtiene cuando consulta el valor de una propiedad de objeto o elemento de matriz que no existe. El valor no definido también es devuelto por las funciones que no tienen valor de retorno y el valor de los parámetros de la función para los que no se proporciona ningún argumento. undefined es una variable global predefinida (no una palabra clave de idioma como null) que se inicializa en el valor indefinido. En ECMAScript 3, undefined es una variable de lectura / escritura, y se puede establecer en cualquier valor. Este error se corrige en ECMAScript 5 y el indefinido es de solo lectura en esa versión del idioma. Si aplica el operador typeof al valor indefinido, devuelve "indefinido", lo que indica que este valor es el único miembro de un tipo especial.

A pesar de estas diferencias, nulo e indefinido indican una ausencia de valor y, a menudo, se pueden usar indistintamente. El operador de igualdad == los considera iguales. (Utilice el operador de igualdad estricta === para distinguirlos). Ambos son valores falsos: se comportan como falsos cuando se requiere un valor booleano. Ni null ni undefined tienen propiedades o métodos. De hecho, utilizando. o [] para acceder a una propiedad o método de estos valores provoca un TypeError.

Podría considerar que no definido representa una ausencia de valor a nivel de sistema, inesperada o similar a un error y nula para representar la ausencia de valor a nivel de programa, normal o esperada. Si necesita asignar uno de estos valores a una variable o propiedad o pasar uno de estos valores a una función, casi siempre es la opción correcta.

Answer 22

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

Piénsalo como un valor, como:

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

la propiedad indefinida 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 del tipo de datos undefined

Ambos representan un valor de una variable sin valor

Y null no representa una cadena que no tiene ningún 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 manera de usar

indefinido usarlo para comparar el tipo de datos variable

nulo usarlo para vaciar un valor de una variable

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

Answer 23

null y undefined 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 ni métodos y un intento de leer cualquiera de las propiedades resultará en un error en tiempo de ejecución (para todos los demás objetos, obtendrás un valor indefinido si intentas leer una propiedad no existente);
• los valores nulos e indefinidos se consideran iguales entre sí y para nada más por los operadores == y != .

Las similitudes sin embargo 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

indefinido , NaN e Infinity son solo nombres de variables "superglobulares" preinicializadas; se inicializan en tiempo de ejecución y pueden ser anuladas por variables globales o locales normales con los mismos nombres.

Ahora, intentemos lo mismo con null :

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

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

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

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

Answer 24

nulo - Es un valor de asignación. Que se utiliza con la variable para representar ningún valor. (es un objeto)

indefinido : es una variable que no tiene ningún valor asignado. Así que javascript le asignará un indefinido. (es un tipo de datos)

no declarado : si la variable no se crea en absoluto, se conoce como no declarado.

Answer 25

nulo : ausencia de valor para una variable; indefinido : ausencia de variable propiamente dicha;

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

Answer 26

Sólo para añadir mis puntos de vista -

Una variable que se declara solo, y nunca se usa en ninguna parte, es eliminada por un compilador de optimización en caso de lenguajes compilados como C ++ [o una advertencia está marcada en el IDE]. En última instancia, significa que la variable no existe porque su memoria nunca se asigna.

En el caso de un intérprete de javascript, [supongo] que una variable se trata como existente solo desde el punto en que se le asigna un valor. Antes de ese punto, su tipo es "indefinido", y no se le asigna memoria. Y, por lo que su tipo es indefinido.

Un nulo en javascript es un valor que representa una dirección, pero esa dirección no apunta a nada todavía [referencia inexistente]. Sin embargo, es un valor.

Answer 27

Básicamente, Undefined es una variable global que javascript crea en el tiempo de ejecución si null significa que no hay un valor asignado a la variable (en realidad null es 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

Sin definir eso es lo que obtendrás como salida.

Ahora,

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

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

Answer 28

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

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

En ese caso, ¿cómo denotar cuándo quiere 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, la ausencia de un valor, pero no es lo mismo que no definido, ya que en este caso realmente tiene el valor en memoria. Ese valor es nulo

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

Answer 29

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

Verifique el registro de la consola en la herramienta de desarrollo, se imprimirá como indefinido.

null es un objeto. Si desea que alguna variable sea nula, entonces se usa null. Existe una variable null pero no se conoce el valor. nulo no se inicializa automáticamente.

Ejemplo: var MyName = null; console.log (typeof MyName); Verifique el registro de la csole en la herramienta de desarrollo, será un objeto.

Answer 30

• indefinido significa que una variable se ha declarado pero aún no se le ha asignado un valor.
• nulo es un valor de asignación. Se puede asignar a una variable como una representación de ningún valor.
• indefinido y nulo son dos tipos distintos:

undefined es un tipo en sí mismo (undefined) mientras que null es un objeto.

• Las variables no asignadas se inicializan mediante JavaScript con un valor predeterminado de indefinido.
• JavaScript nunca establece un valor en nulo. Eso debe hacerse programáticamente.