TypeScript - Opérateurs

Bonjour, futurs programmeurs ! Aujourd'hui, nous allons entreprendre un voyage passionnant à la découverte des opérateurs de TypeScript. En tant que votre enseignant bienveillant en informatique, je suis là pour vous guider à travers cette aventure étape par étape. Alors, bouclez votre ceinture et plongeon dans !

Qu'est-ce qu'un Opérateur ?

Avant de commencer notre odyssée des opérateurs TypeScript, comprenstons ce qu'est réellement un opérateur. Pensez aux opérateurs comme des symboles spéciaux qui ordonnent à l'ordinateur d'effectuer des manipulations mathématiques ou logiques spécifiques. Ils sont comme les baguettes magiques de la programmation, transformant et combinant nos données de diverses manières.

Par exemple, lorsque vous voyez un signe "+" dans votre code, ce n'est pas simplement une décoration fantaisiste. C'est un opérateur qui indique à l'ordinateur d'additionner des éléments. Génial, non ?

Opérateurs Arithmétiques

Commençons par les opérateurs arithmétiques. Ceux-ci vous sont probablement les plus familiers, car ils sont similaires à ce que vous avez utilisé dans vos cours de mathématiques.

Voici un tableau des opérateurs arithmétiques en TypeScript :

Opérateur	Description	Exemple
+	Addition	5 + 3
-	Soustraction	7 - 2
*	Multiplication	4 * 6
/	Division	8 / 2
%	Modulo (reste)	9 % 4
++	Incrément	let x = 5; x++;
--	Décrément	let y = 3; y--;

Voyons-les en action :

let a: number = 10;
let b: number = 5;

console.log(a + b);  // Output: 15
console.log(a - b);  // Output: 5
console.log(a * b);  // Output: 50
console.log(a / b);  // Output: 2
console.log(a % b);  // Output: 0

let c: number = 7;
c++;
console.log(c);  // Output: 8

let d: number = 3;
d--;
console.log(d);  // Output: 2

Dans cet exemple, nous effectuons diverses opérations arithmétiques sur nos variables. L'opérateur modulo (%) pourrait être nouveau pour certains d'entre vous. Il nous donne le reste après la division. Ainsi, 10 % 5 est 0 car 10 divisé par 5 ne laisse aucun reste.

Opérateurs Relatifs

Passons aux opérateurs relatifs. Ceux-ci sont utilisés pour comparer des valeurs et renvoyer true ou false en fonction de la comparaison.

Voici un tableau des opérateurs relatifs :

Opérateur	Description	Exemple
==	Égal à	5 == 5
!=	Différent de	5 != 3
>	Supérieur à	7 > 3
<	Inférieur à	2 < 8
>=	Supérieur ou égal à	5 >= 5
<=	Inférieur ou égal à	4 <= 4

Voyons comment ils fonctionnent :

let x: number = 5;
let y: number = 10;

console.log(x == y);  // Output: false
console.log(x != y);  // Output: true
console.log(x > y);   // Output: false
console.log(x < y);   // Output: true
console.log(x >= 5);  // Output: true
console.log(y <= 10); // Output: true

Ces opérateurs sont très utiles lorsque vous avez besoin de prendre des décisions dans votre code en fonction de la comparaison des valeurs.

Opérateurs Logiques

Les opérateurs logiques sont utilisés pour déterminer la logique entre des variables ou des valeurs. Ils sont comme Sherlock Holmes de la programmation, nous aidant à déduire des vérités à partir de multiples conditions.

Voici un tableau des opérateurs logiques :

Opérateur	Description	Exemple
&&	ET Logique	true && false
||	OU Logique	true || false
!	NON Logique	!true

Voyons-les en action :

let isRaining: boolean = true;
let isWarm: boolean = false;

console.log(isRaining && isWarm);  // Output: false
console.log(isRaining || isWarm);  // Output: true
console.log(!isRaining);           // Output: false

Dans cet exemple, && renvoie true uniquement si les deux conditions sont true. || renvoie true si au moins une condition est true. ! inverse la valeur booléenne.

Opérateurs Bitwise

Maintenant, nous nous aventurons dans un territoire plus avancé. Les opérateurs bitwise effectuent des opérations sur les représentations binaires des nombres. Ne vous inquiétez pas si cela semble complexe - nous allons le détailler !

