¿Qué operadores puedo usar en JavaScript?

Sé que desde la escuela hemos conocido los operadores, ya que son tan fáciles como recordar la suma (+), la resta (-), la división (/), y la multiplicación (*). Sin embargo, el día de hoy conocerás los operadores que utiliza el lenguaje de programación JavaScript. ¡Comencemos!.

Para este capítulo de hoy nos centraremos en conocer aquellos operadores que no conocimos en nuestra vida escolar.

Operador de asignación

Notemos que una asignación = es también un operador. Se enumera en la tabla de precedencia con la prioridad muy baja de 3.

Por eso, cuando asignamos una variable, como x = 2 * 2 + 1, los cálculos se realizan primero y luego = se evalúa, almacenando el resultado en x.

let x = 2 * 2 + 1;
alert( x ); // 5

Es posible encadenar tareas:

let a, b, c;
a = b = c = 2 + 2;
alert( a ); // 4
alert( b ); // 4
alert( c ); // 4

Las tareas encadenadas se evalúan de derecha a izquierda. En primer lugar la expresión más a la derecha 2 + 2 se evalúan entonces asignado a las variables de la izquierda: c, b y a. Al final, todas las variables comparten un solo valor.

Módulo %

El resto del operador (o módulo%), tiene una apariencia que puede engañarte, ya que no tiene nada que ver con porcentajes.

El resultado de a % b es el resto de la división entera de a por b.

Por ejemplo:

alert( 5 % 2 ); // 1 es el resto de 5 dividido por 2
alert( 8 % 3 ); // 2 es el resto de 8 dividido por 3
alert( 6 % 3 ); // 0 es el resto de 6 dividido por 3

Exponenciación **

El operador de exponenciación ** es una adición reciente al lenguaje JS.

Para un número natural b, el resultado a ** b se amultiplica por sí mismo b veces.

Por ejemplo:

alert( 2 ** 2 ); // 4 (2 * 2)
alert( 2 ** 3 ); // 8 (2 * 2 * 2)
alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2)

El operador trabaja para números no enteros de a y b también, por ejemplo:

alert( 4 ** (1/2) ); // 2 (el poder de 1/2 es el mismo que el de una raíz cuadrada, eso son las matemáticas.)
alert( 8 ** (1/3) ); // 2 (la potencia de 1/3 es la misma que la de una raíz cúbica)

Incremento/Decremento

Aumentar o disminuir un número en uno es una de las operaciones numéricas más comunes.

Entonces, hay operadores especiales para eso:

Incremento ++ aumenta una variable en 1:

let counter = 2;
counter++; // funciona igual que el contador = contador + 1, pero es más corto
alert( counter ); // 3

La — disminución disminuye una variable en 1:

let counter = 2;
counter--; // funciona igual que contador = contador - 1, pero es más corto
alert( counter ); // 1

Importante:
Incremento / decremento solo se puede aplicar a una variable. Un intento de usarlo en un valor como 5++ dará un error.

Los operadores ++ y — se pueden colocar tanto antes como despues de la variable.

Cuando el operador va después de la variable, se llama una “forma de sufijo”: counter++.
La “forma de prefijo” es cuando el operador está delante de la variable: ++counter.
Ambos registros hacen lo mismo: aumentar counter por 1.

¿Hay alguna diferencia? Sí, pero solo podemos verlo si usamos el valor devuelto de ++/–.

Vamos a aclarar. Como sabemos, todos los operadores devuelven un valor. Incremento / decremento no es una excepción aquí. El formulario de prefijo devuelve el nuevo valor, mientras que el formulario de postfix devuelve el valor anterior (antes del incremento / decremento).

Para ver la diferencia, aquí está el ejemplo:

let counter = 1;
let a = ++counter; // (*)
alert(a); // 2

Aquí en la línea, (*) el prefijo de llamada ++counter incrementa counter y devuelve el nuevo valor que es 2. Así que los alertes pectáculos 2.

Ahora vamos a usar el formulario postfix:

let counter = 1;
let a = counter++; // (*) cambia ++counter por counter++
alert(a); // 1
[/ph]
En la línea de (*) la postfix forma counter++ también incrementa counter, pero devuelve el antiguo valor (antes de incremento). Así que los alertes pectáculos 1.

Para resumir:

Si no se usa el resultado de incremento / decremento, entonces no hay diferencia en qué forma usar:

[php]let counter = 0;
counter++;
++counter;
alert( counter ); // 2, las líneas de arriba hicieron lo mismo

Si nos gustaría aumentar el valor y utilizar el resultado del operador en este momento, necesitamos el formulario de prefijo:

let counter = 0;
alert( ++counter ); // 1

Si nos gustaría incrementar, pero usar el valor anterior, entonces necesitamos el formulario de postfix:

let counter = 0;
alert( counter++ ); // 0

Operadores Bitwise

Los operadores bitwise tratan los argumentos como números enteros de 32 bits y trabajan en el nivel de su representación binaria.

Estos operadores no son específicos de JavaScript. Son compatibles en la mayoría de los lenguajes de programación.

La lista de operadores:

Y ( &)
O ( |)
XOR ( ^)
NO ( ~)
MAYÚS IZQUIERDA ( <<)
MAYÚS DERECHA ( >>)
CAMBIO A LA DERECHA CERO ( >>>)
Estos operadores se utilizan muy raramente. Para entenderlos, debemos profundizar en la representación de números de bajo nivel, y no sería óptimo hacerlo ahora. Especialmente porque no los necesitaremos pronto. Si tienes curiosidad, puedes investigar por ti mismo los Operadores de Bitwise. Sería más práctico hacer eso cuando surge una necesidad real.

Coma

El operador de coma , es uno de los operadores más raros e inusuales. A veces se usa para escribir código más corto, por lo que necesitamos saberlo para comprender qué está pasando.

El operador de coma nos permite evaluar varias expresiones, dividiéndolas con una coma ,. Cada uno de ellos se evalúa, pero solo se devuelve el resultado del último.

Por ejemplo:

let a = (1 + 2, 3 + 4);
alert( a ); // 7 (el resultado de 3 + 4)

Aquí, la primera expresión 1 + 2 se evalúa y su resultado se desecha, luego 3 + 4 se evalúa y se devuelve como resultado.

La coma tiene una precedencia muy baja.
Tenga en cuenta que el operador de coma tiene una prioridad muy baja, menor que =, por lo que los paréntesis son importantes en el ejemplo anterior.

Sin ellos: primero a = 1 + 2, 3 + 4 evalúa +, sumando los números a = 3, 7, luego el operador de asignación = asigna a = 3, y luego el número después de la coma 7 no se procesa de ninguna manera, por lo que se ignora.

¿Por qué necesitamos un operador que deseche todo, excepto la última parte?

A veces la gente lo usa en construcciones más complejas para poner varias acciones en una línea.

Por ejemplo:

// tres operaciones en una linea
for (a = 1, b = 3, c = a * b; a < 10; a++) {
...
}

Tales trucos se utilizan en muchos marcos de JavaScript, por eso los mencionamos. Pero generalmente no mejoran la legibilidad del código, por lo que deberíamos pensar bien antes de escribir así.