Opérateur === d'égalité stricte

expression1 === expression2

Teste l'égalité de deux expressions ; l'opérateur d'égalité stricte (===) se comporte de la même façon que l'opérateur d'égalité (==), à la différence que les types de données ne sont pas convertis. Le résultat est true lorsque les deux expressions sont égales, types de données inclus.

La définition de l'égalité dépend du type de données du paramètre :

Les nombres ou les valeurs booléennes sont considérés comme égaux lorsque leur valeur est identique.
Les expressions de type String sont égales lorsqu'elles comportent le même nombre de caractères et que ces caractères sont identiques.
Les variables représentant des objets, des tableaux et des fonctions sont comparées par référence. Deux variables sont égales lorsqu'elles font référence au même objet, au même tableau ou à la même fonction. Deux tableaux distincts ne sont jamais considérés comme égaux, même s'ils comportent le même nombre d'éléments.

Disponibilité : ActionScript 1.0 ; Flash Lite 2.0

Opérandes

expression1 : Object - Nombre, chaîne, valeur booléenne, variable, objet, tableau ou fonction.

expression2 : Object - Nombre, chaîne, valeur booléenne, variable, objet, tableau ou fonction.

Valeur renvoyée

Boolean - Résultat booléen de la comparaison.

Exemple

Les commentaires inclus dans le code suivant affichent la valeur renvoyée des opérations qui utilisent les opérateurs d'égalité et d'égalité stricte :

 // Les deux instructions renvoient true, car aucune conversion ne se 
 // produit 
var string1:String = "5"; 
var string2:String = "5"; 
trace(string1 == string2); // true 
trace(string1 === string2); // true 
// Le typage automatique des données convertit 5 en « 5 » dans cet exemple 
var string1:String = "5"; 
var num:Number = 5; 
trace(string1 == num); // true 
trace(string1 === num); // false 
// Le typage automatique des données convertit vrai en « 1 » dans cet 
// exemple 
var string1:String = "1"; 
var bool1:Boolean = true; 
trace(string1 == bool1); // true 
trace(string1 === bool1); // false 
// Le typage automatique des données convertit false en « 0 » dans cet 
// exemple 
var string1:String = "0"; 
var bool2:Boolean = false; 
trace(string1 == bool2); // true 
trace(string1 === bool2); // false

Les exemples suivants illustrent la façon dont l'opérateur d'égalité stricte traite les références de variables différemment des variables incluant des valeurs littérales. C'est l'une des raisons pour laquelle il convient d'utiliser de façon systématique des littéraux de chaîne et d'éviter d'utiliser l'opérateur new avec la classe String.

// Crée une variable de type chaîne à partir d'une valeur littérale 
var str:String = "asdf"; 
// Crée une variable qui est une référence 
var stringRef:String = new String("asdf"); 
// L'opérateur d'égalité ne fait pas de différence entre les littéraux, 
// les variables et les références 
trace(stringRef == "asdf"); // true 
trace(stringRef == str); // true 
trace("asdf" == str); // true 
// L'opérateur d'égalité stricte analyse les variables qui sont des 
// références par oppositions aux littéraux et aux variables 
trace(stringRef === "asdf"); // false 
trace(stringRef === str); // false

Voir aussi

Opérateur ! NOT logique, Opérateur != (inégalité), Opérateur !== d'inégalité stricte, Opérateur && (AND logique), Opérateur || (OR logique), Opérateur == (égalité)