Operator-Grundlagen

Die Grundlagen von Operatoren in der Programmierung sind für die Durchführung mathematischer Operationen, logischer Vergleiche, Datenmanipulation und Flusskontrolle innerhalb eines Programms von wesentlicher Bedeutung. Lernen wir sie mit JavaScript?

Haupttypen von Operatoren in JavaScript:

1. Arithmetische Operatoren

Sie werden verwendet, um mathematische Operationen zwischen Zahlen durchzuführen. Zu diesen Operatoren gehören:

• Addition ( ): Addiert zwei Werte.
• Subtraktion (-): Subtrahiert den zweiten Wert vom ersten.
• Multiplikation (*): Multipliziert zwei Werte.
• Division (/): Dividiert den ersten Wert durch den zweiten.
• Modul (%): Gibt den Rest der Division zwischen zwei Werten zurück.
• Potenzierung (``)**: Potenziert den ersten Wert mit dem zweiten.

Beispiel:

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)

2. Zuweisungsoperatoren

Zuweisungsoperatoren werden verwendet, um Variablen Werte zuzuweisen. Der gebräuchlichste Operator ist „=", aber es gibt Kombinationen mit arithmetischen Operatoren, die den Code einfacher machen.

• Zuweisung (=): Weist der Variablen einen Wert zu.
• Zuweisung mit Zusatz ( =): Addiert das Ergebnis und weist es der Variablen zu.
• Zuweisung mit Subtraktion (-=): Subtrahiert das Ergebnis und weist es der Variablen zu.
• Zuweisung mit Multiplikation (*=): Multipliziert und weist das Ergebnis der Variablen zu.
• Zuweisung mit Division (/=): Dividiert und weist das Ergebnis der Variablen zu.

Beispiel:

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

3. Vergleichsoperatoren

Diese Operatoren vergleichen zwei Werte und geben einen booleschen Wert zurück (wahr oder falsch). Sie werden häufig in Kontrollstrukturen wie if und while.

verwendet

• Gleichheit (==): Prüft, ob die Werte gleich sind, ohne den Typ zu überprüfen.
• Identität (===): Prüft, ob die Werte und Typen genau gleich sind.
• Unterschiedlich (!=): Prüft, ob die Werte unterschiedlich sind.
• Strenge Differenz (!==): Prüft, ob Werte und Typen unterschiedlich sind.
• Größer als (>): Prüft, ob der Wert auf der linken Seite größer ist.
• Kleiner als (<): Prüft, ob der Wert links kleiner ist.
• Größer oder gleich (>=): Prüft, ob der Wert auf der linken Seite größer oder gleich ist.
• Kleiner oder gleich (<=): Prüft, ob der Wert auf der linken Seite kleiner oder gleich ist.

Beispiel:

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)

4. Logische Operatoren

Logische Operatoren werden zum Kombinieren boolescher Ausdrücke (wahr oder falsch) verwendet und sind für die Flusskontrolle unerlässlich.

• AND ( && ): Gibt true zurück, wenn beide Ausdrücke wahr sind.
• OR ( || ): Gibt true zurück, wenn mindestens einer der Ausdrücke wahr ist.
• NICHT ( ! ): Kehrt den booleschen Wert eines Ausdrucks um.

Beispiel:

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





  
  
  5. Unäre Operatoren


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



Inkrement ( ): Addiert 1 zum Variablenwert.

Dekrementieren (--): Subtrahiere 1 vom Variablenwert.



  
  
  Beispiel:




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 <= 10);     // true




Es ist wichtig zu bedenken, dass die Reihenfolge dieser Operatoren das Verhalten der Variablen beeinflusst. Es gibt zwei Möglichkeiten, sie zu verwenden:



Vorangestelltes x oder --x:Verwenden Sie den aktuellen Wert der Variablen im Ausdruck und erhöhen/dekrementieren Sie ihn dann.

Posifixiertes x oder x--: Erhöht/dekrementiert den Wert, bevor er im Ausdruck verwendet wird (wie zuvor veranschaulicht).


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_if_true : value_if_false.


  
  
  Beispiel:




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 hier mehr über ternäre Operatoren


  
  
  7. String-Verkettungsoperator ( )


Der Additionsoperator ( ) kann auch verwendet werden, um Zeichenfolgen zu verketten (Texte zu verbinden).

  
  
  Beispiel:




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)





  
  
  8. Bitweise Operatoren (Bitweise)


Diese Operatoren führen Operationen auf Bitebene (0en und 1en) aus, die im Allgemeinen in der Programmierung auf niedriger Ebene verwendet werden, beispielsweise bei Hardwareoperationen. Es ist nicht üblich, diese Art von Operatoren zu verwenden.


UND Stück für Stück (&)
ODER Stück für Stück (|)
XOR Bit für Bit (^)
NICHT Stück für Stück (~)
Linksverschiebung (<<)
Nach rechts verschieben (>>)

Beispiel:

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

Das Verständnis der Funktionsweise von Operatoren ist von grundlegender Bedeutung für die Erstellung von Programmen, die Berechnungen und Vergleiche durchführen und den Codefluss effizient steuern.

Das obige ist der detaillierte Inhalt vonOperator-Grundlagen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!