Curso JavaScript en pocas palabras. Parte 2

En este parte recordamos los operadores de asignación, lógicos y aritméticos.

Operador de asignación. Símbolo `=`

Asigna un valor a una variable.

let x=5;

También es posible hacer una asiganción a varias variables de un valor en la misma línea. Personalmente, no me gusta ni lo uso pero lo comento para recordar que existe.

let x=y=5;

Operadores aritméticos

Los operadores básicos son la suma+, resta -, multiplicación*, división /, potencia** y resto%.

const x = 3;
const y = 2;

console.log("suma: ", x + y); // -> 5
console.log("resta: ", x - y); // -> 1
console.log("multiplicatión: ", x * y); // -> 6
console.log("división: ", x / y); // -> 1.5
console.log("resto :", x % y); // -> 1
console.log("potencia: ", x ** y); // -> 9

En una línea de código con varias operaciones es recomendable usar paréntesis. En caso de no ponerlos, el orden de la operación no siempre será como pensamos.

console.log(2 + 2 * 2); // -> 6
console.log(2 + (2 * 2)); // -> 6
console.log((2 + 2) * 2); // -> 8

Operador unario

El operador unario es el que hace operaciones sobre un único operando. Tenemos el+ y el-.

Con el +si lo aplicamos sobre un valor que contenga un valor numérico pero sobre una variable de tipostring, lo convierte en tipo número. Si la variable es numérica no tiene efecto alguno.

El operador- hace la negación del valor numérico.

Operadores de incremento y decremento unarios

Son++y--. Incrememtan o decrementan una unidad sobre la variable que se aplican. La ventaja de su uso es que ecribes menos código

let x = 5;
console.log (++x); // -> 6. Es lo mismo que x=x+1;
console.log (--x); // -> 5. Es lo mismo que x=x-1;

Si el operador se pone detrás de la variable, la variable mantendrá el valor original en esa línea y se aplicará el cambio en la siguiente. Vamos con un ejemplo para aclarar esto.

let x = 5;
console.log (x++); // -> 5. Se incrementa la variable después de imprimir por consola
console.log (x); // -> 6. En la siguiente línea el valor ya está actualizado;

Operadores de asignación compuesta

Son una combinación de un operador unario y el operador de asignación. Es una forma abreviada de escribir una operación. Tenemos +=, -=, /=, *=, %= y **=.

let x = 5;

x += 2; // equivale a x = x + 2;
console.log(x); // -> 7
x -= 4; // equivale a x = x - 4
console.log(x); // -> 3

Operadores Lógicos

Los operadores lógicos también llamados booleanos devuelven verdadero o falsotrue or false. Se pueden usar para evaluar una o mas condiciones devolviendo true o false. Otra forma de usarlos es para invertir el valor de un booleano, es decir, si vale true pasarlo a false o viceversa.

Los principales operadores lógicos son&&(and),||(or)ynot(!)

Operador de negación `!`

El operador de negación, también conocido como not,!devuelve el valor opuesto al booleano. Por tanto si vale true será false o viceversa

console.log(!true); // ->false
console.log(!false); // ->true

Operador binario and`&&`

El operador and&&devuelve truecuando todos los operandos son ciertos

let x=true;
let y=false;
console.log (x && y); ->false

Operador binario or`||`

El operador or||devuelvetruesi uno de los operandos es verdadero

let x=true;
let y=false;
console.log (x || y); ->true

Operadores lógicos sobre valores no booleanos

Cuando se usa el operador not!sobre valores no booleanos, javascript lo convierte a boolenano según unos criterios casi siempre bastante intuitivos

console.log(!0); // ->true // 0 es interpretado false
console.log(!1); // ->false // 1 es interpretado como true console.log(!555); ->false // los numeros mayores de 0 son interpretados como true
console.log(!"hola"); ->false // las cadenas de texto son true para el interprete
console.log(!""); ->true // Una cadena vacía será false para el interprete
console.log(!-4); ->false // este caso es menos intuitivo. Un número negativo también será true

El operador and&& y or||sobre valores no booleanos o mixtos tiene un comportamiento peculiar. Mejor verlo con ejemplos.

//operador &&
console.log ( true && 33 ); -> 33
console.log ( false && 33 ); -> false
console.log(11 && 22); -> 22
console.log("hola" && "adios"); -> adios // devuelve la última cadena
console.log("" && "adios"); -> "" // devuelve cadena vacía

//operador ||
console.log ( true || 33 ); -> true
console.log ( false || 33 ); -> 33
console.log(11 || 22); -> 11
console.log("hola" || "adios"); -> hola // devuelve la primera cadena
console.log("" || "adios"); -> adios

En según que casos devuelve un booleno o uno de los operandos. Sinceramente, nunca he usado este tipo de sentencias. Es algo que viene en los manuales y lo comento para refrescar la memoria

Operadores de asignación compuesta con operadores binarios

De la misma forma que se puede usar la asignación compuesta con operadores de asignación (+=,-=,etc) se pueden usar los operadores binarios con asignación compuesta.

a &&= false; // equivalente a = a && false
b ||= true; // equivalente a = a || false

Operaciones con cadenas

Operador`+`

El operador+aplicado a cadenas hace la concatenación.

let saludo = "Hola";
console.log(saludo + " " + "mundo"); // ->Hola Mundo

Asignación compuesta con operador`+`

Las asiganaciones compuestas están permitidas con cadenas.

let saludo = "Hola";
saludo += " mundo"; // equivale a saludo = saludo + "mundo";
console.log(saludo); // ->Hola Mundo

Operadores de comparación

Los operadores de comparación devuelventrueofalsesegún la igualdad o diferencia entre variables o valores.

Para igualdad tenemos dos niveles de comparación. La mas estricta que tiene en cuenta la identidad o tipo de valor, representada por=== y la de simplemente igualdad,==.

Ejemplos con===

console.log(10 === 10); // -> true
console.log(10 === "10"); // -> false
console.log("10" === "10"); // -> true
console.log("hola" === "adios"); // -> false

Ejemplos con==

console.log(10 == 10); // -> true
console.log(10 == "10"); // -> true
console.log("10" == "10"); // -> true
console.log("hola" == "adios"); // -> false

Con el símbolo!podemos comparar la "no identidad" y la "no igualdad",!==y!=

Ejemplos con!==

console.log(10 !== 10); // -> false
console.log(10 !== "10"); // -> true
console.log("10" !== "10"); // -> false
console.log("hola" !== "adios"); // -> true

Ejemplos con!=

console.log(10 != 10); // -> false
console.log(10 != "10"); // -> false
console.log("10" != "10"); // -> false
console.log("hola" != "adios"); // -> true

Mas operadores de comparación

Podemos comparar dos valores o variables y detectar cual es mayor o menor de las dos. Son los operadores mayor que>, menor que<, mayor o igual que>=y menor o igual que<=

Cuando la comparación es entre números el resultado es bastante obvio.

console.log( 5 > 3); // -> true;
console.log( 5 < 3); // -> false;
console.log( 3 <= 3); // -> true

Cuando la comparación es entre cadenas, la lógica de la comparación es un poco compleja y realmente no tiene mucha utilidad práctica. Resumiendo mucho solo comentar que las cadenas son comparadas de manera individual por cada posición de caracter. Las minúsculas son de mayor valor que las mayusculas y que los valores numéricos son menores que las letras.

console.log("b" > "a"); // -> true
console.log("b2" > "b3"); // -> false
console.log("A" > "a"); // -> false
console.log("11" > "A1"); // -> false