Desiderate controllare se due valori sono uguali.
|
|
Usi l'uguaglianza (o diseguaglianza) o l'operatore rigoroso diseguaglianza rigorosa o (di uguaglianza) per confrontare due valori. Per controllare se un valore sia un numero valido, usi il isNaN().
Le espressioni di uguaglianza restituiscono sempre un valore booleano che indica se i due valori sono uguali. Gli operatori diseguaglianza e (di uguaglianza) vengono sia nei sapori normali che rigorosi. Gli operatori normali di diseguaglianza e di uguaglianza controllano se le due espressioni che sono confrontate possano essere risolte allo stesso valore dopo avere convertitli in stesso datatype. Per esempio, noti che la stringa "6" ed il numero 6 sono considerati uguale perché la stringa "6" è convertita in numero 6 prima del confronto:
trace(5 == 6); //esposizioni: trace(6 == falso 6); //esposizioni: trace(6 == allineare "6"); //esposizioni: trace(5 == allineare "6"); //esposizioni: falso
I ritorni logici dell'operatore di diseguaglianza (! =) falsi se due valori sono uguali ed allineare se non sono uguali. Se necessario, gli operandi sono convertiti in stesso datatype prima del confronto:
trace(5! = 6); //esposizioni: trace(6 allineare! = 6); //esposizioni: trace(6 falso! = "6"); //esposizioni: trace(5 falso! = "6"); //esposizioni: allineare
D'altra parte, l'uguaglianza e di diseguaglianza degli operatori il controllo preliminare rigorosi se i valori che sono confrontati sono dello stesso datatype prima di realizzare il confronto. Le differenze nel datatype inducono l'operatore di uguaglianza rigoroso a restituire falso e l'operatore rigoroso di diseguaglianza a di ritorno allineare:
trace(6 === 6); //esposizioni: trace(6 === allineare "6"); //esposizioni: trace(6 falso! = = 6); //esposizioni: trace(6 falso! = = "6"); //esposizioni: allineare
Ci è una differenza grande fra l'operatore di
assegnazione (=) e l'operatore di uguaglianza (==). se usate
l'operatore di assegnazione anziché l'operatore di uguaglianza,
cambiate il valore della variabile piuttosto che verificare il
relativo valore corrente.
Usando l'operatore errato conduce ai risultati inattesi. Nel seguente esempio, i uguali myVar 5 inizialmente, in modo da voi potreste prevedere il successivo se dichiarazione da valutare sempre a falso, evitando il trace() essere eseguita:
varietà = 5 myVar; //seguente codice è errato.
Dovrebbe essere se (== myVar 6) preferibilmente se (= 6) myVar
{trace("Rabbits sono coniglietti."); } trace("myVar è" +
myVar); //esposizioni: myVar sono 6
Tuttavia, l'esempio usa erroneamente l'operatore di assegnazione (=) anziché l'operatore di uguaglianza (==). cioè insiemi myVar di espressione = i 6 myVar a 6 invece di prova se myVar sono 6. Una volta usato in se la clausola, l'espressione = 6 myVar è trattare come il numero 6. Poiché tutto il numero diverso da zero usato in un'espressione della prova si converte in allineare booleano, l'azione del trace() è denominata. Sostituisca l'espressione della prova con == myVar 6 preferibilmente.
Potete controllare il datatype dell'articolo usando l'operatore del typeof, come segue:
varietà = 5 myVar; se (== myVar "numero" del
typeof) {trace("Yippee. È un numero."); }
Ma alcuni valori numerici sono non validi. I seguenti risultati di esempio in myVar che è regolato uguale a NaN (un costante che rappresenta i numeri non validi, short per "il Non-un-Numero") perché il calcolo non può essere effettuato in un senso espressivo:
varietà = 15 myVar - "caffè";
Malgrado il relativo nome, NaN è un valore riconosciuto del datatype di numero:
trace(typeof myVar); //esposizioni: "numero"
Di conseguenza, alla prova se qualcosa è non soltanto un numero, ma ad un numero valido, potreste provare questo:
varietà = 15 myVar - "caffè"; se (== myVar
"numero" del typeof) {// prova de Nizza, ma questo non funzionerà.
se (myVar! = NaN) {trace("Yippee. È un numero.");
}}
Non potete confrontare semplicemente un valore al costante NaN al controllo se è un numero valido. Invece, dovete usare la funzione speciale del isNaN() per effettuare la prova.
Per determinare se un numero è non valido, usi la funzione speciale del isNaN(), come segue:
varietà = 15 myVar - "caffè"; se (isNaN(myVar))
{trace("Sorry, quello non è un numero valido."); }
Per verificare l'opposto di una circostanza (cioè, se la circostanza non è allineare) usi NON l'operatore logico (!). per esempio, per controllare se una variabile contenga un numero, un!isNAN(validi di uso), come segue:
varietà = 15 myVar - "caffè"; se (!isNaN(myVar))
{// numero non è non valido, in modo da deve essere una traccia
valida di numero ("che è un numero valido."); //questo salta ad
un'altra struttura, presupponente che abbiate identificato una
struttura "SuccessScreen". gotoAndStop ("SuccessScreen");
}
Naturalmente, potete realizzare i confronti usando gli operatori ben noti di confronto. Per esempio, potete usare > e < operatori per controllare se un valore è di meno che o più grande di un altro valore:
trace(5 < 6); //esposizioni: allineare trace(5 > 5); //esposizioni: falso
Similmente, potete usare > = e < = operatori per controllare se un valore è inferiore o uguale a, o superiore o uguale a, un altro valore:
trace(5 < = 6); //esposizioni: allineare trace(5 > = 5); //esposizioni: allineare
Dovreste anche essere informati che ActionScript confronta diversamente i datatypes differenti. I dati di ActionScript possono essere categorizzati nei datatypes primitivi (stringa, numero e booleano) o nei datatypes compositi (oggetto, movieclip ed allineamento). Quando confrontate i datatypes primitivi, ActionScript li confronta "da valore." In questo esempio, myVar e myOtherVar sono considerati uguale perché entrambi contengono il valore 6.
varietà = 6 myVar; varietà = 6 myOtherVar; traccia (== myVar myOtherVar); //esposizioni: allineare
Tuttavia, quando confrontate i datatypes compositi, ActionScript li confronta "da riferimento." Confrontare gli articoli da riferimento significa che i due articoli sono considerati uguali soltanto se entrambe il punto esattamente allo stesso oggetto, non soltanto agli oggetti con il soddisfare di corrispondenza. Per esempio, due allineamenti che contengono esattamente gli stessi valori non sono considerati uguale:
//generi due allineamenti con lo stesso arrayOne degli
elementi = nuovo Array("a", "b", "c"); arrayTwo = nuovo
Array("a", "b", "c"); arrayTwo del == di trace(arrayOne);
//esposizioni: falso
Due articoli compositi sono uguali soltanto se entrambi si riferiscono all'oggetto, all'allineamento, o alla clip identico di film. Per esempio:
//generi un singolo arrayOne di allineamento = nuovo
Array("a", "b", "c"); //generi un'altra variabile che riferisce
lo stessi arrayOne = arrayTwo di allineamento; arrayTwo del ==
di trace(arrayOne); //esposizioni: allineareOnline: 632 users browsing the articles directory
|
|