La manière la plus simple de vérifier si une chaîne convertie en nombre est réellement un nombre dans actionscript

Question

Je ne sais pas si cela a du sens, mais j'ai besoin de vérifier si une valeur de serveur retournée est réellement un nombre. À l'heure actuelle, je reçois toutes les valeurs de nombre retournées comme chaînes soit '7' au lieu de 7.

Quelle est la manière la plus simple de vérifier si les valeurs de chaîne peuvent réellement être converties en nombres?

Answer 1

Vous pouvez remarquer que dans actionscript:

trace(int('7')); // will return 7 

et

trace(int('a')); // will return 0 

Donc, à l'exception des zéros, vous pouvez réellement maintenant si une chaîne est un nombre ou non

Answer 2

typeof('7') == 'string' 
typeof(7) == 'number' 

Est ce que ça aide?

Answer 3

La méthode la plus simple consiste à convertir la chaîne en nombre et à tester si elle est NaN. Si vous regardez la référence de l'API Flex, la fonction Number() de niveau supérieur indique qu'elle retournera NaN si la chaîne transmise à la méthode ne peut pas être convertie en nombre.

Heureusement, Flex (en quelque sorte) le fait pour vous, avec la fonction isNaN(). Tout ce que vous devez faire est:

var testFlag:Boolean = isNaN(someStringThatMightBeANumber); 

Si testFlag est faux, la chaîne peut être convertie en un nombre, sinon il ne peut pas être converti.

Modifier

ci-dessus ne fonctionnera pas si la compilation en mode strict. Au lieu de cela, vous devrez d'abord convertir en nombre et puis vérifier NaN, comme suit:

var testFlag:Boolean = isNaN(Number(someStringThatMightBeANumber)); 

Answer 4

ai pas testé, mais cela devrait fonctionner:

if(isNaN(theString)) { 
    trace("it is a string"); 
} else { 
    trace("it is a number"); 
} 

Si vous utilisez AS3 et/ou le mode strict (comme l'a souligné back2dos), vous devrez convertir en premier numéro pour que le compiler:

if(isNaN(Number(theString))) { 
    trace("it is a string"); 
} else { 
    trace("it is a number"); 
} 

Answer 5

ce essaiera de convertir votre String à un Number , Qui est essentiellement un 64 bits nombre à virgule flottante:

var val:Number = Number(sourceString); 

si sourceString n'est pas une représentation String valide d'un Number, val sera NaN (pas un nombre) ... vous vérifiez contre cette valeur avec isNaN ... parce que val == NaN retournera faux pour une raison qui ne peut pas tout à fait comprendre ... vous pouvez utiliser int(val) == val pour vérifier, que ce soit une valeur intégrale ...

greetz

back2dos

Answer 6

function isANumber(__str:String):Boolean 
{ 
    return !isNaN(Number(__str)); 
} 

Answer 7

Voici une autre façon de vérifier si la valeur peut être convertie en un nombre:

var ob:Object = {a:'2',b:3,c:'string'}; 

for(var v:* in ob){ 
var nr:Number = ob[v]; 
trace(ob[v]+" "+(nr === Number(nr))) 
} 

cette tracera suivante:

2 true 
3 true 
string false 

Answer 8

RegE chemin xp:

function stringIsAValidNumber(s: String) : Boolean { 
    return Boolean(s.match(/^[0-9]+.?[0-9]+$/)); 
} 

Answer 9

Placez ceci dans une fonction où vous voulez des chiffres pour rester
joy_edit1 est un objet TextInput (étincelle)

//is a number check 
if(isNaN(Number(joy_edit1.text))) { 
    joy_edit1.text = ""; 
    return void; 
} 

Answer 10

La plupart des réponses sur cette question ont un défaut majeur leur. Si vous prenez Number (null) ou Number (undefined) ou Number (""), tous retourneront 0 et évalueront "est un nombre". Essayez quelque chose comme ceci:

function isANumber(val:*):Boolean { 
    return !(val === null || val === "" || isNaN(val)); 
} 

Answer 11

Vous devez utiliser la solution native d'Adobe:

parseInt et parseFloat méthodes.

lire également la description isNaN:

Renvoie true si la valeur est NaN (pas un nombre). La fonction isNaN() est utile pour vérifier si une expression mathématique évalue correctement un nombre à . L'utilisation la plus courante de isNaN() est de vérifier la valeur renvoyée par les fonctions parseInt() et parseFloat(). La valeur NaN est un membre spécial du type de données Nombre qui représente une valeur qui n'est "pas un nombre".

Voici une implémentation simple:

function isANumber(value:String):Boolean { 
    return !isNaN(parseFloat(value)); 
}