Ein Operator ist ein Symbol, das einen Wert oder Daten bearbeitet. Es stellt eine spezifische Aktion zum Arbeiten mit Daten dar. Die Daten, mit denen Operatoren arbeiten, werden Operanden genannt. Es kann mit einem oder mehreren Werten verwendet werden, um einen einzelnen Wert zu erzeugen. Alle Standard-JavaScript-Operatoren sind mit dem TypeScript-Programm verfügbar.
Beispiel
10 + 10 = 20;
Im obigen Beispiel werden die Werte „10“ und „20“ als Operanden bezeichnet, während „+“ und „=“ als Operatoren bezeichnet werden.
Operatoren in TypeScript
In TypeScript kann ein Operator auf folgende Arten klassifiziert werden.
k-nn-Algorithmus
- Rechenzeichen
- Vergleichsoperatoren (Relationaloperatoren).
- Logische Operatoren
- Bitweise Operatoren
- Zuweisungsoperatoren
- Ternärer/bedingter Operator
- Verkettungsoperator
- Geben Sie Operator ein
Rechenzeichen
Arithmetische Operatoren verwenden numerische Werte als Operanden, führen eine Aktion aus und geben dann einen einzelnen numerischen Wert zurück. Die gebräuchlichsten arithmetischen Operatoren sind Addition(+), Subtraktion(-), Multiplikation(*) und Division(/).
| Operator | Name des Bedieners | Beschreibung | Beispiel |
|---|---|---|---|
| + | Zusatz | Es gibt eine Addition der Werte zurück. | let a = 20; let b = 30; let c = a + b; console.log( c ); // <strong>Output</strong> 30 |
| - | Subtraktion | Es gibt die Differenz der Werte zurück. | let a = 30; let b = 20; let c = a - b; console.log( c ); // <strong>Output</strong> 10 |
| * | Multiplikation | Es gibt das Produkt der Werte zurück. | let a = 30; let b = 20; let c = a * b; console.log( c ); // <strong>Output</strong> 600 |
| / | Aufteilung | Es führt die Divisionsoperation durch und gibt den Quotienten zurück. | let a = 100; let b = 20; let c = a / b; console.log( c ); // <strong>Output</strong> 5 |
| % | Modul | Es führt die Divisionsoperation durch und gibt den Rest zurück. | let a = 95; let b = 20; let c = a % b; console.log( c ); // <strong>Output</strong> 15 |
| ++ | Zuwachs | Es wird verwendet, um den Wert der Variablen um eins zu erhöhen. | let a = 55; a++; console.log( a ); // <strong>Output</strong> 56 |
| -- | Dekrementieren | Es wird verwendet, um den Wert der Variablen um eins zu verringern. | let a = 55; a--; console.log( a ); // <strong>Output</strong> 54 |
Vergleichsoperatoren (Relationaloperatoren).
Die Vergleichsoperatoren werden zum Vergleich der beiden Operanden verwendet. Diese Operatoren geben einen booleschen Wert „true“ oder „false“ zurück. Nachfolgend sind die wichtigen Vergleichsoperatoren aufgeführt.
Konvertierung von String nach Int in Java
| Operator | Name des Bedieners | Beschreibung | Beispiel |
|---|---|---|---|
| == | Ist gleich | Es prüft, ob die Werte der beiden Operanden gleich sind oder nicht. | let a = 10; let b = 20; console.log(a==b); //false console.log(a==10); //true console.log(10=='10'); //true |
| === | Identisch (gleich und vom gleichen Typ) | Es prüft, ob Typ und Werte der beiden Operanden gleich sind oder nicht. | let a = 10; let b = 20; console.log(a===b); //false console.log(a===10); //true console.log(10==='10'); //false |
| != | Nicht gleichzusetzen mit | Es prüft, ob die Werte der beiden Operanden gleich sind oder nicht. | let a = 10; let b = 20; console.log(a!=b); //true console.log(a!=10); //false console.log(10!='10'); //false |
| !== | Nicht identisch | Es prüft, ob Typ und Werte der beiden Operanden gleich sind oder nicht. | let a = 10; let b = 20; console.log(a!==b); //true console.log(a!==10); /false console.log(10!=='10'); //true |
| > | Größer als | Es prüft, ob der Wert des linken Operanden größer ist als der Wert des rechten Operanden oder nicht. | let a = 30; let b = 20; console.log(a>b); //true console.log(a>30); //false console.log(20> 20'); //false |
| >= | Größer als oder gleich wie | Es prüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist oder nicht. | let a = 20; let b = 20; console.log(a>=b); //true console.log(a>=30); //false console.log(20>='20'); //true |
| < | Weniger als | Es prüft, ob der Wert des linken Operanden kleiner ist als der Wert des rechten Operanden oder nicht. | let a = 10; let b = 20; console.log(a <b); true console.log(a<10); false console.log(10<'10'); false< pre></b);> |
| <=< td> | Gleich oder kleiner als | Es prüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist oder nicht. | let a = 10; let b = 20; console.log(a<=b); true console.log(a<="10);" console.log(10<="10" ); true< pre></=b);> |
Logische Operatoren
Logische Operatoren werden zum Kombinieren von zwei oder mehr Bedingungen in einem einzigen Ausdruck verwendet und geben das boolesche Ergebnis wahr oder falsch zurück. Die logischen Operatoren sind unten angegeben.
| Operator | Name des Bedieners | Beschreibung | Beispiel |
|---|---|---|---|
| && | Logisches UND | Es gibt „true“ zurück, wenn beide Operanden (Ausdruck) wahr sind, andernfalls wird „false“ zurückgegeben. | let a = false; let b = true; console.log(a&&b); /false console.log(b&&true); //true console.log(b&&10); //10 which is also 'true' console.log(a&&'10'); //false |
| || | Logisches ODER | Es gibt „true“ zurück, wenn einer der Operanden (Ausdruck) „true“ ist, andernfalls wird „false“ zurückgegeben. | let a = false; let b = true; console.log(a||b); //true console.log(b||true); //true console.log(b||10); //true console.log(a||'10'); //'10' which is also 'true' |
| ! | Logisches NICHT | Es gibt das inverse Ergebnis eines Operanden (Ausdrucks) zurück. | let a = 20; let b = 30; console.log(!true); //false console.log(!false); //true console.log(!a); //false console.log(!b); /false console.log(!null); //true |
Bitweise Operatoren
Die bitweisen Operatoren führen die bitweisen Operationen an Operanden aus. Die bitweisen Operatoren sind wie folgt.
| Operator | Name des Bedieners | Beschreibung | Beispiel |
|---|---|---|---|
| & | Bitweises UND | Es gibt das Ergebnis einer booleschen UND-Operation für jedes Bit seiner ganzzahligen Argumente zurück. | let a = 2; let b = 3; let c = a & b; console.log(c); // <br> <strong>Output <strong> 2 </strong></strong> |
| | | Bitweises ODER | Es gibt das Ergebnis einer booleschen ODER-Operation für jedes Bit seiner ganzzahligen Argumente zurück. | let a = 2; let b = 3; let c = a | b; console.log(c); // <br> <strong>Output</strong> 3 |
| ^ | Bitweises XOR | Es gibt das Ergebnis einer booleschen Exklusiv-ODER-Operation für jedes Bit seiner ganzzahligen Argumente zurück. | let a = 2; let b = 3; let c = a ^ b; console.log(c); // <strong>Output </strong> 1 |
| ~ | Bitweise NICHT | Es invertiert jedes Bit in den Operanden. | let a = 2; let c = ~ a; console.log(c); // <strong>Output</strong> -3 |
| >> | Bitweise Rechtsverschiebung | Der Wert des linken Operanden wird um die im rechten Operanden angegebene Anzahl von Bits nach rechts verschoben. | let a = 2; let b = 3; let c = a >> b; console.log(c); // <strong>Output </strong> 0 |
| << | Bitweise Linksverschiebung | Der Wert des linken Operanden wird um die im rechten Operanden angegebene Anzahl von Bits nach links verschoben. Neue Bits werden auf der rechten Seite mit Nullen aufgefüllt. | let a = 2; let b = 3; let c = a << b; console.log(c); // <strong>Output </strong> 16 |
| >>> | Bitweise Rechtsverschiebung mit Null | Der Wert des linken Operanden wird um die im rechten Operanden angegebene Anzahl von Bits nach rechts verschoben und auf der linken Seite werden Nullen hinzugefügt. | let a = 3; let b = 4; let c = a >>> b; console.log(c); // <strong>Output </strong> 0 |
Zuweisungsoperatoren
Zuweisungsoperatoren werden verwendet, um der Variablen einen Wert zuzuweisen. Die linke Seite des Zuweisungsoperators wird als Variable bezeichnet, die rechte Seite des Zuweisungsoperators wird als Wert bezeichnet. Der Datentyp der Variablen und des Werts muss identisch sein, andernfalls gibt der Compiler einen Fehler aus. Die Zuweisungsoperatoren lauten wie folgt.
| Operator | Name des Bedieners | Beschreibung | Beispiel |
|---|---|---|---|
| = | Zuordnen | Es weist Werte vom rechten zum linken Operanden zu. | let a = 10; let b = 5; console.log('a=b:' +a); // <strong>Output </strong> 10 |
| += | Hinzufügen und zuweisen | Es addiert den linken Operanden mit dem rechten Operanden und weist das Ergebnis dem linken Operanden zu. | let a = 10; let b = 5; let c = a += b; console.log(c); // <strong>Output </strong> 15 |
| -= | Subtrahieren und zuweisen | Es subtrahiert den rechten Operanden vom linken Operanden und weist das Ergebnis dem linken Operanden zu. | let a = 10; let b = 5; let c = a -= b; console.log(c); // <strong>Output </strong> 5 |
| *= | Multiplizieren und zuweisen | Es multipliziert den linken Operanden mit dem rechten Operanden und weist das Ergebnis dem linken Operanden zu. | let a = 10; let b = 5; let c = a *= b; console.log(c); // <strong>Output </strong> 50 |
| /= | Teilen und zuweisen | Es dividiert den linken Operanden durch den rechten Operanden und weist das Ergebnis dem linken Operanden zu. | let a = 10; let b = 5; let c = a /= b; console.log(c); // <strong>Output </strong> 2 |
| %= | Modul und Zuweisung | Es dividiert den linken Operanden durch den rechten Operanden und weist das Ergebnis dem linken Operanden zu. | let a = 16; let b = 5; let c = a %= b; console.log(c); // <strong>Output </strong> 1 |
Ternärer/bedingter Operator
Der Bedingungsoperator verwendet drei Operanden und gibt basierend auf der Bedingung einen booleschen Wert zurück, unabhängig davon, ob diese wahr oder falsch ist. Die Funktionsweise ähnelt einer if-else-Anweisung. Der bedingte Operator weist eine Assoziativität von rechts nach links auf. Die Syntax eines bedingten Operators ist unten angegeben.
expression ? expression-1 : expression-2;
Beispiel
let num = 16; let result = (num > 0) ? 'True':'False' console.log(result);
Ausgabe:
True
Verkettungsoperator
Der Verkettungsoperator (+) ist ein Operator, der zum Anhängen der beiden Zeichenfolgen verwendet wird. Bei der Verkettungsoperation können wir kein Leerzeichen zwischen den Zeichenfolgen einfügen. Wir können mehrere Zeichenfolgen in einer einzigen Anweisung verketten. Das folgende Beispiel hilft uns, den Verkettungsoperator in TypeScript zu verstehen.
E-R-Modelldiagramm
Beispiel
let message = 'Welcome to ' + 'JavaTpoint'; console.log('Result of String Operator: ' +message);
Ausgabe:
Result of String Operator: Welcome to JavaTpoint
Geben Sie Operatoren ein
Es steht eine Sammlung von Operatoren zur Verfügung, die Sie bei der Arbeit mit Objekten in TypeScript unterstützen können. Operatoren wie „typeof“, „instanceof“, „in“ und „delete“ sind Beispiele für Typoperatoren. Die detaillierte Erklärung dieser Operatoren finden Sie unten.
| Name des Bedieners | Beschreibung | Beispiel |
|---|---|---|
| In | Es wird verwendet, um das Vorhandensein einer Eigenschaft an einem Objekt zu überprüfen. | let Bike = {make: 'Honda', model: 'CLIQ', year: 2018}; console.log('make' in Bike); // <strong>Output:</strong> true |
| löschen | Es wird verwendet, um die Eigenschaften von den Objekten zu löschen. | let Bike = { Company1: 'Honda', Company2: 'Hero', Company3: 'Royal Enfield' }; delete Bike.Company1; console.log(Bike); // <strong>Output:</strong> { Company2: 'Hero', Company3: 'Royal Enfield' } |
| Art der | Es gibt den Datentyp des Operanden zurück. | let message = 'Welcome to ' + 'JavaTpoint'; console.log(typeof message); // <strong>Output:</strong> String |
| Instanz von | Es wird verwendet, um zu prüfen, ob das Objekt von einem bestimmten Typ ist oder nicht. | let arr = [1, 2, 3]; console.log( arr instanceof Array ); // true console.log( arr instanceof String ); // false |