Características Undefined en JavaScript

La propiedad global undefined representa el valor inicial indefinido en JavaScript.

Atributos de propiedad undefined

Escribible	No
Contable	No
Ajustable	No

Características generales

Una propiedad undefined es una propiedad de un objeto global, es decir, es una variable de dominio público y el valor inicial de la propiedad undefined es el tipo de datos inicial indefinido.

La propiedad undefined no es configurable y no se puede escribir en los navegadores modernos (comenzando con el estándar ECMAScript 5), pero aún así trate de evitar sobrescribirla.

Las variables a las que no se les asigna un valor serán de su tipo undefined, las expresiones regresarán undefined si no se asigna ningún valor a la variable que evalúa su valor, y una función regresará undefined si no especificamos un valor para que esa función regrese a través de la expresión return.

Es cierto que podemos usar la palabra undefined como identificador en cualquier dominio que no sea el dominio público (porque no undefined es una palabra reservada), pero no es apropiado hacerlo, y será difícil mantener y depurar el programa.

// NUNCA HAGAS ESTO

// "foo string" 
( function ()  {  var  undefined  =  'foo' ;  console.log ( undefined ,  typeof  undefined );  }) ();

// "foo string" 
( function ( undefined )  {  console.log ( undefined ,  typeof  undefined );  }) ( 'foo' );

Estructura undefined JavaScript

undefined

Ejemplos y aplicaciones en código

Factor de coincidencia con `undefined`

Puede usar el operador de coincidencia ( ===) con undefined para ver si una variable tiene un valor. En el siguiente código, no se definió ningún valor para la variable x. El resultado de la expresión if es true:

var  x ; 
if  ( x  ===  undefined )  { 
   // las expresiones se ejecutarán aquí 
} 
else  { 
   // las expresiones no se ejecutarán aquí 
}

Tenga en cuenta que usamos el operador de coincidencia ( ===) en lugar del operador de igualdad regular ( ==), porque x == undefined devolverá el valor true si es x igual null, mientras que el operador de coincidencia no. El valor null no es equivalente undefined. Consulte los parámetros de comparación para obtener más detalles.

typeof y valor undefined

Alternativamente, podemos usar el parámetro typeof para verificar si el valor de una variable es undefined:

var  x ; 
if  ( typeof  x  ===  'undefined' )  { 
   // las expresiones se ejecutarán aquí 
}

Una razón para usar el parámetro typeof es que no arrojará un error cuando la variable no esté declarada:

// la variable aún no se ha definido 
if  ( typeof  x  ===  'undefined' )  {  // sin problemas 
   // las expresiones se ejecutarán aquí 
}

if  ( x  ===  undefined )  {  // Lanza un ReferenceError

}

void y valor undefined

Una tercera forma de verificar si el valor de una variable undefined es igual es usar el operando void:

var  x ; 
if  ( x  ===  void  0 )  { 
   // las expresiones se ejecutarán aquí 
}

// Esta variable no está definida por 
if  ( y  ===  void  0 )  { 
   // El error se lanzará a - Uncaught ReferenceError: y is not defined
}