In diesem Tutorial erfahren Sie anhand von Beispielen, welche Operatoren in JavaScript verfügbar sind und wie Sie sie verwenden.
Was ist ein Operator?
In JavaScript ist ein Operator ein spezielles Symbol, mit dem Operationen an Operanden (Werten und Variablen) ausgeführt werden. Beispielsweise,
2 + 3; // 5
Hier +ist ein Operator, der Additionen ausführt, und 2und 3sind Operanden.
JavaScript-Operatortypen
Hier ist eine Liste der verschiedenen Operatoren, die Sie in diesem Tutorial lernen werden.
- Zuweisungsoperatoren
- Rechenzeichen
- Vergleichsoperatoren
- Logische Operatoren
- Bitweise Operatoren
- String-Operatoren
- Andere Betreiber
JavaScript-Zuweisungsoperatoren
Zuweisungsoperatoren werden verwendet, um Variablen Werte zuzuweisen . Beispielsweise,
const x = 5;
Hier wird der =Operator verwendet, um 5der Variablen einen Wert zuzuweisen x.
Hier ist eine Liste häufig verwendeter Zuweisungsoperatoren:
| Operator | Name | Beispiel |
|---|---|---|
= | Aufgabenverwalter | a = 7; // 7 |
+= | Zusatzzuordnung | a += 5; // a = a + 5 |
-= | Subtraktionszuordnung | a -= 2; // a = a - 2 |
*= | Multiplikationszuweisung | a *= 3; // a = a * 3 |
/= | Abteilungszuordnung | a /= 2; // a = a / 2 |
%= | Restzuordnung | a %= 2; // a = a % 2 |
**= | Exponentiation Assignment | a **= 2; // a = a**2 |
Hinweis: Der häufig verwendete Zuweisungsoperator ist =. Sie werden andere Zuweisungsoperatoren verstehen wie +=, -=, *=usw. , wenn wir arithmetische Operatoren lernen.
JavaScript-Arithmetikoperatoren
Arithmetische Operatoren werden verwendet, um arithmetische Berechnungen durchzuführen . Beispielsweise,
const number = 3 + 5; // 8
Hier wird der +Operator verwendet, um zwei Operanden hinzuzufügen.
| Operator | Name | Beispiel |
|---|---|---|
+ | Zusatz | x + y |
- | Subtraktion | x - y |
* | Multiplikation | x * y |
/ | Teilung | x / y |
% | Rest | x % y |
++ | Inkrement (inkrementiert um 1) | ++x oder x++ |
-- | Dekrement (Dekrement um 1) | --x oder x-- |
** | Potenzierung (Macht) | x ** y |
Beispiel 1: Arithmetische Operatoren in JavaScript
let x = 5; let y = 3; // addition console.log('x + y = ', x + y); // subtraction console.log('x - y = ', x - y); // multiplication console.log('x * y = ', x * y); // division console.log('x / y = ', x / y); // remainder console.log('x % y = ', x % y); // increment console.log('++x = ', ++x); // x is now 6 console.log('x++ = ', x++); // x returns 6 and then increases by 1 console.log('x = ', x); // decrement console.log('--x = ', --x); // x is now 6 console.log('x-- = ', x--); // x returns 6 and then increases by 1 console.log('x = ', x); //exponentiation console.log('x ** y =', x ** y);
Besuchen Sie ++ und - operator, um mehr zu erfahren.
Ausgabe
x + y = 8 x - y = 2 x * y = 15 x / y = 1,6666666666666667 x% y = 2 ++ x = 6 x ++ = 6 x = 7 - x = 6 x - = 6 x = 5 x ** y = 125
Hinweis : Der Operator ** wurde in EcmaScript 2016 eingeführt und wird von einigen Browsern möglicherweise nicht unterstützt. Weitere Informationen finden Sie unter Unterstützung des JavaScript-Exponentiationsbrowsers.
JavaScript-Vergleichsoperatoren
Vergleichsoperatoren vergleichen zwei Werte und geben entweder trueoder einen booleschen Wert zurück false. Beispielsweise,
const a = 3, b = 2; console.log(a> b); // true
Hier wird der Vergleichsoperator >verwendet, um zu vergleichen, ob a größer als b ist.
| Operator | Beschreibung | Beispiel |
|---|---|---|
== | Gleich : Gibt zurück, truewenn die Operanden gleich sind | x == y |
!= | Nicht gleich : Gibt zurück, truewenn die Operanden nicht gleich sind | x != y |
=== | Streng gleich : truewenn die Operanden gleich und vom gleichen Typ sind | x === y |
!== | Streng ungleich : truewenn die Operanden gleich, aber unterschiedlich oder überhaupt nicht gleich sind | x !== y |
> | Größer als : trueWenn der linke Operand größer als der rechte Operand ist | x> y |
>= | Größer oder gleich : trueWenn der linke Operand größer oder gleich dem rechten Operanden ist | x>= y |
< | Kleiner als : trueWenn der linke Operand kleiner als der rechte Operand ist | x < y |
<= | Kleiner oder gleich : truewenn der linke Operand kleiner oder gleich dem rechten Operanden ist | x <= y |
Beispiel 2: Vergleichsoperatoren in JavaScript
// equal operator console.log(2 == 2); // true console.log(2 == '2'); // true // not equal operator console.log(3 != 2); // true console.log('hello' != 'Hello'); // true // strict equal operator console.log(2 === 2); // true console.log(2 === '2'); // false // strict not equal operator console.log(2 !== '2'); // true console.log(2 !== '2'); // false
Output
true true true true true false false true
Comparison operators are used in decision making and loops. You will learn about the use of comparison operators in detail in later tutorials.
JavaScript Logical Operators
Logical operators perform logical operations and return a boolean value, either true or false. For example,
const x = 5, y = 3; (x < 6) && (y < 5); // true
Here, && is the logical operator AND. Since both x < 6 and y < 5 are true, the result is true.
| Operator | Description | Example |
|---|---|---|
&& | Logical AND: true if both the operands are true, else returns false | x && y |
|| | Logical OR: true if either of the operands is true; returns false if both are false | x || y |
! | Logical NOT: true if the operand is false and vice-versa. | !x |
Example 3: Logical Operators in JavaScript
// logical AND console.log(true && true); // true console.log(true && false); // false // logical OR console.log(true || false); // true // logical NOT console.log(!true); // false
Output
true false true false
Logical operators are used in decision making and loops. You will learn about the use of logical operators in detail in later tutorials.
JavaScript Bitwise Operators
Bitwise operators perform operations on binary representations of numbers.
| Operator | Description |
|---|---|
& | Bitwise AND |
| | Bitwise OR |
^ | Bitwise XOR |
~ | Bitwise NOT |
<< | Left shift |
>> | Sign-propagating right shift |
>>> | Zero-fill right shift |
Bitwise operators are rarely used in everyday programming. If you are interested, visit JavaScript Bitwise Operators to learn more.
JavaScript String Operators
In JavaScript, you can also use the + operator to concatenate (join) two or more strings.
Example 4: String operators in JavaScript
// concatenation operator console.log('hello' + 'world'); let a = 'JavaScript'; a += ' tutorial'; // a = a + ' tutorial'; console.log(a);
Output
helloworld JavaScript tutorial
Hinweis: Bei +Verwendung mit Zeichenfolgen wird eine Verkettung durchgeführt. Wenn +es jedoch mit Zahlen verwendet wird, führt es eine Addition durch.
Andere JavaScript-Operatoren
Hier ist eine Liste anderer in JavaScript verfügbarer Operatoren. Weitere Informationen zu diesen Operatoren finden Sie in späteren Tutorials.
| Operator | Beschreibung | Beispiel |
|---|---|---|
, | wertet mehrere Operanden aus und gibt den Wert des letzten Operanden zurück. | let a = (1, 3 , 4); // 4 |
?: | Gibt einen Wert basierend auf der Bedingung zurück | (5> 3) ? 'success' : 'error'; // "success" |
delete | löscht die Eigenschaft eines Objekts oder ein Element eines Arrays | delete x |
typeof | Gibt eine Zeichenfolge zurück, die den Datentyp angibt | typeof 3; // "number" |
void | verwirft den Rückgabewert des Ausdrucks | void(x) |
in | Gibt zurück, truewenn sich die angegebene Eigenschaft im Objekt befindet | prop in object |
instanceof | Gibt zurück, truewenn das angegebene Objekt vom angegebenen Objekttyp ist | object instanceof object_type |
