ActionScript : Vérifiant l'égalité ou comparer des valeurs

Share

|

Vous voulez vérifier si deux valeurs sont égales.

Employez l'égalité (ou l'inégalité) ou l'opérateur strict d'égalité (ou inégalité stricte) pour comparer deux valeurs. Pour vérifier si une valeur est un nombre valide, employez l'isNaN().

Les expressions d'égalité renvoient toujours une valeur booléenne indiquant si les deux valeurs sont égales. Les opérateurs d'égalité (et inégalité) viennent dans des saveurs régulières et strictes. Les opérateurs réguliers d'égalité et d'inégalité vérifient si les deux expressions étant comparées peuvent être résolues à la même valeur après les avoir convertis en même datatype. Par exemple, notez que la corde "6" et le numéro 6 sont considérés égal parce que la corde "6" est convertie en numéro 6 avant comparaison :

trace(5 == 6) ; //affichages : trace(6 == faux
6) ; //affichages : trace(6 == vrai "6") ; 
//affichages : trace(5 == vrai "6") ; //affichages :
faux

Les retours logiques d'opérateur d'inégalité (! =) faux si deux valeurs sont égales et vraies si elles ne sont pas égales. Au besoin, les opérandes sont convertis en même datatype avant la comparaison :

trace(5 ! = 6) ; //affichages : trace(6 
vrai ! = 6) ; //affichages : trace(6 faux ! = 
"6") ; //affichages : trace(5 faux ! = "6") ; 
//affichages : vrai

D'autre part, l'égalité et d'inégalité d'opérateurs le contrôle stricts d'abord si les valeurs étant comparées sont du même datatype avant d'effectuer la comparaison. Les différences dans le datatype font renvoyer l'opérateur d'égalité strict faux et l'opérateur strict d'inégalité à de retour rectifient :

trace(6 === 6) ; //affichages : trace(6 === 
vrai "6") ; //affichages : trace(6 faux ! = = 6) ; 
//affichages : trace(6 faux ! = = "6") ; 
//affichages : vrai

Il y a une grande différence entre l'opérateur de tâche (=) et l'opérateur d'égalité (==). si vous employez l'opérateur de tâche au lieu de l'opérateur d'égalité, vous changez la valeur de la variable plutôt que d'examiner sa valeur courante.

Employer l'opérateur faux mène aux résultats inattendus. Dans l'exemple suivant, les égales myVar 5 au début, ainsi vous pourriez attendre le suivant si rapport à évaluer toujours à faux, empêchant le trace() de l'exécution :

variété = 5 myVar ; //code suivant est faux. 
Il devrait être si (== myVar 6) à la place si (= 6) myVar {les
trace("Rabbits sont des lapins.") ; } trace("myVar est" + myVar)
; //affichages : myVar est 6

Cependant, l'exemple emploie de manière erronée l'opérateur de tâche (=) au lieu de l'opérateur d'égalité (==). c'est-à-dire, ensembles myVar d'expression les = 6 myVar à 6 au lieu de l'essai si myVar est 6. Une fois utilisé dans si la clause, l'expression = 6 myVar est traitée comme numéro 6. Puisque tout nombre de non zéro utilisé dans une expression d'essai convertit en vrai booléen, l'action de trace() s'appelle. Remplacez l'expression d'essai avec le == myVar 6 à la place.

Vous pouvez vérifier le datatype d'un article en utilisant l'opérateur de typeof, comme suit :

variété = 5 myVar ; si (== myVar "nombre" de 
typeof) {trace("Yippee. C'est un nombre.") ; }

Mais quelques valeurs numériques sont inadmissibles. Les résultats suivants d'exemple dans myVar étant placé égal à NaN (une constante représentant des nombres inadmissibles, l'abréviation l'"Non-un-Nombre") parce que le calcul ne peut pas être exécuté dans une manière signicative :

variété = 15 myVar - "café" ;

En dépit de son nom, NaN est une valeur identifiée du datatype de nombre :

trace(typeof myVar) ; //affichages : "nombre"

Par conséquent, à l'essai si quelque chose est non seulement un nombre, mais à un nombre valide, vous pourriez essayer ceci :

variété = 15 myVar - "café" ; si (== myVar 
"nombre" de typeof) {// essai de Nice, mais ceci ne fonctionnera pas. 
si (myVar ! = NaN) {trace("Yippee. C'est un 
nombre.") ; }}

Vous ne pouvez pas simplement comparer une valeur à la constante NaN au contrôle si c'est un nombre valide. Au lieu de cela, vous devez employer la fonction spéciale d'isNaN() pour réaliser l'essai.

Pour déterminer si un nombre est inadmissible, employez la fonction spéciale d'isNaN(), comme suit :

variété = 15 myVar - "café" ; si (isNaN(myVar)) 
{trace("Sorry, ce n'est pas un nombre valide.") ; }

Pour examiner l'opposé d'une condition (c.-à-d., si la condition n'est pas vraie) employez PAS l'opérateur logique (!). par exemple, pour vérifier si une variable contient un nombre, un !isNAN(valides d'utilisation), comme suit :

variété = 15 myVar - "café" ; si (!isNaN(myVar)) 
{// nombre n'est pas inadmissible, ainsi ce doit être une trace 
valide de nombre ("qui est un nombre valide.") ; //ceci saute à
une autre armature, supposant que vous avez marqué une armature 
"SuccessScreen". gotoAndStop ("SuccessScreen") ; }

Naturellement, vous pouvez effectuer des comparaisons en utilisant les opérateurs bien connus de comparaison. Par exemple, vous pouvez employer > et < des opérateurs pour vérifier si une valeur est moins qu'ou plus grande qu'une autre valeur :

trace(5 < 6) ; //affichages : vrai trace(5 > 
5) ; //affichages : faux

De même, vous pouvez employer > = et < = des opérateurs pour vérifier si une valeur est inférieur ou égal à, ou supérieur ou égal à, une autre valeur :

trace(5 < = 6) ; //affichages : vrai trace(5 >
= 5) ; //affichages : vrai

Vous devriez également vous rendre compte qu'actionScript compare différents datatypes différemment. Des données d'ActionScript peuvent être classées par catégorie dans les datatypes primitifs (corde, nombre, et booléen) ou les datatypes composés (objet, movieclip, et rangée). Quand vous comparez les datatypes primitifs, ActionScript les compare "par valeur." Dans cet exemple, myVar et myOtherVar sont considérés égal parce qu'ils tous les deux contiennent la valeur 6.

variété = 6 myVar ; variété = 6 myOtherVar ; 
trace (== myVar myOtherVar) ; //affichages : vrai

Cependant, quand vous comparez les datatypes composés, ActionScript les compare "par la référence." Comparer des articles par la référence signifie que les deux articles sont considérés égaux seulement si les deux point exactement au même objet, pas simplement aux objets avec le contenu assorti. Par exemple, deux rangées contenant exactement les mêmes valeurs ne sont pas considérées égale :

//créez deux rangées avec le même arrayOne d'éléments
= nouvel Array("a", "b", "c") ; arrayTwo = nouvel Array("a", 
"b", "c") ; arrayTwo de == de trace(arrayOne) ; 
//affichages : faux

Deux articles composés sont égaux seulement s'ils tous les deux se rapportent à l'objet, à la rangée, ou à l'agrafe identique de film. Par exemple :

//créez un arrayOne simple de rangée = nouvel Array("a",
"b", "c") ; //créez une autre variable qui met en référence 
le mêmes arrayOne = arrayTwo de rangée ; arrayTwo de == de 
trace(arrayOne) ; //affichages : vrai