tipos - undefined javascript error




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

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


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


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


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


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) 

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.


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'

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.


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


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 ]
    

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

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.


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 
}

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 .


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.


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 

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


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.


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.


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.


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.





undefined