Resumen Capitulo 1 Valores, Tipos, y Operadores

Observamos cuatro tipos de valores de JavaScript en este capítulo: números, textos (strings),
booleanos, y valores indefinidos. Tales valores son creados escribiendo su nombre (true, null) o
valor (13, "abc"). Puedes combinar y transformar valores con operadores. Vimos operadores
binarios para aritmética (+, -, *, /, y %), concatenación de strings (+), comparaciones (==, !=,
===, !==, <, >, <=, >=), y lógica (&&, ||), así también como varios otros operadores unarios (-
para negar un número, ! para negar lógicamente, y typeof para saber el valor de un tipo) y un
operador ternario (?:) para elegir uno de dos valores basándose en un tercer valor. Esto te da la
información suficiente para usar JavaScript como una calculadora de bolsillo, pero no para
mucho más. El próximo capítulo empezará a juntar estas expresiones para formar programas
básicos.
*************************************************************************************************************

-La información se almacena y maneja en bits más precisamente en código binario.

Valores
Cada valor tiene un tipo que determina su rol. Algunos valores son números, otros son pedazos
de texto, otros son funciones, y así sucesivamente.

Números
Solo existen una cantidad finita de patrones que podemos crear con 64 bits, lo que significa que
la cantidad de números diferentes que pueden ser representados es limitada. Para una
cantidad de N dígitos decimales, la cantidad de números que pueden ser representados es
10N. Del mismo modo, dados 64 dígitos binarios, podemos representar 264 números
diferentes, lo que es alrededor de 18 mil trillones (un 18 con 18 ceros más).
o π (pi) no puede ser precisamente expresado por un número finito de números decimales,
muchos números pierden algo de precisión cuando solo hay 64 bits disponibles para
almacenarlos.

Aritmética
Los símbolos + y * son llamados operadores. Puedes cambiar este orden envolviendo la
adición en paréntesis: (100 + 4) * 11.
Para sustraer, existe el operador -, y la división puede ser realizada con el operador /.
Cuando operadores aparecen juntos sin paréntesis, el orden en el cual son aplicados es
determinado por la precedencia de los operadores.
El símbolo % es utilizado para representar la operación de residuo. X % Y es el residuo de
dividir X entre Y.

Números especiales
Infinity y -Infinity, los cuales representan las infinidades positivas y negativas. Infinity - 1 aun es
Infinity, y asi sucesivamente. A pesar de esto, no confíes mucho en computaciones que
dependan de infinidades. Estas no son matemáticamente confiables, y puede que muy
rápidamente nos resulten en el próximo número especial: NaN.

Strings
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' Puedes usar
comillas simples, comillas dobles, o comillas invertidas para representar strings, siempre y
cuando las comillas al principio y al final coincidan.
Cuando una barra invertida (\) es encontrada dentro de un texto entre comillas, indica que el
carácter que le sigue tiene un significado especial. Esto se conoce como escapar el carácter.
Una comilla que es precedida por una barra invertida no representará el final del string sino que
formará parte del mismo. Cuando el carácter n es precedido por una barra invertida, este se
interpreta como un Newline (salto de linea).

"Esta es la primera línea\nY esta es la segunda"

El texto actual es este:
Esta es la primera línea Y esta es la segunda

Asi es como el string “Un carácter de salto de linea es escrito así: "\n".” puede ser expresado:
Un carácter de salto de linea es escrito así: \"\\n\"."

Los strings no pueden ser divididos, multiplicados, o substraidos, pero el operador + puede ser
utilizado en ellos. No los agrega, sino que los concatena— pega dos strings juntos. La siguiente
línea producirá el string "concatenar": "con" + "cat" + "e" + "nar"

Operadores unarios
Algunos operadores 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

Valores Booleanos

Es frecuentemente util tener un valor que distingue entre solo dos posibilidades, como “si”, y
“no”, o “encendido” y “apagado”. Para este propósito, JavaScript tiene el tipo Boolean, que tiene
solo dos valores: true (verdadero) y false (falso) que se escriben de la misma forma.
console.log(3 > 2) // → true
console.log(3 < 2) // → false
Los Strings pueden ser comparados de la misma forma.
console.log("Aardvark" < "Zoroaster")
// → true
Otros operadores similares son >= (mayor o igual que), <= (menor o igual que), == (igual a), y !
= (no igual a).

Operadores lógicos
Algunas operaciones que pueden ser aplicadas a valores Booleanos. JavaScript soporta tres
operadores lógicos: and, or, y not. Estos pueden ser usados para “razonar” acerca de valores
Booleanos.
El operador && representa el operador lógico and. Es un operador binario, y su resultado es
verdadero sólo si ambos de los valores dados son verdaderos.

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

los valores dados es verdadero.

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 último operador lógico no es unario, tampoco binario, sino ternario, esto es, que opera en
tres valores. Está 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” cuál
de los otros dos valores será 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.

Conversión de tipo automática

console.log(null == undefined);
// → true
console.log(null == 0);
// → false
Este comportamiento es frecuentemente útil. Cuando queremos probar si un valor tiene un
valor real en vez de null o undefined, puedes compararlo con null usando el operador == (o !=).
Pero qué pasa si queremos probar que algo se refiere precisamente al valor false? Las reglas
para convertir strings y números a valores Booleanos, dice que 0, NaN, y el string vació ("")
cuentan como false, mientras que todos los otros valores cuentan como true. Debido a esto,
expresiones como 0 == false, y "" == false son también verdaderas. Cuando no queremos
ninguna conversión 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. Recomiendo usar el operador de
comparación de tres caracteres de una manera defensiva para prevenir que conversiones de
tipo inesperadas te estorben. Pero cuando estés seguro de que el tipo va a ser el mismo en
ambos lados, no es problemático utilizar los operadores más cortos.

Corto circuito de operadores lógicos

Los operadores lógicos && y ||, manejan valores de diferentes tipos de una forma peculiar. Ellos
convertirán el valor en su lado izquierdo a un tipo Booleano para decidir que hacer, pero
dependiendo del operador y el resultado de la conversión, devolverán o el valor original de la
izquierda o el valor de la derecha. El operador ||, por ejemplo, devolverá el valor de su izquierda
cuando este 21 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

Podemos utilizar esta funcionalidad como una forma de recurrir a un valor por defecto. Si
tenemos un valor que puede estar vacío, podemos usar || después de este para reemplazarlo
con otro valor. Si el valor inicial puede ser convertido a falso, obtendrá el reemplazo en su
lugar. 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.

Chapter 2 Estructura de Programa

Vinculaciones

let atrapado = 5 * 5;

Ese es un segundo tipo de declaración. La palabra especial (palabra

clave) let indica que esta oración va a definir una vinculación. Le sigue el
nombre de la vinculación y, si queremos darle un valor inmediatamente,
un operador = y una expresión.
--------------------------------
let diez = 10;
console.log(diez * diez);
// → 100
--------------------------------
let humor = "ligero";
console.log(humor);
// → ligero
humor = "oscuro";
console.log(humor);
// → oscuro
---------------------------------
let deudaLuigi = 140;
deudaLuigi = deudaLuigi - 35;
console.log(deudaLuigi);
// → 105
---------------------------------
let uno = 1, dos = 2;
console.log(uno + dos);
// → 3
---------------------------------
var nombre = "Ayda";
const saludo = "Hola ";
console.log(saludo + nombre);
// → Hola Ayda
----------------------------------

Nombres vinculantes
Funciones