Los fundamentos de los operadores son ​​esenciales para realizar operaciones matemáticas, comparaciones lógicas, manipulación de datos y control de flujo dentro de un programa. Aprendamos usando javascript ?

Tipos principales de operadores de JavaScript:

1.

operadores aritméticos

se utilizan para realizar operaciones matemáticas entre números. Estos operadores incluyen:

• además () : agregue dos valores.
subtracción (-)
• : reste el segundo valor del primero. multiplicación (*)
: multiplica dos valores.
• división (/) : divide el primer valor por el segundo.
• módulo (%) : devuelve el resto de la división entre dos valores.
Exponencia (`
• `) **: eleva el primer valor al poder del segundo. Ejemplo:
• dejar a = 10; Sea B = 3; console.log (a b); // Adición: 13 console.log (a - b); // resta: 7 console.log (a * b); // Multiplicación: 30 console.log (a / b); // División: 3.333 console.log (a % b); // Módulo: 1 (resto de la división de 10 por 3) console.log (a ** b); // Exponencia: 1000 (10 elevado a 3) 2.
operadores de atribución

Los operadores de atribución se utilizan para asignar valores a variables. El operador más común es "=", pero hay combinaciones con operadores aritméticos que facilitan el código.

let a = 10;
let b = 3;

console.log(a   b);  // Adição: 13
console.log(a - b);  // Subtração: 7
console.log(a * b);  // Multiplicação: 30
console.log(a / b);  // Divisão: 3.333
console.log(a % b);  // Módulo: 1 (resto da divisão de 10 por 3)
console.log(a ** b); // Exponenciação: 1000 (10 elevado a 3)

atribution (=) : atribuye un valor a la variable.

Atribución con adición (=)

: suma y atribuye el resultado a la variable.

atraer con subtratación (-=)
• : reste y atribuya el resultado a la variable. Atribución con multiplicación (*=)
: multiplica y atribuye el resultado a la variable.
• atributo con la división (/=) : divide y atribuye el resultado a la variable.
• Ejemplo: Sea x = 5; x = 3; // x = x 3 -> 8 x -= 2; // x = x - 2 -> 6 x *= 4; // x = x * 4 -> 24 x /= 2; // x = x / 2 -> 12 console.log (x); // Resultado final: 12
• 3. Operadores de comparación
• Estos operadores comparan dos valores y devuelven un valor boolean (
true

o

false

). Se usan ampliamente en estructuras de control, como

let x = 5;
x  = 3;  // x = x   3 -> 8
x -= 2;  // x = x - 2 -> 6
x *= 4;  // x = x * 4 -> 24
x /= 2;  // x = x / 2 -> 12

console.log(x);  // Resultado final: 12

, y

while .

Igualdad (==) : verifique si los valores son los mismos, sin verificar el tipo. identidad (===) : verifique si los valores y los tipos son exactamente los mismos. diferente (! =) : verifique si los valores son diferentes. Strict Difference (! ==) : verifique si los valores y los tipos son diferentes.

mayor que (>)
• : verifique si el valor izquierdo es más alto. más pequeño que (: verifique si el valor izquierdo es más bajo.
• mayor o igual (> =) : verifique si el valor izquierdo es mayor o igual.
• más pequeño o igual (: verifique si el valor izquierdo es más pequeño o igual.
Ejemplo:
• dejar num1 = 10; Dejar num2 = '10'; console.log (num1 == num2); // Verdadero (solo compara el valor) console.log (num1 === num2); // falso (compara el valor y el tipo) console.log (num1! = num2); // falsos (los valores son iguales) console.log (num1! == num2); // Verdadero (los tipos son diferentes) console.log (num1> 5); // Verdadero console.log (num1
4.
• operadores lógicos
Los operadores lógicos se utilizan para combinar expresiones booleanas (verdaderas o falsas) y son esenciales para el control de flujo.
• y (&&)
: devuelve verdadero si ambas expresiones son verdaderas.
• o (||) : devuelve verdadero si al menos una de las expresiones es verdadera.
• no (!) : invierte el valor booleano de una expresión.
Ejemplo:

dejar a = verdadero; Sea B = falso; console.log (a && b); // falso (y: ambos deben ser verdaderos) console.log (a || b); // Verdadero (o: al menos uno debe ser verdad) console.log (! a); // falso (no: invierte el valor de 'a')

let num1 = 10;
let num2 = '10';

console.log(num1 == num2);   // true (só compara o valor)
console.log(num1 === num2);  // false (compara valor e tipo)
console.log(num1 != num2);   // false (valores são iguais)
console.log(num1 !== num2);  // true (tipos são diferentes)
console.log(num1 > 5);       // true
console.log(num1 

 Estos operadores funcionan con solo uno operando y pueden modificar o devolver el valor de una variable.



 increment () 
: agrega 1 al valor de la variable.

disminución (-)
• : reste 1 del valor de la variable. Ejemplo:
• dejar contador = 5; Contador; // incrementos: contador = 6 console.log (contador); // Salida: 6 encimera--; // disminución: contador = 5 console.log (contador); // Salida: 5 Es importante recordar que el orden de estos operadores influye en el comportamiento de la variable. Hay dos formas de usarlos:
• prefijo x o -x:
usa el valor actual de la variable en la expresión y luego hace que el aumento/disminución.

posfixed x o x-:

aumenta/decretan el valor antes de usarlo en la expresión (como se ejemplificó antes).

let a = true;
let b = false;

console.log(a && b);  // false (AND: ambos devem ser verdadeiros)
console.log(a || b);  // true (OR: ao menos um deve ser verdadeiro)
console.log(!a);      // false (NOT: inverte o valor de 'a')

Aprenda más haciendo clic aquí

6. operadores ternarios

El operador ternario es una forma simplificada de un IF para asignar valores basados ​​en una condición. ¿Es su estructura una condición? Value_se_verdeiro: value_se_falso.

Ejemplo:
• vamos a ser = 18; STATSE = (Age> = 18)? 'Edad superior': 'comprensión'; console.log (estado); // Salida: 'Age superior'
Aprenda más sobre los operadores ternarios aquí
• 7. Concatenar Strings ()

El operador adicional () también se puede usar para

concatenate strings

let contador = 5;

contador  ;  // Incrementa: contador = 6
console.log(contador);  // Saída: 6

contador--;  // Decrementa: contador = 5
console.log(contador);  // Saída: 5

Ejemplo:

Let Fird Name = "Maria"; Let SecondName = "Silva"; Deje el nombre completo = primer nombre "Segundo en ejecución; console.log (namecomplete); // Salir: "Maria Silva"

• 8. operadores de bit (bits a bits)
• Estos operadores realizan operaciones de nivel bits (0s y 1s), generalmente utilizados en programación de bajo nivel, como las operaciones de hardware. No es común usar este tipo de operadores.
y bit un bit (&)

o bit un bit (|)

xor bit un bit (^)

let idade = 18;
let status = (idade >= 18) ? 'Maior de idade' : 'Menor de idade';

console.log(status);  // Saída: 'Maior de idade'

desplazamiento en la izquierda (

desplazamiento correcto (>>)

Ejemplo:

let primeiroNome = "Maria";
let segundoNome = "Silva";

let nomeCompleto = primeiroNome   " "   segundoNome;
console.log(nomeCompleto);  // Saída: "Maria Silva"

Comprender cómo funcionan los operadores es fundamental para construir programas que realicen cálculos, comparaciones y controlen el flujo del código de manera eficiente.