!= Ungleichheits-Operator

expression1 != expression2

Prüft auf das Gegenteil des Gleichheits-Operators (==). Wenn expression1 gleich expression2 ist, lautet das Ergebnis false. Wie auch beim strikten Gleichheits-Operator (==) hängt die Definition von "gleich" von den verglichenen Datentypen ab, wie aus folgender Liste hervorgeht:

Zahlen, Strings und boolesche Werte werden anhand ihres Werts verglichen.
Objekte, Arrays und Funktionen werden anhand ihrer Referenz verglichen.
Variablen werden je nach Typ entweder anhand ihrer Werte oder anhand ihrer Referenz verglichen.

Ein Vergleich nach Wert bedeutet, was in der Regel unter "gleich" verstanden wird, d. h., dass zwei Ausdrücke den gleichen Wert aufweisen. So entspricht bei einem Wertevergleich beispielsweise der Ausdruck (2 + 3) dem Wert des Ausdrucks (1 + 4).

Ein Vergleich nach Referenz bedeutet, dass zwei Ausdrücke nur dann gleich sind, wenn beide das gleiche Objekt referenzieren, z. B. ein Objekt, ein Array oder eine Funktion. Die in den Objekten, Arrays oder Funktionen enthaltenen Werte werden dabei nicht verglichen.

Wenn expression1 und expression2 bei einem Wertevergleich unterschiedliche Datentypen aufweisen, versucht ActionScript den Datentyp von expression2 an den von expression1 anzugleichen.

Verfügbarkeit: ActionScript 1.0, Flash Lite 2.0

Operanden

expression1 : Object - Eine Zahl, ein String, ein boolescher Wert, eine Variable, ein Objekt, ein Array oder eine Funktion.

expression2 : Object - Eine Zahl, ein String, ein boolescher Wert, eine Variable, ein Objekt, ein Array oder eine Funktion.

Rückgabewerte

Boolean - Das boolesche Ergebnis des Vergleichs.

Beispiel

Im folgenden Beispiel werden die Ergebnisse des Ungleichheits-Operators (!=) veranschaulicht:

trace(5 != 8); // Rückgabewert: true
trace(5 != 5) // Rückgabewert: false

Im folgenden Beispiel werden die Ergebnisse des Ungleichheits-Operators (!=) in einer if-Anweisung veranschaulicht:

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

Das folgende Beispiel veranschaulicht anhand zweier Funktionen einen Vergleich nach Referenz:

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
// Ausgabe der Anweisung: foo foo true foo foo false

Das folgende Beispiel veranschaulicht anhand zweier Arrays einen Vergleich nach Referenz:

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
// Ausgabe der Anweisung: 1,2,3 1,2,3 true 1,2,3 1,2,3 false

Siehe auch

! logischer NOT-Operator, !== Strikter Ungleichheits-Operator, && logischer AND-Operator, || logischer OR-Operator, == Gleichheits-Operator, === Strikter Gleichheits-Operator