Un opérateur est un symbole qui opère sur une valeur ou une donnée. Il représente une action spécifique sur le travail avec les données. Les données sur lesquelles les opérateurs opèrent sont appelées opérandes. Il peut être utilisé avec une ou plusieurs valeurs pour produire une seule valeur. Tous les opérateurs JavaScript standards sont disponibles avec le programme TypeScript.
Exemple
10 + 10 = 20;
Dans l'exemple ci-dessus, les valeurs « 10 » et « 20 » sont appelées opérandes, tandis que « + » et « = » sont appelées opérateurs.
Opérateurs en TypeScript
Dans TypeScript, un opérateur peut être classé des manières suivantes.
- Opérateurs arithmétiques
- Opérateurs de comparaison (relationnels)
- Opérateurs logiques
- Opérateurs au niveau du bit
- Opérateurs d'affectation
- Opérateur ternaire/conditionnel
- Opérateur de concaténation
- Opérateur de type
Opérateurs arithmétiques
Les opérateurs arithmétiques prennent des valeurs numériques comme opérandes, effectuent une action, puis renvoient une seule valeur numérique. Les opérateurs arithmétiques les plus courants sont l'addition (+), la soustraction (-), la multiplication (*) et la division (/).
| Opérateur | Nom de l'opérateur | Description | Exemple |
|---|---|---|---|
| + | Ajout | Il renvoie une addition des valeurs. | let a = 20; let b = 30; let c = a + b; console.log( c ); // <strong>Output</strong> 30 |
| - | Soustraction | Il renvoie la différence des valeurs. | let a = 30; let b = 20; let c = a - b; console.log( c ); // <strong>Output</strong> 10 |
| * | Multiplication | Il renvoie le produit des valeurs. | let a = 30; let b = 20; let c = a * b; console.log( c ); // <strong>Output</strong> 600 |
| / | Division | Il effectue l'opération de division et renvoie le quotient. | let a = 100; let b = 20; let c = a / b; console.log( c ); // <strong>Output</strong> 5 |
| % | Module | Il effectue l'opération de division et renvoie le reste. | let a = 95; let b = 20; let c = a % b; console.log( c ); // <strong>Output</strong> 15 |
| ++ | Incrément | Il est utilisé pour incrémenter la valeur de la variable de un. | let a = 55; a++; console.log( a ); // <strong>Output</strong> 56 |
| -- | Décrémenter | Il est utilisé pour décrémenter la valeur de la variable de un. | let a = 55; a--; console.log( a ); // <strong>Output</strong> 54 |
Opérateurs de comparaison (relationnels)
Les opérateurs de comparaison sont utilisés pour comparer les deux opérandes. Ces opérateurs renvoient une valeur booléenne vraie ou fausse. Les opérateurs de comparaison importants sont indiqués ci-dessous.
| Opérateur | Nom de l'opérateur | Description | Exemple |
|---|---|---|---|
| == | Est égal à | Il vérifie si les valeurs des deux opérandes sont égales ou non. | let a = 10; let b = 20; console.log(a==b); //false console.log(a==10); //true console.log(10=='10'); //true |
| === | Identique(égal et du même type) | Il vérifie si le type et les valeurs des deux opérandes sont égaux ou non. | let a = 10; let b = 20; console.log(a===b); //false console.log(a===10); //true console.log(10==='10'); //false |
| != | Pas égal à | Il vérifie si les valeurs des deux opérandes sont égales ou non. | let a = 10; let b = 20; console.log(a!=b); //true console.log(a!=10); //false console.log(10!='10'); //false |
| !== | Pas identique | Il vérifie si le type et les valeurs des deux opérandes sont égaux ou non. | let a = 10; let b = 20; console.log(a!==b); //true console.log(a!==10); /false console.log(10!=='10'); //true |
| > | Plus grand que | Il vérifie si la valeur des opérandes de gauche est supérieure ou non à la valeur de l'opérande de droite. | let a = 30; let b = 20; console.log(a>b); //true console.log(a>30); //false console.log(20> 20'); //false |
| >= | Plus grand ou égal à | Il vérifie si la valeur des opérandes de gauche est supérieure ou égale à la valeur de l'opérande de droite ou non. | let a = 20; let b = 20; console.log(a>=b); //true console.log(a>=30); //false console.log(20>='20'); //true |
| < | Moins que | Il vérifie si la valeur des opérandes de gauche est inférieure ou non à la valeur de l'opérande de droite. | let a = 10; let b = 20; console.log(a <b); true console.log(a<10); false console.log(10<'10'); false< pre></b);> |
| <=< td> | Inférieur ou égal à | Il vérifie si la valeur des opérandes de gauche est inférieure ou égale à la valeur de l'opérande de droite ou non. | let a = 10; let b = 20; console.log(a<=b); true console.log(a<="10);" console.log(10<="10" ); true< pre></=b);> |
Opérateurs logiques
Les opérateurs logiques sont utilisés pour combiner deux ou plusieurs conditions en une seule expression et renvoient le résultat booléen vrai ou faux. Les opérateurs logiques sont donnés ci-dessous.
| Opérateur | Nom de l'opérateur | Description | Exemple |
|---|---|---|---|
| && | ET logique | Il renvoie vrai si les deux opérandes (expression) sont vrais, sinon renvoie faux. | 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 |
| || | OU logique | Il renvoie vrai si l'un des opérandes (expression) est vrai, sinon renvoie faux. | 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' |
| ! | NON logique | Il renvoie le résultat inverse d'un opérande (expression). | 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 |
Opérateurs au niveau du bit
Les opérateurs au niveau du bit effectuent les opérations au niveau du bit sur les opérandes. Les opérateurs au niveau du bit sont les suivants.
| Opérateur | Nom de l'opérateur | Description | Exemple |
|---|---|---|---|
| & | ET au niveau du bit | Il renvoie le résultat d'une opération booléenne ET sur chaque bit de ses arguments entiers. | let a = 2; let b = 3; let c = a & b; console.log(c); // <br> <strong>Output <strong> 2 </strong></strong> |
| | | OU au niveau du bit | Il renvoie le résultat d'une opération booléenne OU sur chaque bit de ses arguments entiers. | let a = 2; let b = 3; let c = a | b; console.log(c); // <br> <strong>Output</strong> 3 |
| ^ | XOR au niveau du bit | Il renvoie le résultat d'une opération booléenne OU exclusif sur chaque bit de ses arguments entiers. | let a = 2; let b = 3; let c = a ^ b; console.log(c); // <strong>Output </strong> 1 |
| ~ | PAS au niveau du bit | Il inverse chaque bit des opérandes. | let a = 2; let c = ~ a; console.log(c); // <strong>Output</strong> -3 |
| >> | Décalage vers la droite au niveau du bit | La valeur de l'opérande de gauche est déplacée vers la droite du nombre de bits spécifié dans l'opérande de droite. | let a = 2; let b = 3; let c = a >> b; console.log(c); // <strong>Output </strong> 0 |
| << | Décalage gauche au niveau du bit | La valeur de l'opérande de gauche est déplacée vers la gauche du nombre de bits spécifié dans l'opérande de droite. Les nouveaux bits sont remplis de zéros sur le côté droit. | let a = 2; let b = 3; let c = a << b; console.log(c); // <strong>Output </strong> 16 |
| >>> | Décalage bit à droite avec zéro | La valeur de l'opérande de gauche est déplacée vers la droite du nombre de bits spécifié dans l'opérande de droite et des zéros sont ajoutés sur le côté gauche. | let a = 3; let b = 4; let c = a >>> b; console.log(c); // <strong>Output </strong> 0 |
Opérateurs d'affectation
Les opérateurs d'affectation sont utilisés pour attribuer une valeur à la variable. Le côté gauche de l’opérateur d’affectation est appelé une variable et le côté droit de l’opérateur d’affectation est appelé une valeur. Le type de données de la variable et de la valeur doit être le même, sinon le compilateur générera une erreur. Les opérateurs d'affectation sont les suivants.
chaîne de entier
| Opérateur | Nom de l'opérateur | Description | Exemple |
|---|---|---|---|
| = | Attribuer | Il attribue des valeurs du côté droit à l’opérande gauche. | let a = 10; let b = 5; console.log('a=b:' +a); // <strong>Output </strong> 10 |
| += | Ajouter et attribuer | Il ajoute l'opérande de gauche avec l'opérande de droite et attribue le résultat à l'opérande de gauche. | let a = 10; let b = 5; let c = a += b; console.log(c); // <strong>Output </strong> 15 |
| -= | Soustraire et attribuer | Il soustrait l’opérande droit de l’opérande gauche et attribue le résultat à l’opérande gauche. | let a = 10; let b = 5; let c = a -= b; console.log(c); // <strong>Output </strong> 5 |
| *= | Multiplier et attribuer | Il multiplie l'opérande de gauche par l'opérande de droite et attribue le résultat à l'opérande de gauche. | let a = 10; let b = 5; let c = a *= b; console.log(c); // <strong>Output </strong> 50 |
| /= | Diviser et attribuer | Il divise l'opérande de gauche avec l'opérande de droite et attribue le résultat à l'opérande de gauche. | let a = 10; let b = 5; let c = a /= b; console.log(c); // <strong>Output </strong> 2 |
| %= | Module et assigner | Il divise l'opérande de gauche avec l'opérande de droite et attribue le résultat à l'opérande de gauche. | let a = 16; let b = 5; let c = a %= b; console.log(c); // <strong>Output </strong> 1 |
Opérateur ternaire/conditionnel
L'opérateur conditionnel prend trois opérandes et renvoie une valeur booléenne basée sur la condition, qu'elle soit vraie ou fausse. Son fonctionnement est similaire à une instruction if-else. L'opérateur conditionnel a une associativité de droite à gauche. La syntaxe d'un opérateur conditionnel est donnée ci-dessous.
expression ? expression-1 : expression-2;
Exemple
let num = 16; let result = (num > 0) ? 'True':'False' console.log(result);
Sortir:
True
Opérateur de concaténation
L'opérateur de concaténation (+) est un opérateur utilisé pour ajouter les deux chaînes. En opération de concaténation, nous ne pouvons pas ajouter d’espace entre les chaînes. Nous pouvons concaténer plusieurs chaînes en une seule instruction. L'exemple suivant nous aide à comprendre l'opérateur de concaténation dans TypeScript.
Exemple
let message = 'Welcome to ' + 'JavaTpoint'; console.log('Result of String Operator: ' +message);
Sortir:
Result of String Operator: Welcome to JavaTpoint
Opérateurs de type
Il existe une collection d'opérateurs disponibles qui peuvent vous aider lorsque vous travaillez avec des objets dans TypeScript. Les opérateurs tels que typeof, instanceof, in et delete sont des exemples d'opérateur Type. L’explication détaillée de ces opérateurs est donnée ci-dessous.
| Nom de l'opérateur | Description | Exemple |
|---|---|---|
| dans | Il permet de vérifier l'existence d'une propriété sur un objet. | let Bike = {make: 'Honda', model: 'CLIQ', year: 2018}; console.log('make' in Bike); // <strong>Output:</strong> true |
| supprimer | Il est utilisé pour supprimer les propriétés des objets. | let Bike = { Company1: 'Honda', Company2: 'Hero', Company3: 'Royal Enfield' }; delete Bike.Company1; console.log(Bike); // <strong>Output:</strong> { Company2: 'Hero', Company3: 'Royal Enfield' } |
| Type de | Il renvoie le type de données de l'opérande. | let message = 'Welcome to ' + 'JavaTpoint'; console.log(typeof message); // <strong>Output:</strong> String |
| exemple de | Il est utilisé pour vérifier si l'objet est d'un type spécifié ou non. | let arr = [1, 2, 3]; console.log( arr instanceof Array ); // true console.log( arr instanceof String ); // false |