Opérateurs d’affectation Dart

1. Opérateur d’affectation de base =

Stocke la valeur de l’expression à droite dans la variable à gauche, en écrasant l’ancienne valeur.

Syntaxe :

variable = valeur ou expression;

int age;
age = 10;        // Affecte 10 à la variable age
String name;
name= "sam"; // Affectation de chaîne de caractèresLangage du code : JavaScript (javascript)

2. Opérateur d’affectation sensible à null ??=

N’exécute l’affectation uniquement si la variable de gauche vaut null. Si la variable n’est pas null, sa valeur reste inchangée.

Syntaxe :

variable ??= valeur;

Équivaut à :

if (variable == null) {
  variable = valeur;
}Langage du code : JavaScript (javascript)

Exemple :

void main() {
	int? total = null;
	total ??= 5;
	print(total); // Affiche 5, l'affectation fonctionne car total vaut null

	int? count = 100;
	count ??= 200;
	print(count); // Affiche 100, l'affectation n'a pas lieu car count n'est pas null
}Langage du code : PHP (php)

3. Opérateurs d’affectation composés

Réalisent une opération puis une affectation en une seule étape

Pour tout opérateur op

a op= b est équivalent à a = a op b

Catégorie	Opérateur	Signification
Opérations arithmétiques basiques	+=	Ajout puis affectation
	-=	Soustraction puis affectation
	*=	Multiplication puis affectation
	/=	Division (virgule flottante) puis affectation
Division entière	~/=	Division entière puis affectation (conserve l’entier)
Reste de division	%=	Calcul du modulo puis affectation
Décalage binaire gauche	<<=	Décalage à gauche puis affectation
Décalage binaire droit	>>=	Décalage à droite puis affectation
Décalage droit sans signe	>>>=	Décalage droit non signé puis affectation
ET bit à bit	&=	ET binaire puis affectation
XOR bit à bit	^=	XOR binaire puis affectation
OU bit à bit	|=	OU binaire puis affectation

Fonctionnement des opérateurs :	a op= b	a = a op b
Exemple concret :	a += b	a = a + b

Exemple de code :

void main() {
	var num = 2;

	// *= Affectation composée de multiplication
	num *= 3; 
	print(num); // 6, équivaut à num = num * 3

	// += Addition
	num += 4;
	print(num); // 10, équivaut à num = num + 4

	// -= Soustraction
	num -= 2;
	print(num); // 8

	// /= Division à virgule flottante
	double d = 10;
	d /= 2;
	print(d); // 5.0

	// ~/= Division entière
	int n = 7;
	n ~/= 2;
	print(n); // 3

	// %= Modulo
	int m = 9;
	m %= 2;
	print(m); // 1

	// <<= Décalage gauche
	int bit1 = 1;
	bit1 <<= 2; // 1 << 2 = 4
	print(bit1); // 4

	// >>= Décalage droit
	int bit2 = 8;
	bit2 >>= 2; // 8 >> 2 = 2
	print(bit2); // 2

	// >>>= Décalage droit sans signe
	int bit3 = -8;
	bit3 >>>= 2;
	print(bit3); //4611686018427387902, un nombre très grand 

	// &= ET binaire
	int x = 6; // 110
	x &= 3;    // 011
	print(x);  // 010 = 2

	// ^= XOR binaire
	int y = 5;
	y ^= 3;
	print(y);

	// |= OU binaire
	int z = 4;
	z |= 1;
	print(z); // 5
}Langage du code : PHP (php)

Concernant les décalages binaires : int bit1 = 1 ; on décale de 2 bits vers la gauche,

Représentation binaire 32 bits du nombre décimal 1 :

00000000 00000000 00000000 00000001

x << n : déplace l’ensemble des bits binaires de x de n positions vers la gauche, complète les bits vides à droite par des 0 et supprime les bits qui dépassent à gauche.

Dans l’exemple ci-dessus, on obtient :

00000000 00000000 00000000 00000100

Cette valeur binaire correspond au nombre décimal 4

Nous aborderons les opérateurs logiques plus tard. Pour l’instant, retenez simplement les opérateurs d’affectation : c’est le point essentiel de cette leçon.

void main() {
  // 1. Affectation de base =
  var a = 2;
  print(a == 2);

  // 2. Affectation composée de multiplication *=
  a *= 3; // a =  a * 3;
  print(a == 6);

  // 3. Affectation composée d'addition +=
  a += 4; // a = a + 4;
  print(a == 10);

  // 4. Affectation sensible à null ??=
  int? b; // Valeur initiale null
  b ??= 20;
  print(b == 20);

  b ??= 99; // b n'est pas null, aucune modification
  print(b == 20);

  // 5. Soustraction -=
  a -= 5;
  print(a == 5);

  // 6. Modulo %=
  a %= 3;
  print(a == 2);
}Langage du code : Dart (dart)

Tous les affichages valent true