Operadores en Javascript

Muchos operadores nos son conocidos desde la escuela. Son suma +, una multiplicación *, una resta – y así sucesivamente.

En este capítulo nos concentramos en aspectos que no están cubiertos por la aritmética escolar.

Términos: “unario”, “binario”, “operando”

Antes de continuar, comprendamos la terminología común.

Un operando – es lo que se aplica a los operadores. Por ejemplo, en la multiplicación 5 * 2 hay dos operandos: el operando izquierdo es 5, y el operando derecho es 2. A veces las personas dicen “argumentos” en lugar de “operandos”.

Un operador es unario si tiene un solo operando. Por ejemplo, la negación unaria – invierte el signo del número:

let ​​x = 1;
x = -x;
alert (x); // -1, se aplicó negación unaria

Un operador es binario si tiene dos operandos. El mismo menos existe en la forma binaria también:

let ​​x = 1, y = 3;
alert (y - x); // 2, valores binarios menos resta

Formalmente, estamos hablando de dos operadores diferentes aquí: la negación unaria (operando único, invierte el signo) y la resta binaria (dos operandos, resta).

Concatenación de cuerdas, binario +

Ahora veamos las características especiales de los operadores de JavaScript que están más allá de la aritmética escolar.

Por lo general, el operador más + suma números.

Pero si el binario + se aplica a las cadenas, las fusiona (concatena):

let s = "my" + "string";
alert (s); // mystring

Tenga en cuenta que si alguno de los operandos es una cadena, el otro también se convierte en una cadena.

Por ejemplo:

alert ('1' + 2); // "12"
alert (2 + '1'); // "21"

Mira, no importa si el primer operando es una cadena o el segundo. La regla es simple: si cualquiera de los operandos es una cadena, entonces convierte la otra en una cadena también.

Sin embargo, tenga en cuenta que las operaciones se ejecutan de izquierda a derecha. Si hay dos números seguidos por una cadena, los números se agregarán antes de convertirse en una cadena:

alert (2 + 2 + '1'); // "41" y no "221"

La concatenación y conversión de cadenas es una característica especial del binario +. Otros operadores aritméticos trabajan solo con números. Siempre convierten sus operandos en números.

Por ejemplo, resta y división:

alert (2 - '1'); // 1
alert ('6' / '2'); // 3

Conversión numérica, unaria +

El plus + existe en dos formas. La forma binaria que usamos arriba y la forma unaria.

El + unario o, en otras palabras, el operador + aplicado a un solo valor, no hace nada con los números, pero si el operando no es un número, entonces se convierte en él.

Por ejemplo:

// Sin efecto en los números.
let ​​x = 1;
alert (+ x); // 1

let ​​y = -2;
alert (+ y); // -2

// Convierte no números
alert (+ true); // 1
alert (+ ""); // 0

En realidad, hace lo mismo que Número (…), pero es más corto.

La necesidad de convertir cadenas a números surge muy a menudo. Por ejemplo, si estamos obteniendo valores de los campos de formulario HTML, entonces normalmente son cadenas.

¿Y si queremos sumarlos?

El binario + los agregaría como cadenas:

let manzanas = "2";
let naranjas = "3";

alert (manzanas + naranjas); // "23", el binario más concatena cadenas

Si queremos tratarlos como números, entonces podemos convertir y luego sumar:

let manzanas = "2";
let naranjas = "3";

// ambos valores se convierten en números antes del binario más
alert (+ manzanas + + naranjas); // 5

// la variante más larga
// alert (Number (manzanas) + Number (naranjas)); // 5

Desde el punto de vista de un matemático, la abundancia de ventajas puede parecer extraña. Pero desde el punto de vista de un programador, no hay nada especial: las ventajas unarias se aplican primero, convierten las cadenas en números y luego el binario más las resume.

¿Por qué se aplican ventajas unarias a los valores anteriores al binario? Como veremos, eso se debe a su precedencia.

Asignación

Notemos que una asignación = es también un operador.

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. Primero se evalúa la expresión más a la derecha 2 + 2 y luego se asigna a las variables de la izquierda: c, b y a. Al final, todas las variables comparten un solo valor.

Residuo o resto %

El operador % a pesar de su apariencia no tiene relación con los 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 un resto de 5 dividido por 2
alert (8% 3); // 2 es un resto de 8 dividido por 3
alert (6% 3); // 0 es un resto de 6 dividido por 3

Exponente **

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

Para un número natural b, el resultado de a ** b es multiplicado 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 también trabaja para números no enteros, por ejemplo:

alert (4 ** (1/2)); // 2 (la potencia de 1/2 es lo mismo que una raíz cuadrada)
alert (8 ** (1/3)); // 2 (potencia de 1/3 es lo mismo que 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 ++ incrementa una variable en 1:

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

Disminución — disminuye una variable en 1:

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

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

Los operadores ++ y – pueden colocarse tanto antes como antes de la variable.

Cuando el operador persigue la variable, se denomina “forma de postfijo”: contador ++.
La “forma de prefijo” es cuando el operador está delante de la variable: ++ contador.

Ambos registros hacen lo mismo: aumenta el contador en 1.

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 (~)
• MOVER IZQUIERDA (<<)
• MOVER DERECHA (>>)

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.

Modificar en el sitio

A menudo necesitamos aplicar un operador a una variable y almacenar el nuevo resultado en ella.

Por ejemplo:

let ​​n = 2;
n = n + 5;
n = n * 2;

Esta notación se puede acortar utilizando los operadores + = y * =:

let ​​n = 2;
n + = 5; // ahora n = 7 (igual que n = n + 5)
n * = 2; // ahora n = 14 (igual que n = n * 2)
alert (n); // 14

Existen operadores cortos de “modificar y asignar” para todos los operadores aritméticos y bitwise: / =, – = etc.

Dichos operadores tienen la misma prioridad que una asignación normal, por lo que se ejecutan después de la mayoría de los otros cálculos:

let ​​n = 2;
n * = 3 + 5;
alert (n); // 16 (la parte derecha se evaluó primero, igual que n * = 8)

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 lo que está sucediendo.

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 se evalúa 3 + 4 y se devuelve como resultado.

 

---

Written by Tutor