Een operator is een symbool dat werkt op een waarde of gegevens. Het vertegenwoordigt een specifieke actie op het gebied van het werken met data. De gegevens waarop operators werken, worden operand genoemd. Het kan worden gebruikt met een of meer waarden om één enkele waarde te produceren. Alle standaard JavaScript-operators zijn beschikbaar met het TypeScript-programma.
Voorbeeld
10 + 10 = 20;
In het bovenstaande voorbeeld staan de waarden '10' en '20' bekend als een operand, terwijl '+' en '=' bekend staan als operators.
Operatoren in TypeScript
In TypeScript kan een operator op de volgende manieren worden geclassificeerd.
- Rekenkundige operatoren
- Vergelijkingsoperatoren (relationele).
- Logische operatoren
- Bitwise-operatoren
- Toewijzingsoperatoren
- Ternaire/voorwaardelijke operator
- Concatenatie-operator
- Type Operator
Rekenkundige operatoren
Rekenkundige operatoren nemen numerieke waarden als operanden, voeren een actie uit en retourneren vervolgens een enkele numerieke waarde. De meest voorkomende rekenkundige operatoren zijn optellen(+), aftrekken(-), vermenigvuldigen(*) en delen(/).
| Exploitant | Operatornaam | Beschrijving | Voorbeeld |
|---|---|---|---|
| + | Toevoeging | Het retourneert een optelling van de waarden. | let a = 20; let b = 30; let c = a + b; console.log( c ); // <strong>Output</strong> 30 |
| - | Aftrekken | Het retourneert het verschil tussen de waarden. | let a = 30; let b = 20; let c = a - b; console.log( c ); // <strong>Output</strong> 10 |
| * | Vermenigvuldiging | Het retourneert het product van de waarden. | let a = 30; let b = 20; let c = a * b; console.log( c ); // <strong>Output</strong> 600 |
| / | Divisie | Het voert de delingsbewerking uit en retourneert het quotiënt. | let a = 100; let b = 20; let c = a / b; console.log( c ); // <strong>Output</strong> 5 |
| % | Module | Het voert de delingsbewerking uit en retourneert de rest. | let a = 95; let b = 20; let c = a % b; console.log( c ); // <strong>Output</strong> 15 |
| ++ | Verhogen | Het wordt gebruikt om de waarde van de variabele met één te verhogen. | let a = 55; a++; console.log( a ); // <strong>Output</strong> 56 |
| -- | Verlagen | Het wordt gebruikt om de waarde van de variabele met één te verlagen. | let a = 55; a--; console.log( a ); // <strong>Output</strong> 54 |
Vergelijking (relationele) operators
De vergelijkingsoperatoren worden gebruikt om de twee operanden te vergelijken. Deze operatoren retourneren een Booleaanse waarde waar of onwaar. De belangrijkste vergelijkingsoperatoren worden hieronder gegeven.
| Exploitant | Operatornaam | Beschrijving | Voorbeeld |
|---|---|---|---|
| == | Is gelijk aan | Het controleert of de waarden van de twee operanden gelijk zijn of niet. | let a = 10; let b = 20; console.log(a==b); //false console.log(a==10); //true console.log(10=='10'); //true |
| === | Identiek (gelijk en van hetzelfde type) | Het controleert of het type en de waarden van de twee operanden gelijk zijn of niet. | let a = 10; let b = 20; console.log(a===b); //false console.log(a===10); //true console.log(10==='10'); //false |
| != | Niet gelijk aan | Het controleert of de waarden van de twee operanden gelijk zijn of niet. | let a = 10; let b = 20; console.log(a!=b); //true console.log(a!=10); //false console.log(10!='10'); //false |
| !== | Niet hetzelfde | Het controleert of het type en de waarden van de twee operanden gelijk zijn of niet. | let a = 10; let b = 20; console.log(a!==b); //true console.log(a!==10); /false console.log(10!=='10'); //true |
| > | Groter dan | Er wordt gecontroleerd of de waarde van de linkeroperand groter is dan de waarde van de rechteroperand of niet. | let a = 30; let b = 20; console.log(a>b); //true console.log(a>30); //false console.log(20> 20'); //false |
| >= | Groter dan of gelijk aan | Er wordt gecontroleerd of de waarde van de linkeroperand groter is dan of gelijk is aan de waarde van de rechteroperand. | let a = 20; let b = 20; console.log(a>=b); //true console.log(a>=30); //false console.log(20>='20'); //true |
| < | Minder dan | Er wordt gecontroleerd of de waarde van de linkeroperand kleiner is dan de waarde van de rechteroperand of niet. | let a = 10; let b = 20; console.log(a <b); true console.log(a<10); false console.log(10<'10'); false< pre></b);> |
| <=< td> | Minder dan of gelijk aan | Er wordt gecontroleerd of de waarde van de linkeroperand kleiner is dan of gelijk is aan de waarde van de rechteroperand. | let a = 10; let b = 20; console.log(a<=b); true console.log(a<="10);" console.log(10<="10" ); true< pre></=b);> |
Logische operatoren
Er worden logische operatoren gebruikt om twee of meer voorwaarden in één expressie te combineren en het Booleaanse resultaat waar of onwaar te retourneren. De logische operatoren worden hieronder gegeven.
| Exploitant | Operatornaam | Beschrijving | Voorbeeld |
|---|---|---|---|
| && | Logisch EN | Het retourneert waar als beide operanden (expressie) waar zijn, en retourneert anders onwaar. | 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 |
| || | Logische OF | Het retourneert waar als een van de operanden (expressie) waar is, en retourneert anders onwaar. | 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' |
| ! | Logisch NIET | Het retourneert het omgekeerde resultaat van een operand(expressie). | 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 |
Bitwise-operatoren
De bitsgewijze operatoren voeren de bitsgewijze bewerkingen op operanden uit. De bitsgewijze operatoren zijn als volgt.
| Exploitant | Operatornaam | Beschrijving | Voorbeeld |
|---|---|---|---|
| & | Bitsgewijs EN | Het retourneert het resultaat van een Booleaanse AND-bewerking op elk bit van zijn gehele argumenten. | let a = 2; let b = 3; let c = a & b; console.log(c); // <br> <strong>Output <strong> 2 </strong></strong> |
| | | Bitsgewijze OF | Het retourneert het resultaat van een Booleaanse OR-bewerking op elk bit van zijn gehele argumenten. | let a = 2; let b = 3; let c = a | b; console.log(c); // <br> <strong>Output</strong> 3 |
| ^ | Bitsgewijze XOR | Het retourneert het resultaat van een Booleaanse exclusieve OR-bewerking voor elk bit van zijn gehele argumenten. | let a = 2; let b = 3; let c = a ^ b; console.log(c); // <strong>Output </strong> 1 |
| ~ | Bitwijs NIET | Het keert elke bit in de operanden om. | let a = 2; let c = ~ a; console.log(c); // <strong>Output</strong> -3 |
| >> | Bitsgewijze rechtsverschuiving | De waarde van de linker operand wordt naar rechts verplaatst met het aantal bits dat in de rechter operand is opgegeven. | let a = 2; let b = 3; let c = a >> b; console.log(c); // <strong>Output </strong> 0 |
| << | Bitsgewijze linksverschuiving | De waarde van de linker operand wordt naar links verplaatst met het aantal bits dat in de rechter operand is opgegeven. Nieuwe bits worden aan de rechterkant gevuld met nullen. | let a = 2; let b = 3; let c = a << b; console.log(c); // <strong>Output </strong> 16 |
| >>> | Bitsgewijze rechtsverschuiving met nul | De waarde van de linker operand wordt naar rechts verplaatst met het aantal bits dat is opgegeven in de rechter operand, en aan de linkerkant worden nullen toegevoegd. | let a = 3; let b = 4; let c = a >>> b; console.log(c); // <strong>Output </strong> 0 |
Toewijzingsoperatoren
Toewijzingsoperatoren worden gebruikt om een waarde aan de variabele toe te kennen. De linkerkant van de toewijzingsoperator wordt een variabele genoemd, en de rechterkant van de toewijzingsoperator wordt een waarde genoemd. Het gegevenstype van de variabele en de waarde moeten hetzelfde zijn, anders geeft de compiler een fout. De toewijzingsoperatoren zijn als volgt.
| Exploitant | Operatornaam | Beschrijving | Voorbeeld |
|---|---|---|---|
| = | Toewijzen | Het wijst waarden toe van de rechter- naar de linkeroperand. | let a = 10; let b = 5; console.log('a=b:' +a); // <strong>Output </strong> 10 |
| += | Toevoegen en toewijzen | Het voegt de linker operand toe aan de rechter operand en wijst het resultaat toe aan de linker operand. | let a = 10; let b = 5; let c = a += b; console.log(c); // <strong>Output </strong> 15 |
| -= | Aftrekken en toewijzen | Het trekt de rechter operand af van de linker operand en wijst het resultaat toe aan de linker operand. | let a = 10; let b = 5; let c = a -= b; console.log(c); // <strong>Output </strong> 5 |
| *= | Vermenigvuldig en wijs toe | Het vermenigvuldigt de linkeroperand met de rechteroperand en wijst het resultaat toe aan de linkeroperand. | let a = 10; let b = 5; let c = a *= b; console.log(c); // <strong>Output </strong> 50 |
| /= | Verdeel en verdeel | Het verdeelt de linker operand met de rechter operand en wijst het resultaat toe aan de linker operand. | let a = 10; let b = 5; let c = a /= b; console.log(c); // <strong>Output </strong> 2 |
| %= | Module en toewijzing | Het verdeelt de linker operand met de rechter operand en wijst het resultaat toe aan de linker operand. | let a = 16; let b = 5; let c = a %= b; console.log(c); // <strong>Output </strong> 1 |
Ternaire/voorwaardelijke operator
De voorwaardelijke operator neemt drie operanden en retourneert een Booleaanse waarde op basis van de voorwaarde, ongeacht of deze waar of onwaar is. De werking ervan is vergelijkbaar met een if-else-instructie. De voorwaardelijke operator heeft associativiteit van rechts naar links. De syntaxis van een voorwaardelijke operator wordt hieronder gegeven.
expression ? expression-1 : expression-2;
Voorbeeld
let num = 16; let result = (num > 0) ? 'True':'False' console.log(result);
Uitgang:
True
Concatenatie-operator
De concatenatie (+) operator is een operator die wordt gebruikt om de twee strings toe te voegen. Bij aaneenschakeling kunnen we geen spatie tussen de tekenreeksen toevoegen. We kunnen meerdere strings samenvoegen in één enkele instructie. Het volgende voorbeeld helpt ons de aaneenschakelingsoperator in TypeScript te begrijpen.
Voorbeeld
let message = 'Welcome to ' + 'JavaTpoint'; console.log('Result of String Operator: ' +message);
Uitgang:
Result of String Operator: Welcome to JavaTpoint
Type Operators
Er is een verzameling operators beschikbaar die u kunnen helpen bij het werken met objecten in TypeScript. Operators zoals typeof, instanceof, in en delete zijn voorbeelden van de operator Type. Hieronder vindt u een gedetailleerde uitleg van deze operatoren.
| Operatornaam | Beschrijving | Voorbeeld |
|---|---|---|
| in | Het wordt gebruikt om te controleren op het bestaan van een eigenschap van een object. | let Bike = {make: 'Honda', model: 'CLIQ', year: 2018}; console.log('make' in Bike); // <strong>Output:</strong> true |
| verwijderen | Het wordt gebruikt om de eigenschappen van de objecten te verwijderen. | let Bike = { Company1: 'Honda', Company2: 'Hero', Company3: 'Royal Enfield' }; delete Bike.Company1; console.log(Bike); // <strong>Output:</strong> { Company2: 'Hero', Company3: 'Royal Enfield' } |
| soort van | Het retourneert het gegevenstype van de operand. | let message = 'Welcome to ' + 'JavaTpoint'; console.log(typeof message); // <strong>Output:</strong> String |
| exemplaarvan | Het wordt gebruikt om te controleren of het object van een bepaald type is of niet. | let arr = [1, 2, 3]; console.log( arr instanceof Array ); // true console.log( arr instanceof String ); // false |