Operadores em JavaScript

Na vida real, você viu como adicionamos, subtrair dois valores. Da mesma forma, em uma linguagem de programação, essa ação é executada através da ajuda de operadores. Em palavras simples, matemático ou lógico As operações podem ser realizadas através do uso de operadores. Os operadores desempenham essas funções em único ou múltiplo operando para produzir resultados. Aqui, operando são os valores de dados sobre quais operações estão sendo executadas.

Como qualquer outra linguagem de programação, o JavaScript também usa vários operadores. É útil, pois facilita a comparação e a manipulação de valores para o usuário.

Neste artigo, discutiremos vários operadores em JavaScript junto com seu uso e exemplos.

Tipo de operadores em JavaScript

Existem vários operadores disponíveis no JavaScript, alguns estão listados abaixo:

1. Operadores aritméticos
2. Operadores de atribuição
3. Operadores de comparação
4. Operadores lógicos
5. Operadores de string

Vamos entender esses operadores, um por um com exemplos para uma melhor compreensão.

Operadores aritméticos

Os operadores aritméticos ajudam a realizar todos os cálculos básicos matemáticos, como adição, subtração, multiplicação e divisão. A seguir, vários operadores aritméticos:

Operadores	Nome
+	Adição
-	Subtração
/	Divisão
*	Multiplicação
%	Restante
++	Aumentar em 1
-	Diminuir em 1
**	Exponencial (poder)

Exemplo de operadores aritméticos

Seja x = 3;
Seja y = 2;
// Adição
console.log ('x + y =', x + y); // 5
// subtração
console.log ('x - y =', x - y); // 1
// multiplicação
console.log ('x * y =', x * y); // 6
// Divisão
console.log ('x / y =', x / y); // 1.5
// restante de 3/2 será 1
console.log ('x % y =', x % y); // 1
// aumenta em 1
console.log ('++ x =', ++ x); // x será 4
console.log ('x ++ =', x ++); // imprime 4 e depois aumentou para 5
console.log ('x =', x); // 5
// diminui em 1
console.log ('-x =', --x); // x será 4
console.log ('x-- =', x--); // imprime 4 e depois diminuiu para 3
console.log ('x =', x); // 3
// exponenciação
console.log ('x ** y =', x ** y); // 3 Poder de 2 é 9

Operadores de atribuição

No JavaScript, os operadores de atribuição são usados ​​para atribuir alguns valores a uma variável. Por exemplo:

Seja x = 3;
const y = 5;

Aqui, x e y são variáveis ​​que são atribuídas valores 3 e 5, respectivamente. A seguir, alguns operadores de atribuição:

Operadores	Nome
=	Atribuição
+=	Atribuição de adição
-=	Atribuição de subtração
*=	Atribuição de multiplicação
/=	Atribuição de divisão
%=	Atribuição de restante
** =	Atribuição de exponenciação

Exemplo de operadores de atribuição

Seja x = 3; // atribuindo valor usando o operador de atribuição
// Tarefa de adição
console.log ('x += 3', x += 3); // 6, agora x = 6
// atribuição de subtração
console.log ('x -= 2', x -= 2); // 4, agora x = 4
// Atribuição de multiplicação
console.log ('x *= 2', x *= 2); // 8, agora x = 8
// Tarefa de divisão
console.log ('x /= 2', x /= 2); // 4
// atribuição restante
console.log ('x %= 2', x %= 2); // 0
// atribuição de exponenciação
Seja x = 5;
console.log ('x ** = 2', x ** = 2); // 25

Operadores de comparação

Os operadores de comparação trabalham comparando dois valores e retornando verdadeiro e falso:

Operadores	Nome
==	Igual a
!=	Não é igual a
===	Estrito é igual a
!==	Rigoroso não igual a
>	Maior que
<	Menor que
> =	Maior ou igual a
<=	Menor ou igual a

Exemplo de operadores de comparação:

// Operador igual
console.log (3 == 2); // false
console.log (3 == '3'); // verdadeiro
// Não é igual o operador
console.log (3 != 4); // verdadeiro
console.log ('mundo' != 'mundo'); // false
// Strito Operador igual
console.log (7 === '7'); // false
console.log (6 === 6); // verdadeiro
// rigoroso operador não igual
console.log (8 !== '8'); // verdadeiro
console.log (3 !== 3); // false

Operadores lógicos

Os operadores lógicos são usados ​​para lidar com operações lógicas nos valores de dados, como resultado, eles retornam um valor booleano:

Operadores	Nome
&&	Lógico e
||	Lógico ou
!	Lógico não

Exemplo de operadores lógicos:

// lógico e
console.log (7 == 7 && 7 == 7); // verdadeiro, e o operador funciona quando as duas declarações são verdadeiras
console.log (7 == 7 && 7 == 87!= 7); // false, uma das afirmações não é verdadeira
// lógico ou
console.log (7 == 7 || 7!= 7); // verdadeiro, ou o operador funciona quando uma das duas declarações é verdadeira
// lógico não
console.registro(!7 == 7); // false, teria sido verdade se a expressão não fosse verdadeira.

Operadores de string

Os operadores de string são usados ​​para ingressar em duas ou mais strings ou um número e uma string.

Exemplo de operadores de string:

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

Conclusão

Os operadores do tipo OF. Neste artigo, aprendemos vários operadores em JavaScript, como eles são usados ​​e sua funcionalidade. Os operadores ajudam os usuários a executar tarefas difíceis com facilidade e logicamente.

Cada operador específico está disponível para o usuário implementar uma funcionalidade específica em seu programa. Espero que isso ajude você a entender melhor os operadores em JavaScript e, em geral.