Opérateur != (inégalité)

expression1 != expression2

Recherche l'inverse de l'opérateur d'égalité (==). Si expression1 est égale à expression2 , le résultat est false. Comme pour l'opérateur d'égalité (==), la définition de l'égalité dépend des types de données comparés, comme illustré dans la liste suivante :

Les valeurs booléennes, les nombres et les chaînes sont comparés en fonction de leur valeur.
Les objets, les tableaux et les fonctions sont comparés par référence.
Une variable est comparée par valeur ou par référence, en fonction de son type.

La comparaison par valeur, comme son nom l'indique signifie que deux expressions ont la même valeur. Par exemple, l'expression (2 + 3) est égale à l'expression (1 + 4) lorsque la comparaison porte sur la valeur.

La comparaison par référence signifie que deux expressions ne sont égales que si elles font toutes deux référence au même objet, tableau ou fonction. Les valeurs figurant dans l'objet, le tableau ou la fonction ne sont pas comparées.

Lorsque la comparaison porte sur la valeur, si expression1 et expression2 ont un type de donnée différent, ActionScript tente de convertir le type de données d' expression2 pour le faire correspondre à celui d'expression1.

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

L'exemple suivant affiche le résultat de l'opérateur d'inégalité (!=) :

trace(5 != 8); // Renvoie true 
trace(5 != 5) // Renvoie false

L'exemple suivant illustre l'utilisation de l'opérateur d'inégalité (!=) dans une instruction if :

var a:String = "David";
var b:String = "Fool";
if (a != b) { 
 trace("David is not a fool"); 
}

L'exemple suivant illustre la comparaison par référence avec deux fonctions :

var a:Function = function() { trace("foo"); }; 
var b:Function = function() { trace("foo"); }; 
a(); // foo 
b(); // foo 
trace(a != b); // true 
a = b; 
a(); // foo 
b(); // foo 
trace(a != b); // false 
// Renvoie la sortie de l'instruction : foo foo true foo foo false

L'exemple suivant illustre la comparaison par référence avec deux tableaux :

var a:Array = [ 1, 2, 3 ]; 
var b:Array = [ 1, 2, 3 ]; 
trace(a); // 1, 2, 3 
trace(b); // 1, 2, 3 
trace(a!=b); // true 
a = b; 
trace(a); // 1, 2, 3 
trace(b); // 1, 2, 3 
trace(a != b); // false 
// Renvoie la sortie de l'instruction : 1,2,3 1,2,3 true 1,2,3 1,2,3 false

Voir aussi

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