Ir al contenido principal

Valores especiales de datos básicos: null, undefined, NaN e Infinity

En JavaScript, null es la nada, undefined es la nada sin avisar, NaN es un número que no lo es, e Infinity es el resultado de dividir el caos por cero.

En este capítulo, que complementa al anterior "Tipos de datos básicos: bool, number y string", vamos a centrarnos en cuatro valores especiales de datos, la mayoría comunmente utilizados en JS: undefined, null, NaN e Infinity.

Índice

  1. undefined
  2. null
  3. ¿null o undefined?
  4. NaN
  5. Infinity
  6. Objetivos conseguidos
  7. Próximos pasos

undefined

Como su nombre indica, el valor global undefined representa un valor no definido. Lo mejor es verlo con unos ejemplos: 

// Imprime "undefined" 
console.log(typeof undefined)

// Crea una variable sin valor e imprime su tipo
let undefinedVar
console.log(typeof undefinedVar) // Imprime "undefined"

// Imprime el tipo de una variable inexistente
console.log(typeof nonExistingVar) // Imprime "undefined"

// Crea una variable y sobreescribe
// su valor, asignando undefined
let modifiedVar = "foo"
console.log(typeof modifiedVar)	// Imprime "string"

modifiedVar = undefined
console.log(typeof modifiedVar)	// Imprime "undefined"

El valor undefined se puede convertir a boolean, number y string en base a estas reglas:

  • Se convierte en boolean como valor false
  • Se convierte en number como valor NaN (veremos más sobre este valor en la sección NaN)
  • Se convierte en string como valor "undefined"
// Imprime "false" 2 veces
console.log(Boolean(undefined))
console.log(!!undefined)

// Imprime "NaN" 2 veces
console.log(Number(undefined))
console.log(+undefined)

// Imprime "undefined" 2 veces
console.log(String(undefined))
console.log(`${undefined}`)

null

El valor null representa un valor nulo, o vacío, o explícitamente no definido.

En los siguientes ejemplos vemos a null en accion. Es importante recalcar que el tipo de una variable null, al contrario de lo mostrado por el comando typeof null, no es object, sino undefined (se trata de un bug en ECMAScript, la especificación de lenguaje en la que se basa JS). 

// Imprime "object" (bug de ECMAScript)
console.log(typeof null)

// Crea una constante establecida a null
// e imprime "object" (bug de ECMAScript)
const nullish = null
console.log(typeof nullish)

// Crea una variable y sobreescribe
// su valor, asignando null
let modifiedVar = "foo"
console.log(typeof modifiedVar)	// Imprime "string"

modifiedVar = null
console.log(typeof modifiedVar)	// Imprime "object" (bug de ECMAScript)

La conversión de null a valores boolean, number y string sigue estas reglas:

  • Como undefined, se convierte en boolean como valor false
  • A diferencia de undefined...
    • se convierte en number como valor 0 (undefined se convertía a NaN)
    • se convierte en string como valor "null" (undefined se convertía a "undefined")
// Imprime "false" 2 veces
console.log(Boolean(null))
console.log(!!null)

// Imprime "0" 2 veces
console.log(Number(null))
console.log(+null)

// Imprime "null" 2 veces
console.log(String(null))
console.log(`${null}`)

¿null o undefined?

A primera vista null e undefined son valores relativamente similares: ambos representan la nada más absoluta.

A menudo los programadores tienden a utilizarlos indiscriminadamente, algo que considero erróneo y que debe ceñirse a algo dicho unas líneas más arriba y también dicho por MDN: se usa null para establecer intencionadamente el valor de una variable como vacía o no definida.

Dicho de un modo más de andar por casa, si una variable contiene el valor undefined, es porque no existe o no se ha inicializado, mientras que si una variable tiene un valor null es porque explícitamente el programador le ha asignado dicho valor para indicar, precisamente, que no contiene ningún valor.

A priori puede parecer algo extraño que a una variable se le haya establecido un valor nulo/vacío/no definido. Durante el curso iremos viendo ejemplos gracias a los que lo anterior cobrará pleno sentido. De momento quédate con la idea de "si no tiene valor y quiero que explícitamente conste así, debo usar null"

NaN

NaN, de Not a Number, es una contradicción con patas: es un número que no es un número.

NaN se utiliza principalmente para representar el resultado de conversiones a number que no son factibles, como se muestra en los siguientes ejemplos: 

// NaN es un número!
console.log(typeof NaN)	// Imprime "number"

// Todos estos comandos imprimen "NaN"
console.log(Number(undefined))
console.log(Number("No soy un número"))
console.log(Number(NaN))

// Imprime true
const nanValue = NaN
console.log(Number.isNaN(nanValue))

El último de los ejemplos anteriores es especialmente importante: la comparación de igualdad de NaN con cualquier otro valor, incluso consigo mismo, siempre devolverá false. Es por ello que el modo adecuado de comprobar si un valor es NaN es mediante una llamada a la funcion Number.isNaN()

Infinity

Infinity, es también un número que representa al valor especial ∞ y -∞.

Vamos a ver algunos ejemplos de Infinity, algunos de ellos basados en funciones que todavía no hemos visto, así que te pido un voto de confianza en lo que a continuación se muestra: 

// Infinity es un número
console.log(typeof Infinity)	// Imprime "number"

// Todos estos comandos imprimen "Infinity" o "-Infinity"
console.log(Infinity)
console.log(-Infinity)
cconsole.log(Infinity + 1)
console.log(Infinity - 1)
console.log(Infinity / 0)
console.log(1 / 0)

// 10e1000 es el número máximo representable en JS
console,log(10e1000)

// Math.log(0) es igual al 
// logaritmo neperiano de 0)
// En JS equivale al valor -Infinity
console,log(Math.log(0))

Al contrario que con NaN, no hay problema alguna en la comparacion de un valor con Infinity.

Objetivos conseguidos

Con este capítulo hemos cubierto totalmente los valores básicos en JS, abordando los valores especiales undefined, null, NaN e Infinity.

Ahora conoces los valores especiales que contienen las variables no establecidas o no definidas (undefined), además del valores que explícitamente representa un valor no establecido (null).

También conoces cómo se representan aquellos valores que no pueden convertirse a un equivalente numérico (NaN) y cómo poder comprobar si un valor es NaN (función Number.isNaN()).

Finalmente sabes cómo se representan los valores ∞ y -∞ (Infinity).

Próximos pasos

En el próximo capítulo, "Asignación, operaciones aritméticas y concatenación", aprenderemos cómo asignar valores a constantes y variables y cómo realizar tanto operaciones aritméticas sobre valores numéricos como concatenaciones con valores alfanuméricos.

Labels: