Valores

Números especiales

Infinity y -Infinity, los cuales representan las infinidades positivas y negativas. Infinity - 1 aun es Infinity, y asi sucesivamente.

NaN (Not A Number), aunque sea un valor del tipo numérico. Obtendrás este resultado cuando, por ejemplo, trates de calcular 0 / 0 (cero dividido entre cero), Infinity - Infinity, o cualquier otra cantidad de operaciones numéricas que no produzcan un resultado significante.

Solo hay un valor en JavaScript que no es igual a si mismo, y este es NaN (“no es un número”).

console.log(NaN == NaN)
// → false

Strings

El dato básico es el string. Los Strings son usados para representar texto. Son escritos encerrando su contenido en comillas:

`Debajo en el mar`
"Descansa en el océano"
'Flota en el océano'

Operadores unarios

No todo los operadores son simbolos. Algunos se escriben como palabras. Un ejemplo es el operador typeof, que produce un string con el nombre del tipo de valor que le demos.

console.log(typeof 4.5)
// → number
console.log(typeof "x")
// → string

Boleanos

console.log(3 > 2)
// → true
console.log(3 < 2)
// → false

console.log("Itchy" != "Scratchy")
// → true
console.log("Apple" == "Orange")
// → false

Solo hay un valor en JavaScript que no es igual a si mismo, y este es NaN (“no es un número”).

console.log(NaN == NaN)
// → false

Operadores lógicos

El operador && representa el operador lógico and. Es un operador binario, y su resultado es verdadero solo si ambos de los valores dados son verdaderos.

console.log(true && false)
// → false
console.log(true && true)
// → true

El operador || representa el operador lógico or. Lo que produce es verdadero si cualquiera de los valores dados es verdadero.

console.log(false || true)
// → true
console.log(false || false)
// → false

Not se escribe como un signo de exclamación (!). Es un operador unario que voltea el valor dado—!true produce false y !false produce true.

El ultimo operador lógico ternario opera en tres valores. Es escrito con un signo de interrogación y dos puntos, de esta forma:

console.log(true ? 1 : 2);
// → 1
console.log(false ? 1 : 2);
// → 2

Este es llamado el operador condicional (o algunas veces simplemente operador ternario ya que solo existe uno de este tipo). El valor a la izquierda del signo de interrogación “decide” cual de los otros dos valores sera retornado. Cuando es verdadero, elige el valor de en medio, y cuando es falso, el valor de la derecha.

Valores vacíos

Existen dos valores especiales, escritos como null y undefined, que son usados para denotar la ausencia de un valor significativo. Son en si mismos valores, pero no traen consigo información.

Muchas operaciones en el lenguaje que no producen un valor significativo (veremos algunas mas adelante), producen undefined simplemente porque tienen que producir algún valor.

La diferencia en significado entre undefined y null es un accidente del diseño de JavaScript, y realmente no importa la mayor parte del tiempo. En los casos donde realmente tendríamos que preocuparnos por estos valores, mayormente recomiendo que los trates como intercambiables.

Conversión de tipo automática

console.log(8 * null)
// → 0
console.log("5" - 1)
// → 4
console.log("5" + 1)
// → 51
console.log("cinco" * 2)
// → NaN
console.log(false == 0)
// → true

Cuando un operador es aplicado al tipo de valor “incorrecto”, JavaScript silenciosamente convertirá ese valor al tipo que necesita, utilizando una serie de reglas que frecuentemente no dan el resultado que quisieras o esperarías.

Sin embargo, cuando null o undefined ocurren en cualquiera de los lados del operador, este produce verdadero solo si ambos lados son valores o null o undefined.

console.log(null == undefined);
// → true
console.log(null == 0);
// → false

Este comportamiento es frecuentemente util. Cuando queremos probar si un valor tiene un valor real en vez de null o undefined, puedes compararlo con null usando el operador == (o !=).

Cuando no queremos ninguna conversion de tipo automática, existen otros dos operadores adicionales: === y !==. El primero prueba si un valor es precisamente igual al otro, y el segundo prueba si un valor no es precisamente igual. Entonces "" === false es falso, como es de esperarse.

Corto circuito de operadores lógicos

Los operadores lógicos && y ||, manejan valores de diferentes tipos de una forma peculiar.

El operador ||, por ejemplo, devolverá el valor de su izquierda cuando este puede ser convertido a verdadero y de ser lo contrario devolverá el valor de la derecha. Esto tiene el efecto esperado cuando los valores son Booleanos, pero se comporta de una forma algo análoga con valores de otros tipos.

console.log(null || "usuario")
// → usuario
console.log("Agnes" || "usuario")
// → Agnes

El operador && funciona de manera similar, pero de forma opuesta. Cuando el valor a su izquierda es algo que se convierte a falso, devuelve ese valor, y de lo contrario, devuelve el valor a su derecha.