Compréhension des opérateurs d'expression

Les expressions peuvent être liées entre elles avec des opérateurs pour créer des expressions composées. Le langage Apex prend en charge les opérateurs suivants :

Opérateur	Syntaxe	Description
`=`	`x = y`	Opérateur d'affectation (associatif à droite). Attribue la valeur de `y` à la valeur L de `x`. Notez que le type de données `x` doit correspondre au type de données `y`, et ne peut pas être `null`.
`+=`	`x += y`	Opérateur d'affectation d'addition (associatif à droite). Ajoute la valeur de `y` à la valeur d'origine de `x`, puis réattribue la nouvelle valeur à `x`. Pour plus d'informations, reportez-vous à `+`. `x` et `y` ne peuvent pas être `null`.
`*=`	`x *= y`	Opérateur d'affectation de multiplication (associatif à droite). Multiplie la valeur de `y` par la valeur d'origine de `x`, puis réattribue la nouvelle valeur à `x`. Notez que `x` et `y` doivent être des Integer ou des Double, ou une combinaison des deux. `x` et `y` ne peuvent pas être `null`.
`-=`	`x -= y`	Opérateur d'affectation de soustraction (associatif à droite). Soustrait la valeur de `y` de la valeur d'origine de `x`, puis réattribue la nouvelle valeur à `x`. Notez que `x` et `y` doivent être des Integer ou des Double, ou une combinaison des deux. `x` et `y` ne peuvent pas être `null`.
`/=`	`x /= y`	Opérateur d'affectation de division (associatif à droite). Divise la valeur d'origine de `x` par la valeur de `y`, puis réattribue la nouvelle valeur à `x`. Notez que `x` et `y` doivent être des Integer ou des Double, ou une combinaison des deux. `x` et `y` ne peuvent pas être `null`.
`\|=`	`x \|= y`	Opérateur d'affectation OR (associatif à droite). Si `x`, booléen, et `y`, booléen, sont tous les deux false, `x` reste false. Sinon, la valeur true est attribuée à `x`. Remarque : Cet opérateur exhibe un comportement « court-circuit », ce qui signifie que `y` est évalué uniquement si `x` est false. `x` et `y` ne peuvent pas être `null`.
`&=`	`x &= y`	Opérateur d'affectation AND (associatif à droite). Si `x`, booléen, et `y`, booléen, sont tous les deux true, `x` reste true. Sinon, la valeur false est attribuée à `x`. Remarque : Cet opérateur exhibe un comportement « court-circuit », ce qui signifie que `y` est évalué uniquement si `x` est true. `x` et `y` ne peuvent pas être `null`.
`<<=`	`x <<= y`	Opérateur d'affectation décalage gauche au niveau du bit. Décale chaque bit dans `x` vers la gauche de `y` bits, de sorte que les bits de poids fort sont perdus, et les nouveaux bits droits sont définis sur 0. Cette valeur est ensuite réattribuée à `x`.
`>>=`	`x >>= y`	Opérateur d'affectation décalage droit au niveau du bit. Décale chaque bit dans `x` vers la droite de `y` bits, de sorte que les bits de poids faible sont perdus, et les nouveaux bits gauches sont définis sur 0 pour des valeurs positives de `y` et sur 1 pour des valeurs négatives de `y`. Cette valeur est ensuite réattribuée à `x`.
`>>>=`	`x >>>= y`	Opérateur d'affectation décalage droit non signé au niveau du bit. Décale chaque bit dans `x` vers la droite de `y` bits, de sorte que les bits de poids faible sont perdus, et les nouveaux bits gauches sont définis sur 0 pour toutes les valeurs de `y`. Cette valeur est ensuite réattribuée à `x`.
`? :`	`x ? y : z`	Opérateur ternaire (associatif à droite). Cet opérateur agit en tant que paramètre abrégé pour les instructions if-then-else. Si `x`, booléen, est true, `y` est le résultat. Sinon, `z` est le résultat. Notez que `x` ne peut pas être `null`.
`&&`	`x && y`	Opérateur logique AND (associatif à gauche). Si `x`, booléen, et `y`, booléen, sont tous les deux true, l'expression évalue à true. Sinon, l'expression évalue à false. Remarque : `&&` est prioritaire sur `\|\|` Cet opérateur exhibe un comportement « court-circuit », ce qui signifie que `y` est évalué uniquement si `x` est true. `x` et `y` ne peuvent pas être `null`.
`\|\|`	`x \|\| y`	Opérateur logique OR (associatif à gauche). Si `x`, booléen, et `y`, booléen, sont tous les deux false, l'expression évalue à false. Sinon, l'expression évalue à true. Remarque : `&&` est prioritaire sur `\|\|` Cet opérateur exhibe un comportement « court-circuit », ce qui signifie que `y` est évalué uniquement si `x` est false. `x` et `y` ne peuvent pas être `null`.
`==`	`x == y`	Opérateur d'égalité. Si la valeur de `x` est égale à la valeur de `y`, l'expression évalue à true. Sinon, l'expression évalue à false. Remarque : Contrairement au langage Java, `==` dans Apex compare l'égalité de la valeur de l'objet, pas l'égalité de la référence. Par conséquent : La comparaison de chaînes en utilisant `==` n'est pas sensible à la casse La comparaison d'ID en utilisant `==` est sensible à la casse, et ne fait pas la distinction entre les formats à 15 caractères et à 18 caractères Pour les sObject et les tableaux sObject, `==` effectue une vérification approfondie de toutes les valeurs de champ sObject avant de renvoyer son résultat. De la même façon pour les collections, les types Apex intégrés et les types définis par l'utilisateur. Pour des enregistrements, chaque champ doit avoir la même valeur pour `==` pour évaluer sur true. `x` ou `y` peuvent être le `null` littéral. La comparaison de deux valeurs quelconques ne peut jamais donner `null`. SOQL et SOSL utilisent `=` pour leur opérateur d'égalité, pas `==`. Bien que le langage Apex et SOQL et SOSL soient étroitement liés, cette différence de syntaxe regrettable existe, car la plupart des langages modernes utilisent `=` pour l'affectation et `==` pour l'égalité. Les concepteurs du langage Apex ont considéré qu'il était préférable de conserver ce modèle que de forcer les développeurs à apprendre un nouvel opérateur d'affectation. Par conséquent, les développeurs Apex doivent utiliser `==` pour des tests d'égalité dans le corps principal du code Apex, et `=` pour l'égalité dans les requêtes SOQL et SOSL.
`===`	`x === y`	Opérateur d'égalité identique. Si `x` et `y` référencent un emplacement identique dans la mémoire, l'expression évalue à true. Sinon, l'expression évalue à false. Notez que cet opérateur fonctionne uniquement pour les sObjects ou les collections (telles que mappage ou liste). Pour un objet Apex (tel qu'une Exception ou l'instanciation d'une classe), l'opérateur d'égalité identique est le même que l'opérateur d'égalité.
`<`	`x < y`	Opérateur inférieur à. Si `x` est inférieur à `y`, l'expression évalue à true. Sinon, l'expression évalue à false. Remarque : Contrairement à d'autres procédures stockées dans la base de données, Apex ne prend pas en charge la logique booléenne à trois états, et la comparaison de deux valeurs quelconques ne peut jamais donner `null`. Si `x` ou `y` est égal à `null` et est un Integer, Double, Date ou Datetime, l'expression est false. Une valeur String ou ID non `null` est toujours supérieure à une valeur `null`. Si `x` et `y` sont des ID, ils doivent référencer le même type d'objet. Sinon, une erreur d'exécution est générée. Si `x` ou `y` est un ID et que l'autre valeur est une String, la valeur String est validée et traitée en tant qu'ID. `x` et `y` ne peuvent pas être booléens. La comparaison de deux chaînes est effectuée conformément aux paramètres régionaux de l'utilisateur contextuel.
`>`	`x > y`	Opérateur supérieur à. Si `x` est supérieur à `y`, l'expression évalue à true. Sinon, l'expression évalue à false. Remarque : La comparaison de deux valeurs quelconques ne peut jamais donner `null`. Si `x` ou `y` est égal à `null` et est un Integer, Double, Date ou Datetime, l'expression est false. Une valeur String ou ID non `null` est toujours supérieure à une valeur `null`. Si `x` et `y` sont des ID, ils doivent référencer le même type d'objet. Sinon, une erreur d'exécution est générée. Si `x` ou `y` est un ID et que l'autre valeur est une String, la valeur String est validée et traitée en tant qu'ID. `x` et `y` ne peuvent pas être booléens. La comparaison de deux chaînes est effectuée conformément aux paramètres régionaux de l'utilisateur contextuel.
`<=`	`x <= y`	Opérateur inférieur ou égal à. Si `x` est inférieur ou égal à `y`, l'expression évalue à true. Sinon, l'expression évalue à false. Remarque : La comparaison de deux valeurs quelconques ne peut jamais donner `null`. Si `x` ou `y` est égal à `null` et est un Integer, Double, Date ou Datetime, l'expression est false. Une valeur String ou ID non `null` est toujours supérieure à une valeur `null`. Si `x` et `y` sont des ID, ils doivent référencer le même type d'objet. Sinon, une erreur d'exécution est générée. Si `x` ou `y` est un ID et que l'autre valeur est une String, la valeur String est validée et traitée en tant qu'ID. `x` et `y` ne peuvent pas être booléens. La comparaison de deux chaînes est effectuée conformément aux paramètres régionaux de l'utilisateur contextuel.
`>=`	`x >= y`	Opérateur supérieur ou égal à. Si `x` est supérieur ou égal à `y`, l'expression évalue à true. Sinon, l'expression évalue à false. Remarque : La comparaison de deux valeurs quelconques ne peut jamais donner `null`. Si `x` ou `y` est égal à `null` et est un Integer, Double, Date ou Datetime, l'expression est false. Une valeur String ou ID non `null` est toujours supérieure à une valeur `null`. Si `x` et `y` sont des ID, ils doivent référencer le même type d'objet. Sinon, une erreur d'exécution est générée. Si `x` ou `y` est un ID et que l'autre valeur est une String, la valeur String est validée et traitée en tant qu'ID. `x` et `y` ne peuvent pas être booléens. La comparaison de deux chaînes est effectuée conformément aux paramètres régionaux de l'utilisateur contextuel.
`!=`	`x != y`	Opérateur d'inégalité. Si la valeur de `x` est différente de la valeur de `y`, l'expression évalue à true. Sinon, l'expression évalue à false. Remarque : Contrairement au langage Java, `!=` dans Apex compare l'égalité de la valeur de l'objet, pas l'égalité de la référence. Pour les sObject et les tableaux sObject, `!=` effectue une vérification approfondie de toutes les valeurs de champ sObject avant de renvoyer son résultat. Pour des enregistrements, `!=` évalue à true si les enregistrements ont des valeurs différentes pour un champ quelconque. `x` ou `y`peuvent être le `null` littéral. La comparaison de deux valeurs quelconques ne peut jamais donner `null`.
`!==`	`x !== y`	Opérateur d'inégalité identique. Si `x` et `y` ne référencent pas un emplacement identique dans la mémoire, l'expression évalue à true. Sinon, l'expression évalue à false. Notez que cet opérateur fonctionne uniquement pour des sObjects, des collections (telles que le mappage ou liste) ou un objet Apex (tel qu'une Exception ou l'instanciation d'une classe).
`+`	`x + y`	Opérateur d'addition. Ajoute la valeur de `x` à la valeur de `y` en fonction des règles suivantes : Si `x` et `y` sont des Integer ou des Double, il ajoute la valeur de `x` à la valeur de `y`. Si un Double est utilisé, le résultat est un Double. Si `x` est une Date et `y` un Integer, il renvoie une nouvelle Date qui est incrémentée par le nombre de jours spécifié. Si `x` est une Datetime et `y` est un Integer ou un Double, il renvoie une nouvelle Date qui est incrémentée par le nombre de jours spécifié, avec la partie fractionnaire correspondant à une partie du jour. Si `x` est une String et `y` est une String et n'importe quel autre type d'argument non `null`, il concatène `y` à la fin de `x`.
`-`	`x - y`	Opérateur de soustraction. Soustrait la valeur de `y` de la valeur de `x` en fonction des règles suivantes : Si `x` et `y` sont des Integer ou des Double, il soustrait la valeur de `x` de la valeur de `y`. Si un Double est utilisé, le résultat est un Double. Si `x` est une Date et `y` un Integer, il renvoie une nouvelle Date qui est décrémentée par le nombre de jours spécifié. Si `x` est une Datetime et `y` est un Integer ou un Double, il renvoie une nouvelle Date qui est décrémentée par le nombre de jours spécifié, avec la partie fractionnaire correspondant à une partie du jour.
`*`	`x * y`	Opérateur de multiplication. Multiplie `x`, un Integer ou un Double, avec `y`, un autre Integer ou Double. Notez que si un double est utilisé, le résultat est un Double.
`/`	`x / y`	Opérateur de division. Divise `x`, un Integer ou un Double, par `y`, un autre Integer ou Double. Notez que si un double est utilisé, le résultat est un Double.
`!`	`!x`	Opérateur de complément logique. Il inverse la valeur d'un booléen, de sorte que true devient false, et false devient true.
`-`	`-x`	Opérateur de négation unaire. Multiplie la valeur de `x`, un Integer ou un Double, par -1. Notez que l'équivalent positif `+` est également valide en termes de syntaxe, mais n'a aucun effet mathématique.
`++`	`x++` `++x`	Opérateur d'incrément. Ajoute 1 à la valeur de `x`, une variable de type numérique. Si elle a un préfixe (`++x`), l'expression évalue à la valeur de x après l'incrément. Si elle a un suffixe (`x++`), l'expression évalue à la valeur de x avant l'incrément.
`--`	`x--` `--x`	Opérateur de décrément. Soustrait 1 de la valeur de `x`, une variable de type numérique. Si elle a un préfixe (`--x`), l'expression évalue à la valeur de x après le décrément. Si elle a un suffixe (`x--`), l'expression évalue à la valeur de x avant le décrément.
`&`	`x & y`	Opérateur AND au niveau du bit. Associe avec des AND chaque bit dans `x` au bit correspondant dans `y` de sorte que le bit résultat est défini sur 1 si les deux bits sont définis sur 1. Cet opérateur n'est pas valide pour les types Long ou Integer.
`\|`	`x \| y`	Opérateur OR au niveau du bit. Associe avec des OR chaque bit dans `x` au bit correspondant dans `y` de sorte que le bit résultat est défini sur 1 si un bit au moins est défini sur 1. Cet opérateur n'est pas valide pour les types Long ou Integer.
`^`	`x ^ y`	Opérateur OR exclusif au niveau du bit. Associe avec des OR exclusifs chaque bit dans `x` au bit correspondant dans `y` de sorte que le bit résultat est défini sur 1 si exactement un bit est défini sur 1 et l'autre bit est défini sur 0.
`^=`	`x ^= y`	Opérateur OR exclusif au niveau du bit. Associe avec des OR exclusifs chaque bit dans `x` au bit correspondant dans `y` de sorte que le bit résultat est défini sur 1 si exactement un bit est défini sur 1 et l'autre bit est défini sur 0.
`<<`	`x << y`	Opérateur de décalage gauche au niveau du bit. Décale chaque bit dans `x` vers la gauche de `y` bits, de sorte que les bits de poids fort sont perdus, et les nouveaux bits droits sont définis sur 0.
`>>`	`x >> y`	Opérateur de décalage droit signé au niveau du bit. Décale chaque bit dans `x` vers la droite de `y` bits, de sorte que les bits de poids faible sont perdus, et les nouveaux bits gauches sont définis sur 0 pour des valeurs positives de `y` et sur 1 pour des valeurs négatives de `y`.
`>>>`	`x >>> y`	Opérateur de décalage droit non signé au niveau du bit. Décale chaque bit dans `x` vers la droite de `y` bits, de sorte que les bits de poids faible sont perdus, et les nouveaux bits gauches sont définis sur 0 pour toutes les valeurs de `y`.
`()`	`(x)`	Parenthèses. Élève la priorité d'une expression `x` de sorte qu'elle est évaluée en premier dans une expression composée.