> For the complete documentation index, see [llms.txt](https://shimozurdo.gitbook.io/frontend/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://shimozurdo.gitbook.io/frontend/html5/javascript/valores.md). # 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.