Operadores en JavaScript

En la vida real has visto cómo agregamos, restamos dos valores. Del mismo modo, en un lenguaje de programación, esta acción se realiza a través de la ayuda de operadores. En palabras simples, matemático o lógico Las operaciones se pueden realizar mediante el uso de operadores. Los operadores realizan estas funciones en un solo o múltiplo operandos para producir resultados. Aquí, los operandos son los valores de datos en los que se realizan las operaciones.

Como cualquier otro lenguaje de programación, JavaScript también utiliza varios operadores. Es útil, ya que facilita la tarea de comparar y manipular los valores.

En este artículo, discutiremos varios operadores en JavaScript junto con su uso y ejemplos.

Tipo de operadores en JavaScript

Hay varios operadores disponibles en JavaScript, algunos se enumeran a continuación:

1. Operadores aritméticos
2. Operadores de Asignación
3. Operadores de comparación
4. Operadores logicos
5. Operadores de cadenas

Entendamos a estos operadores uno por uno con ejemplos para una mejor comprensión.

Operadores aritméticos

Los operadores aritméticos ayudan a realizar todos los cálculos básicos matemáticos como suma, resta, multiplicación y división. Los siguientes son varios operadores aritméticos:

Operadores	Nombre
+	Suma
-	Sustracción
/	División
*	Multiplicación
De %	Resto
++	Aumento en 1
-	Disminuir en 1
**	Exponencial (poder)

Ejemplo de operadores aritméticos

Sea x = 3;
Sea y = 2;
// suma
consola.log ('x + y =', x + y); // 5
// resta
consola.log ('x - y =', x - y); // 1
// multiplicación
consola.log ('x * y =', x * y); // 6
// División
consola.log ('x / y =', x / y); // 1.5
// El resto de 3/2 será 1
consola.log ('x % y =', x % y); // 1
// aumentar por 1
consola.log ('++ x =', ++ x); // x será 4
consola.log ('x ++ =', x ++); // Impresiones 4 y luego aumentó a 5
consola.log ('x =', x); // 5
// disminuir por 1
consola.log ('-x =', --x); // x será 4
consola.log ('x-- =', x--); // imprime 4 y luego disminuyó a 3
consola.log ('x =', x); // 3
// exponenciación
consola.log ('x ** y =', x ** y); // 3 potencia de 2 es 9

Operadores de Asignación

En JavaScript, los operadores de asignación se utilizan para asignar algunos valores a una variable. Por ejemplo:

Sea x = 3;
const y = 5;

Aquí, x e y son variables que se asignan los valores 3 y 5 respectivamente. Los siguientes son algunos operadores de asignación:

Operadores	Nombre
=	Asignación
+=	Asignación de adición
-=	Asignación de sustracción
*=	Asignación de multiplicación
/=	Asignación de división
%=	Asignación del resto
** =	Asignación de exponencia

Ejemplo de operadores de asignación

Sea x = 3; // Valor de asignación usando el operador de asignación
// asignación de adición
consola.log ('x += 3', x += 3); // 6, ahora x = 6
// Asignación de sustracción
consola.log ('x -= 2', x -= 2); // 4, ahora x = 4
// Asignación de multiplicación
consola.log ('x *= 2', x *= 2); // 8, ahora x = 8
// Asignación de división
consola.log ('x /= 2', x /= 2); // 4
// Asignación del resto
consola.log ('x %= 2', x %= 2); // 0
// asignación de exponenciación
Sea x = 5;
consola.log ('x ** = 2', x ** = 2); // 25

Operadores de comparación

Los operadores de comparación funcionan comparando dos valores y devolviendo verdadero y falso:

Operadores	Nombre
==	Igual a
!=	No es igual a
===	Estricto igual a
!==	Estricto no igual a
>	Mas grande que
<	Menos que
> =	Mayor o igual a
<=	Menos o igual a

Ejemplo de operadores de comparación:

// operador igual
consola.log (3 == 2); // FALSO
consola.log (3 == '3'); // verdadero
// no es igual operador
consola.registro (3 != 4); // verdadero
consola.Log ('Mundo' != 'mundo'); // FALSO
// operador estricto igual
consola.log (7 === '7'); // FALSO
consola.log (6 === 6); // verdadero
// Operador estricto no igual
consola.registro (8 !== '8'); // verdadero
consola.registro (3 !== 3); // FALSO

Operadores logicos

Los operadores lógicos se utilizan para manejar operaciones lógicas en valores de datos, como resultado, devuelven un valor booleano:

Operadores	Nombre
&&	Lógico y
||	Lógico o
!	Lógico no

Ejemplo de operadores lógicos:

// lógico y
consola.log (7 == 7 && 7 == 7); // verdadero, y el operador funciona cuando ambas declaraciones dadas son verdaderas
consola.Log (7 == 7 && 7 == 87!= 7); // falso, una de las afirmaciones no es verdadera
// lógico o
consola.log (7 == 7 || 7!= 7); // Verdadero, o el operador funciona cuando una de las dos declaraciones dadas es verdadera
// lógico no
consola.registro(!7 == 7); // falso, hubiera sido cierto si la expresión no fuera cierta.

Operadores de cadenas

Los operadores de cadenas se utilizan para unir dos o más cadenas o un número y una cadena.

Ejemplo de operadores de cadenas:

Sea x = 5 + 25; // 30
Sea y = "5" + 5; // 55
Sea z = "mundo" + 5; // World5

Conclusión

Los operadores de typeOf en JavaScript se utilizan para decir el programa sobre qué operación matemática se debe realizar. En este artículo, aprendimos varios operadores en JavaScript, cómo se usan y su funcionalidad. Los operadores ayudan a los usuarios a realizar tareas difíciles con facilidad, y lógicamente.

Cada operador específico está disponible para que el usuario implemente una funcionalidad particular en su programa. Espero que esto te ayude con una mejor comprensión de los operadores en JavaScript, y en general, como los conceptos centrales en cada lenguaje de programación están interconectados.