ActionScript: Comprobando igualdad o comparar valores

Share

|

Usted desea comprobar si dos valores son iguales.

Utilice a la igualdad (o a la desigualdad) o a operador terminante de la igualdad (o desigualdad terminante) para comparar dos valores. Para comprobar si un valor sea un número válido, utilice el isNaN().

Las expresiones de la igualdad vuelven siempre un valor boleano que indica si los dos valores son iguales. Los operadores de la igualdad (y desigualdad) vienen en sabores regulares y terminantes. Los operadores regulares de la igualdad y de la desigualdad comprueban si las dos expresiones que son comparadas se puedan resolver al mismo valor después de convertirlos al mismo datatype. Por ejemplo, observe que la secuencia "6" y el número 6 están considerados igual porque la secuencia "6" se convierte al número 6 antes de la comparación:

trace(5 == 6); //exhibiciones: trace(6 == 
falso 6); //exhibiciones: trace(6 == verdadero "6"); 
//exhibiciones: trace(5 == verdadero "6"); 
//exhibiciones: falso

Las vueltas lógicas del operador de la desigualdad (! =) falsas si dos valores son iguales y verdades si no son iguales. En caso de necesidad, los operandos se convierten al mismo datatype antes de la comparación:

trace(5! = 6); //exhibiciones: trace(6 
verdadero! = 6); //exhibiciones: trace(6 falso! = 
"6"); //exhibiciones: trace(5 falso! = "6"); 
//exhibiciones: verdad

Por otra parte, la igualdad y de la desigualdad de los operadores el cheque terminantes primero si los valores que son comparados están del mismo datatype antes de realizar la comparación. Las diferencias en datatype hacen a operador de igualdad terminante volver falso y el operador terminante de la desigualdad a de vuelta verdad:

trace(6 === 6); //exhibiciones: trace(6 === 
verdadero "6"); //exhibiciones: trace(6 falso! = = 
6); //exhibiciones: trace(6 falso! = = "6"); 
//exhibiciones: verdad

Hay una diferencia grande entre el operador de asignación (=) y el operador de igualdad (==). si usted utiliza a operador de asignación en vez del operador de igualdad, usted cambia el valor de la variable más bien que la prueba de su valor actual.

Usar al operador incorrecto conduce a los resultados inesperados. En el ejemplo siguiente, los iguales myVar 5 al principio, así que usted pudieron contar con el subsecuente si declaración a evaluar siempre a falso, previniendo el trace() de ser ejecutado:

var = 5 myVar; //el código siguiente es incorrecto.
Debe ser si (el == myVar 6) en lugar de otro si (= 6) myVar {los
trace("Rabbits son conejitos."); } trace("myVar es" + myVar); 
//exhibiciones: myVar es 6

Sin embargo, el ejemplo utiliza equivocadamente a operador de asignación (=) en vez del operador de igualdad (==). es decir, sistemas myVar de la expresión los = 6 myVar a 6 en vez de la prueba si son myVar es 6. Cuando está utilizado en si la cláusula, la expresión = 6 myVar se trata como el número 6. Porque cualquier número distinto a cero usado en una expresión de la prueba convierte al verdad boleano, se llama la acción del trace(). Substituya la expresión de la prueba por el == myVar 6 en lugar de otro.

Usted puede comprobar el datatype de un artículo usando al operador del typeof, como sigue:

var = 5 myVar; si (== myVar "número" del typeof) 
{trace("Yippee. Es un número."); }

Pero algunos valores numéricos son inválidos. Los resultados siguientes del ejemplo en myVar que es fijada igual a NaN (una constante que representa números inválidos, el cortocircuito para el "No-uno-Nu'mero") porque el cálculo no se puede realizar en una manera significativa:

var = 15 myVar - "café";

A pesar de su nombre, NaN es un valor reconocido del datatype del número:

trace(typeof myVar); //exhibiciones: 
"número"

Por lo tanto, a la prueba si algo es no solamente un número, solamente a un número válido, usted puede ser que intente esto:

var = 15 myVar - "café"; si (== myVar "número" del
typeof) {// intento de Niza, sino éste no trabajará. si 
(myVar! = NaN) {trace("Yippee. Es un número."); }}

Usted no puede comparar simplemente un valor a la constante NaN al cheque si es un número válido. En lugar, usted debe utilizar la función especial del isNaN() para realizar la prueba.

Para determinarse si un número es inválido, utilice la función especial del isNaN(), como sigue:

var = 15 myVar - "café"; si (isNaN(myVar)) 
{trace("Sorry, eso no es un número válido."); }

Para probar el contrario de una condición (es decir, si la condición no es verdad) utilice NO a operador lógico (!). por ejemplo, para comprobar si una variable contiene un número, un!isNAN(válidos del uso), como sigue:

var = 15 myVar - "café"; si (!isNaN(myVar)) {// el 
número no es inválido, así que debe ser un rastro válido del 
número ("que es un número válido."); //éste salta a otro 
marco, asumiendo que usted ha etiquetado un marco "SuccessScreen". 
gotoAndStop ("SuccessScreen"); }

Por supuesto, usted puede realizar comparaciones usando a los operadores bien conocidos de la comparación. Por ejemplo, usted puede utilizar > y < los operadores para comprobar si un valor es menos que o mayor que otro valor:

trace(5 < 6); //exhibiciones: verdad trace(5 >
5); //exhibiciones: falso

Semejantemente, usted puede utilizar > = y < = los operadores para comprobar si un valor es menos que o igual a, o mayores que o igual a, otro valor:

trace(5 < = 6); //exhibiciones: verdad trace(5
> = 5); //exhibiciones: verdad

Usted debe también estar enterado que ActionScript compara diversos datatypes diferentemente. Los datos de ActionScript se pueden categorizar en los datatypes primitivos (secuencia, número, y boleano) o los datatypes compuestos (objeto, movieclip, y arsenal). Cuando usted compara datatypes primitivos, ActionScript los compara "por valor." En este ejemplo, myVar y myOtherVar se consideran igual porque ambos contienen el valor 6.

var = 6 myVar; var = 6 myOtherVar; rastro (== 
myVar myOtherVar); //exhibiciones: verdad

Sin embargo, cuando usted compara datatypes compuestos, ActionScript los compara "por referencia." Comparar artículos por referencia significa que los dos artículos están considerados iguales solamente si ambo punto exactamente al mismo objeto, no simplemente a los objetos con el contenido que empareja. Por ejemplo, dos órdenes que contienen exactamente los mismos valores no se consideran igual:

//cree dos órdenes con el mismo arrayOne de los elementos
= Array("a nuevo", "b", "c"); arrayTwo = Array("a nuevo", "b", 
"c"); arrayTwo del == del trace(arrayOne); //exhibiciones:
falso

Dos artículos compuestos son iguales solamente si ambos refieren al objeto, al arsenal, o al clip idéntico de la película. Por ejemplo:

//cree un solo arrayOne del arsenal = Array("a nuevo", 
"b", "c"); //cree otra variable que se refiera al mismo arrayOne
= arrayTwo del arsenal; arrayTwo del == del trace(arrayOne); 
//exhibiciones: verdad