Voici un tableau des opérateurs bitwise :

Opérateur	Description	Exemple
&	ET Bitwise	5 & 3
|	OU Bitwise	5 | 3
^	XOR Bitwise	5 ^ 3
~	NON Bitwise	~5
<<	Décalage à Gauche	5 << 1
>>	Décalage à Droite	5 >> 1

Voyons un exemple :

let a: number = 5;  // binaire: 0101
let b: number = 3;  // binaire: 0011

console.log(a & b);  // Output: 1 (binaire: 0001)
console.log(a | b);  // Output: 7 (binaire: 0111)
console.log(a ^ b);  // Output: 6 (binaire: 0110)
console.log(~a);     // Output: -6 (binaire: 1010 en complément à deux)
console.log(a << 1); // Output: 10 (binaire: 1010)
console.log(a >> 1); // Output: 2 (binaire: 0010)

Ces opérateurs travaillent sur la représentation binaire des nombres. Ils sont particulièrement utiles dans la programmation de bas niveau et certains algorithmes.

Opérateurs d'Affectation

Les opérateurs d'affectation sont utilisés pour assigner des valeurs aux variables. Ils sont comme les déménageurs de la programmation, plaçant les valeurs dans leurs properes domiciles (variables).

Voici un tableau des opérateurs d'affectation :

Opérateur	Description	Exemple
=	Affecter	x = 5
+=	Ajouter et affecter	x += 3
-=	Soustraire et affecter	x -= 2
*=	Multiplier et affecter	x *= 4
/=	Diviser et affecter	x /= 2
%=	Modulo et affecter	x %= 3

Voyons-les en action :

let x: number = 10;

x += 5;  // équivalent à : x = x + 5
console.log(x);  // Output: 15

x -= 3;  // équivalent à : x = x - 3
console.log(x);  // Output: 12

x *= 2;  // équivalent à : x = x * 2
console.log(x);  // Output: 24

x /= 4;  // équivalent à : x = x / 4
console.log(x);  // Output: 6

x %= 4;  // équivalent à : x = x % 4
console.log(x);  // Output: 2

Ces opérateurs sont des raccourcis qui rendent notre code plus concis et lisible.

Opérateurs Divers

TypeScript possède également quelques autres opérateurs qui ne rentrent pas dans les catégories précédentes.

Voici un tableau de certains opérateurs divers :

Opérateur	Description	Exemple
?:	Conditionnel (ternaire)	condition ? expr1 : expr2
,	Comma	let x = (1, 2, 3)
delete	Supprimer propriété	delete obj.property
typeof	Type de variable	typeof x
void	Évaluer expression et retourner undefined	void(0)

Voyons un exemple de l'opérateur ternaire, qui est très utile :

let age: number = 20;
let canVote: string = age >= 18 ? "Oui" : "Non";
console.log(canVote);  // Output: "Oui"

C'est une manière abrégée d'écrire une instruction if-else. Si la condition (age >= 18) est true, elle renvoie "Oui", sinon "Non".

Opérateurs de Type

Enfin, regardons quelques opérateurs spécifiques à TypeScript qui nous aident à travailler avec les types.

Voici un tableau des opérateurs de type :

Opérateur	Description	Exemple
typeof	Obtenir le type d'une variable	typeof x
instanceof	Vérifier si un objet est une instance d'une classe	obj instanceof Class
as	Assertion de type	(someValue as string).toUpperCase()
	Assertion de type (syntaxe alternative)	(someValue).toUpperCase()

Voyons un exemple :

let x: any = "Hello, TypeScript!";
let length: number = (x as string).length;
console.log(length);  // Output: 20

class Animal {}
class Dog extends Animal {}

let myPet = new Dog();
console.log(myPet instanceof Animal);  // Output: true

Dans cet exemple, nous utilisons une assertion de type pour indiquer à TypeScript que nous savons que x est une chaîne, même si elle est typée comme any. Nous utilisons également instanceof pour vérifier si myPet est une instance de la classe Animal.

Et voilà, amis ! Nous avons fait le tour du monde des opérateurs TypeScript. Souvenez-vous, la pratique rend parfait, donc n'ayez pas peur d'expérimenter avec ces opérateurs dans votre propre code. Bonne programmation !

Credits: Image by storyset