operatoren 'foundations sind wichtig für die Durchführung mathematischer Operationen, logischer Vergleiche, Datenmanipulation und Flusskontrolle in einem Programm. Lernen wir sie mit JavaScript ?

Haupttypen von JavaScript -Operatoren:

1.

Arithmetische Operatoren

werden verwendet, um mathematische Operationen zwischen Zahlen auszuführen. Diese Operatoren umfassen:

• addition () : zwei Werte hinzufügen.
subtraction (-)
• : Subtrahieren Sie den zweiten Wert des ersten. multiplication (*)
: multipliziert zwei Werte.
• Abteilung (/) : Teilen Sie den ersten Wert durch den zweiten.
• modul (%) : Gibt den Rest der Teilung zwischen zwei Werten zurück.
Exponence (`
• `) **: Erhöht den ersten Wert für die Macht des zweiten. Beispiel:
• sei a = 10; Sei b = 3; console.log (a b); // Addition: 13 console.log (a - b); // Subtraktion: 7 console.log (a * b); // Multiplikation: 30 console.log (a / b); // Division: 3.333 console.log (a % b); // Modul: 1 (Rest der Teilung von 10 bis 3) console.log (a ** b); // Exponenz: 1000 (10 auf 3 erhöht) 2.
Attribution Operatoren

Attributionsoperatoren werden verwendet, um Variablen Werte zuzuweisen. Der häufigste Operator ist "=", aber es gibt Kombinationen mit arithmetischen Operatoren, die Code erleichtern.

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)

attribution (=) : ordnet der Variablen einen Wert zu.

Attribution mit Addition (=)

: Summe und schreibt das Ergebnis der Variablen zu.

anziehen mit subtration (-=)
• : subtrahieren und ordnen das Ergebnis der Variablen zu. Attribution mit Multiplation (*=)
: multipliziert und ordnet das Ergebnis der Variablen zu.
• Attribut mit der Abteilung (/=) : Dividiert und ordnet das Ergebnis der Variablen zu.
• Beispiel: sei 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); // Endergebnis: 12
• 3. Vergleich Operatoren
• Diese Operatoren vergleichen zwei Werte und geben einen Wert zurück boolean (
true

oder

false

). Sie werden in Kontrollstrukturen weit verbreitet, wie

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

und

während .

Equality (==) : Überprüfen Sie, ob die Werte gleich sind, ohne den Typ zu überprüfen. identity (===) : Überprüfen Sie, ob die Werte und Typen genau gleich sind. unterschiedlich (! =) : Überprüfen Sie, ob die Werte unterschiedlich sind. Strict Differenz (! ==) : Überprüfen Sie, ob die Werte und Typen unterschiedlich sind.

größer als (>)
• : Überprüfen Sie, ob der linke Wert höher ist. kleiner als (: Überprüfen Sie, ob der linke Wert niedriger ist.
• Greater oder Equal (> =) : Überprüfen Sie, ob der linke Wert größer oder gleich ist.
• kleiner oder gleich (: Überprüfen Sie, ob der linke Wert kleiner oder gleich ist.
Beispiel:
• lass num1 = 10; Sei num2 = '10'; console.log (num1 == num2); // true (vergleicht nur den Wert) console.log (num1 === num2); // false (vergleicht Wert und Typ) console.log (num1! = num2); // false (Werte sind gleich) console.log (num1! == num2); // true (Typen sind unterschiedlich) console.log (num1> 5); // WAHR console.log (num1
4.
• Logische Operatoren
Logikoperatoren werden verwendet, um boolesche (wahre oder falsche) Ausdrücke zu kombinieren und sind für die Flusskontrolle wesentlich.
• und (&&)
: Gibt wahr, wenn beide Ausdrücke wahr sind.
• oder (||) : Gibt wahr, wenn mindestens einer der Ausdrücke wahr ist.
• nicht (!) : Umkehrt den booleschen Wert eines Ausdrucks.
Beispiel:

lass a = true; Sei b = falsch; console.log (a && b); // falsch (und: beide müssen wahr sein) console.log (a || b); // wahr (oder: mindestens einer muss wahr sein) console.log (! a); // falsch (nicht: Umkehrt den Wert von '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 

 Diese Bediener arbeiten mit nur einem Betrieb und können den Wert einer Variablen ändern oder zurückgeben.



 increation () 
: Fügt 1 zum Wert der Variablen hinzu.

decrement (-)
• : Subtrahiere 1 des Werts der Variablen. Beispiel:
• lass Accountant = 5; Buchhalter; // Inkremente: Accountant = 6 console.log (Buchhalter); // Ausgabe: 6 Schalter--; // Dekrement: Buchhalter = 5 console.log (Buchhalter); // Ausgabe: 5 Es ist wichtig, sich daran zu erinnern, dass die Reihenfolge dieser Operatoren das Verhalten der Variablen beeinflusst. Es gibt zwei Möglichkeiten, sie zu verwenden:
• vorangestellt x oder -x:
verwendet den aktuellen Wert der Variablen im Ausdruck und macht dann die Erhöhung/Dekrementierung.

posfixed x oder x-:

erhöht/dekretiert den Wert, bevor er im Ausdruck verwendet wird (wie schon einmal veranschaulicht).

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')

Erfahren Sie mehr, indem Sie hier klicken

6. ternäre Operatoren

Der ternäre Operator ist eine vereinfachte Form eines if, um Werte basierend auf einer Bedingung zuzuweisen. Ist Ihre Struktur eine Bedingung? Value_se_verdeiro: value_se_falso.

Beispiel:
• Lass uns Alter = 18; Sei Status = (Alter> = 18)? 'Oberes Alter': 'Verständnis'; console.log (Status); // Ausgabe: 'Oberes Alter'
Erfahren Sie hier mehr über ternäre Operatoren
• 7. Concatenar Strings ()

Der Additionsoperator () kann auch an

verkettet werden

let contador = 5;

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

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

Beispiel:

lass vorname = "maria"; lass SecondName = "Silva"; Lassen Sie den Namen complete = vorname "zweitlaufen; console.log (namenecomplete); // Ausfahrt: "Maria Silva"

• 8. Bitgewise -Operatoren (Bits a Bits)
• Diese Operatoren führen Bits -Level -Operationen (0S und 1s) aus, die normalerweise in der Programmierung auf niedriger Ebene verwendet werden, z. B. Hardwareoperationen. Es ist nicht üblich, diese Art von Operatoren zu verwenden.
und bit ein bit (&)

oder bit ein bit (|)

xor bit ein bit (^)

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

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

Verschiebung links (

richtig Verschiebung (>>)

Beispiel:

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

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

Verständnis, wie die Betreiber arbeiten, ist entscheidend für das Erstellen von Programmen, die Berechnungen durchführen, Vergleiche durchführen und den Fluss des Codes effizient steuern.