Ir al contenido principal

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

En Node.JS, 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, muy utilizados en Node.JS: undefined, null, NaN e Infinity.

Índice

  1. undefined
  2. null
  3. ¿null o undefined?
  4. NaN
  5. Infinity
  6. Lo que hemos conseguido
  7. Qué viene a continuación

undefined

Como su nombre indica, el valor global undefined representa un valor no definido. Lo mejor es verlo con 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 puede convertirse a boolean, number y string siguiendo estas reglas:

  • Como boolean se convierte en false
  • Como number se convierte en NaN (lo veremos en la sección NaN)
  • Como string se convierte en "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, vacío o intencionadamente no definido.

En los siguientes ejemplos vemos a null en acción. Es importante recordar que, debido a un bug histórico de ECMAScript, typeof null devuelve "object". 

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

// Crea una constante establecida a null
const nullish = null
console.log(typeof nullish) // Imprime "object"

// 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 otros tipos funciona así:

  • Como boolean se convierte en false
  • Como number se convierte en 0
  • Como string se convierte en "null"
// 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 lo 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 simple:

  • Si una variable contiene el valor undefined, es porque no existe o no se ha inicializado
  • 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: es un número que no es un número.

NaN se utiliza para representar conversiones fallidas a number, como en estos 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 un número especial que representa ∞ y -∞.

Veamos algunos ejemplos (tranquilo si aparecen funciones que aún no hemos estudiado, más adelante las veremos en detalle): 

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

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

// 10e1000 es mayor que el máximo representable en JS
console.log(10e1000)

// Math.log(0) devuelve -Infinity
console.log(Math.log(0))

A diferencia de NaN, no hay ningún problema al comparar un valor con Infinity.

Lo que hemos conseguido

Con este capítulo hemos completado el repaso a los valores básicos de JS, incluyendo los especiales undefined, null, NaN e Infinity.

Ahora sabes qué valores toman las variables no inicializadas (undefined) y cuál usar para indicar de manera explícita que una variable está vacía (null).

También entiendes qué significa NaN y cómo comprobarlo con Number.isNaN().

Finalmente, has visto cómo se representan los infinitos positivo y negativo (Infinity).

Qué viene a continuación

En el próximo capítulo, Asignación, operaciones aritméticas y concatenación, aprenderemos cómo asignar valores a constantes y variables, realizar operaciones aritméticas y trabajar con concatenación de valores alfanuméricos.

Labels: