ActionScript: Verificando a igualdade ou comparar valores

Share

|

Você quer verificar se dois valores forem iguais.

Use a igualdade (ou o desigualdade) ou o operador estrito da igualdade (ou desigualdade estrito) comparar dois valores. Para verificar se um valor seja um número válido, use o isNaN().

As expressões da igualdade retornam sempre um valor booleano que indica se os dois valores são iguais. Os operadores da igualdade (e o desigualdade) vêm em sabores regulares e estritos. Os operadores regulares da igualdade e do desigualdade verificam se as duas expressões que estão sendo comparadas possam ser resolvidas ao mesmo valor após ter convertido os ao mesmo datatype. Para o exemplo, anote que a corda "6" e o número 6 estão considerados igual porque a corda "6" é convertida ao número 6 antes da comparação:

trace(5 == 6); //exposições: trace(6 == 
falso 6); //exposições: trace(6 == verdadeiro "6"); 
//exposições: trace(5 == verdadeiro "6"); 
//exposições: falso

Os retornos lógicos do operador do desigualdade (! =) falsos se dois valores forem iguais e verdadeiros se não forem iguais. Se necessário, os operandos são convertidos ao mesmo datatype antes da comparação:

trace(5! = 6); //exposições: trace(6 
verdadeiro! = 6); //exposições: trace(6 falso! = 
"6"); //exposições: trace(5 falso! = "6"); 
//exposições: verdadeiro

Na outra mão, da igualdade e do desigualdade dos operadores a verificação estrita primeiramente se os valores que estão sendo comparados são do mesmo datatype antes de executar a comparação. As diferenças no datatype fazem com que o operador de igualdade estrito retorne falso e o operador estrito do desigualdade a do retorno rectifica:

trace(6 === 6); //exposições: trace(6 === 
verdadeiro "6"); //exposições: trace(6 falso! = = 
6); //exposições: trace(6 falso! = = "6"); 
//exposições: verdadeiro

Há uma diferença grande entre o operador de atribuição (=) e o operador de igualdade (==). se você usar o operador de atribuição em vez do operador de igualdade, você muda o valor da variável melhor que testar seu valor atual.

Usar o operador errado conduz aos resultados inesperados. No seguinte exemplo, os semelhantes myVar 5 no início, assim que você puderam esperar o subseqüente se indicação a avaliar sempre a falso, impedindo o trace() de ser executado:

var = 5 myVar; //seguinte código é errado. 
Deve-se ser se (== myVar 6) preferivelmente se (= 6) myVar {os 
trace("Rabbits são bunnies."); } trace("myVar é" + myVar); 
//exposições: myVar são 6

Entretanto, o exemplo usa equivocadamente o operador de atribuição (=) em vez do operador de igualdade (==). isto é, jogos myVar da expressão = os 6 myVar a 6 em vez de testar se myVar são 6. Quando usado no se a cláusula, a expressão = 6 myVar for tratada como o número 6. Porque todo o número nonzero usado em uma expressão do teste se converte ao verdadeiro booleano, a ação do trace() é chamada. Substitua a expressão do teste com o == myVar 6 preferivelmente.

Você pode verificar o datatype de um artigo usando o operador do typeof, como segue:

var = 5 myVar; se (== myVar "número" do typeof) 
{trace("Yippee. É um número."); }

Mas alguns valores numéricos são inválidos. Os seguintes resultados do exemplo em myVar que está sendo ajustado igual a NaN (uma constante que representa números inválidos, short para o "Não-um-Número") porque o cálculo não pode ser executado em uma maneira significativa:

var = 15 myVar - "café";

Apesar de seu nome, NaN é um valor reconhecido do datatype do número:

trace(typeof myVar); //exposições: 
"número"

Conseqüentemente, ao teste se algo fosse não somente um número, mas a um número válido, você pôde tentar este:

var = 15 myVar - "café"; se (== myVar "número" do 
typeof) {// tentativa de Nice, mas este não trabalhará. se 
(myVar! = NaN) {trace("Yippee. É um número."); }}

Você não pode simplesmente comparar um valor à constante NaN à verificação se é um número válido. Instead, você deve usar a função especial do isNaN() executar o teste.

Para determinar se um número for inválido, use a função especial do isNaN(), como segue:

var = 15 myVar - "café"; se (isNaN(myVar)) 
{trace("Sorry, aquele não é um número válido."); }

Para testar o oposto de uma circunstância (isto é, se a circunstância não é verdadeira) use NÃO o operador lógico (!). para o exemplo, verificar se uma variável contenha um número, um!isNAN(válidos do uso), como segue:

var = 15 myVar - "café"; se (!isNaN(myVar)) {// 
número não é inválido, assim que deve ser um traço válido do 
número ("que seja um número válido."); //este salta a um 
outro frame, supondo que você etiquetou um frame "SuccessScreen". 
gotoAndStop ("SuccessScreen"); }

Naturalmente, você pode executar comparações usando os operadores well-known da comparação. Para o exemplo, você pode usar > e < os operadores para verificar se um valor for menos do que ou mais grande do que um outro valor:

trace(5 < 6); //exposições: verdadeiro 
trace(5 > 5); //exposições: falso

Similarmente, você pode usar > = e < = os operadores para verificar se um valor for menos do que ou igual a, ou mais grandes do que ou o semelhante a, um outro valor:

trace(5 < = 6); //exposições: verdadeiro 
trace(5 > = 5); //exposições: verdadeiro

Você deve também estar ciente que ActionScript compara datatypes diferentes diferentemente. Os dados de ActionScript podem ser categorizados em datatypes primitivos (corda, número, e booleano) ou em datatypes compostos (objeto, movieclip, e disposição). Quando você compara datatypes primitivos, ActionScript compara-os "pelo valor." Neste exemplo, myVar e myOtherVar são considerados igual porque ambos contêm o valor 6.

var = 6 myVar; var = 6 myOtherVar; traço (== 
myVar myOtherVar); //exposições: verdadeiro

Entretanto, quando você compara datatypes compostos, ActionScript compara-os "pela referência." Comparar artigos pela referência significa que os dois artigos estão considerados iguais somente se ambo o ponto exatamente ao mesmo objeto, não meramente aos objetos com índices combinando. Para o exemplo, duas disposições que contêm exatamente os mesmos valores não são consideradas igual:

//críe duas disposições com o mesmo arrayOne dos 
elementos = Array("a novo", "b", "c"); arrayTwo = Array("a 
novo", "b", "c"); arrayTwo do == do trace(arrayOne); 
//exposições: falso

Dois artigos compostos são iguais somente se ambos consultam ao objeto, à disposição, ou ao grampo idêntico do filme. Para o exemplo:

//críe um único arrayOne da disposição = Array("a 
novo", "b", "c"); //críe uma outra variável que references o 
mesmos arrayOne = arrayTwo da disposição; arrayTwo do == do 
trace(arrayOne); //exposições: verdadeiro