Vérifier si la variable est un nombre ou une chaîne en JavaScript

la meilleure façon de faire qui utilise le type de coulée isNaN+:

mise à Jour de tous-dans la méthode:

function isNumber(n) { return !isNaN(parseFloat(n)) && !isNaN(n - 0) }

même utilisation de regex:

function isNumber(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n); } 

------------------------

isNumber ('123'); // true  
isNumber ('123abc'); // true  
isNumber (5); // true  
isNumber ('q345'); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber('   '); // false

le meilleur moyen que j'ai trouvé est de vérifier une méthode sur la chaîne, i.e.:

if (x.substring) {
// do string thing
} else{
// do other thing
}

ou si vous voulez faire quelque chose avec le nombre vérifier pour une propriété de nombre,

if (x.toFixed) {
// do number thing
} else {
// do other thing
}

C'est un peu comme "duck typing", c'est à vous de quelle manière la plus logique. Je n'ai pas assez de karma, de commenter, mais typeof échoue pour en boîte des chaînes et des nombres, c'est à dire:

alert(typeof new String('Hello World'));
alert(typeof new Number(5));

va alerter "objet".

vérifier si la valeur est une chaîne littérale ou un objet String:

function isString(o) {
    return typeof o == "string" || (typeof o == "object" && o.constructor === String);
}

essai unitaire:

function assertTrue(value, message) {
    if (!value) {
        alert("Assertion error: " + message);
    }
}

function assertFalse(value, message)
{
    assertTrue(!value, message);
}

assertTrue(isString("string literal"), "number literal");
assertTrue(isString(new String("String object")), "String object");
assertFalse(isString(1), "number literal");
assertFalse(isString(true), "boolean literal");
assertFalse(isString({}), "object");

vérifier un numéro est similaire:

function isNumber(o) {
    return typeof o == "number" || (typeof o == "object" && o.constructor === Number);
}

Vous êtes à la recherche pour isNaN():

<script type="text/javascript">
  alert(isNaN(123));
  alert(isNaN(-1.23));
  alert(isNaN(5-2));
  alert(isNaN(0));
  alert(isNaN("Hello"));
  alert(isNaN("2005/12/12"));
</script>

voir fonction JavaScript isNaN () sur MDN.

Essayez cette,

<script>
var regInteger = /^\d+$/;

function isInteger( str ) {    
    return regInteger.test( str );
}

if(isInteger("1a11")) {
   console.log( 'Integer' );
} else {
   console.log( 'Non Integer' );
}
</script>

depuis ES2015 la bonne façon de vérifier si une variable titulaire d'un numéro valide est:

Number.isFinite(value)

exemples:

Number.isFinite(Infinity)   // false
Number.isFinite(NaN)        // false
Number.isFinite(-Infinity)  // false

Number.isFinite(0)          // true
Number.isFinite(2e64)       // true

Number.isFinite('0')        // false
Number.isFinite(null)       // false

//testing data types accurately in JavaScript (opposed to "typeof")
//from http://bonsaiden.github.com/JavaScript-Garden/
function is(type, obj) {
    var clas = Object.prototype.toString.call(obj).slice(8, -1);
    return obj !== undefined && obj !== null && clas === type;
}

//basic usage
is('String', 'test'); // true
is('Array', true); // false

Ou l'adapter pour retourner un type inconnu:

function realTypeOf(obj) {
    return Object.prototype.toString.call(obj).slice(8, -1);
}

//usage
realTypeOf(999); // 'Number'

12 Mai 2012 Mise À Jour: Exemple complet à Javascript: une meilleure typede .

meilleure façon de le faire:

function isNumber(num) {
  return (typeof num == 'string' || typeof num == 'number') && !isNaN(num - 0) && num !== '';
};

cela satisfait aux cas d'essai suivants:

assertEquals("ISNUMBER-True: 0", true, isNumber(0));
assertEquals("ISNUMBER-True: 1", true, isNumber(-1));
assertEquals("ISNUMBER-True: 2", true, isNumber(-500));
assertEquals("ISNUMBER-True: 3", true, isNumber(15000));
assertEquals("ISNUMBER-True: 4", true, isNumber(0.35));
assertEquals("ISNUMBER-True: 5", true, isNumber(-10.35));
assertEquals("ISNUMBER-True: 6", true, isNumber(2.534e25));
assertEquals("ISNUMBER-True: 7", true, isNumber('2.534e25'));
assertEquals("ISNUMBER-True: 8", true, isNumber('52334'));
assertEquals("ISNUMBER-True: 9", true, isNumber('-234'));

assertEquals("ISNUMBER-False: 0", false, isNumber(NaN));
assertEquals("ISNUMBER-False: 1", false, isNumber({}));
assertEquals("ISNUMBER-False: 2", false, isNumber([]));
assertEquals("ISNUMBER-False: 3", false, isNumber(''));
assertEquals("ISNUMBER-False: 4", false, isNumber('one'));
assertEquals("ISNUMBER-False: 5", false, isNumber(true));
assertEquals("ISNUMBER-False: 6", false, isNumber(false));
assertEquals("ISNUMBER-False: 7", false, isNumber());
assertEquals("ISNUMBER-False: 8", false, isNumber(undefined));
assertEquals("ISNUMBER-False: 9", false, isNumber(null));

voici une approche basée sur l'idée de forcer l'entrée à un nombre ou une chaîne en ajoutant zéro ou la chaîne nulle, puis faire une comparaison d'égalité dactylographiée.

function is_number(x) { return x === x+0;  }
function is_string(x) { return x === x+""; }

pour une raison insondable, x===x+0 semble donner de meilleurs résultats que x===+x .

y a-t-il des cas où cela échoue?

dans la même veine:

function is_boolean(x) { return x === !!x; }

Cela semble être légèrement plus rapide que x===true || x===false ou typeof x==="boolean" (et beaucoup plus rapide que x===Boolean(x) ).

puis il y a aussi

function is_regexp(x)  { return x === RegExp(x); }

tout cela dépend de l'existence d'une opération" d'identité " propre à chaque type qui peut être appliquée à n'importe quelle valeur et produire de manière fiable une valeur du type en question. Je ne peux pas penser à une telle opération pour les dates.

pour NaN, il y a

function is_nan(x) { return x !== x;}

C'est fondamentalement la version de underscore, et comme il se présente est environ quatre fois plus rapide que isNaN() , mais les commentaires dans le underscore source mentionnent que "NaN est le seul nombre qui ne se vaut pas" et ajoute un chèque pour _.isNumber. Pourquoi? Quels autres objets ne seraient pas égaux? Aussi, underscore utilise x !== +x --mais quelle différence pourrait faire le + ici?

puis pour les paranoïaques:

function is_undefined(x) { return x===[][0]; }

pouvez-vous le diviser par 1?

je suppose que le problème serait une entrée de chaîne comme: "123ABG"

var Check = "123ABG"

if(Check == Check / 1)
{
alert("This IS a number \n")
}

else
{
alert("This is NOT a number \n")
}

comme je l'ai fait récemment.

Que diriez-vous de juste:

function IsString(obj) {
    return obj !== undefined && obj != null && obj.toLowerCase !== undefined;
}

après un examen plus approfondi plusieurs mois plus tard, cela garantit seulement obj est un objet qui a le nom de la méthode ou de la propriété toLowerCase défini. Je suis honteux de ma réponse. Veuillez voir le haut-voté typeof .

je pense que la conversion du var en chaîne diminue les performances, au moins ce test effectué dans les derniers navigateurs montre.

donc si vous vous souciez de la performance, j'utiliserais ceci:

typeof str === "string" || str instanceof String

pour vérifier si la variable est une chaîne de caractères (même si vous utilisez var str = new String("foo") , str instanceof String renvoie vrai).

comme pour vérifier si c'est un nombre que j'irais pour le natif: isNaN ; fonction.

ou tout simplement utiliser l'inverse de l'isNaN

if (!isNaN (données)) faire quelque chose avec le nombre autre c'est une chaîne

et oui - à l'aide de jQuery $.isNumeric() est plus amusant pour le mâle.

Cette solution résout bon nombre des questions soulevées ici!

C'est de loin la méthode la plus fiable que j'ai utilisée. Je n'ai pas inventé cela, et ne me souviens pas où je l'ai d'abord trouvé. Mais cela fonctionne là où d'autres techniques échouent:

// Begin public utility /getVarType/
// Returns 'Function', 'Object', 'Array',
// 'String', 'Number', 'Boolean', or 'Undefined'
getVarType = function ( data ){
  if (undefined === data ){ return 'Undefined'; }
  if (data === null ){ return 'Null'; }
  return {}.toString.call(data).slice(8, -1);
};  
// End public utility /getVarType/

exemple d'exactitude

var str = new String();
console.warn( getVarType(str) ); // Reports "String"    
console.warn( typeof str );      // Reports "object"

var num = new Number();
console.warn( getVarType(num) ); // Reports "Number"
console.warn( typeof num );      // Reports "object"

var list = [];
console.warn( getVarType( list ) ); // Reports "Array"
console.warn( typeof list );        // Reports "object"

type de fonctionne très bien pour moi dans la plupart des cas. Vous pouvez essayer d'utiliser une instruction if

if(typeof x === 'string' || typeof x === 'number') {
    console.log("Your statement");
}

où x est une variable du nom de votre choix

la meilleure façon que j'ai trouvé qui pense aussi des nombres positifs et négatifs est de : O'Reilly, Javascript et DHTML livre de cuisine :

function isNumber(elem) {
var str = elem.value;
var oneDecimal = false;
var oneChar = 0;
// make sure value hasn't cast to a number data type
str = str.toString( );
for (var i = 0; i < str.length; i++) {
    oneChar = str.charAt(i).charCodeAt(0);
    // OK for minus sign as first character
    if (oneChar =  = 45) {
        if (i =  = 0) {
            continue;
        } else {
            alert("Only the first character may be a minus sign.");
            return false;
        }
    }
    // OK for one decimal point
    if (oneChar =  = 46) {
        if (!oneDecimal) {
            oneDecimal = true;
            continue;
        } else {
            alert("Only one decimal is allowed in a number.");
            return false;
        }
    }
    // characters outside of 0 through 9 not OK
    if (oneChar < 48 || oneChar > 57) {
        alert("Enter only numbers into the field.");
        return false;
    }
}
return true;

}

Errr? Utilisez juste des expressions régulières! :)

function isInteger(val) {
  return val.match(/^[0-9]$/)
}

function isFloat(val) {
  return val.match(/^[0-9]*/\.[0-9]+$/)
}

comme une chaîne comme '1234' avec typeof montrera 'string', et l'inverse ne peut jamais se produire (typeof 123 sera toujours nombre), le mieux est d'utiliser un regex simple /^\-?\d+$/.test(var) . Ou un plus avancé pour faire correspondre des flotteurs, des entiers et des nombres négatifs, /^[\-\+]?[\d]+\.?(\d+)?$/ Le côté important de .test est qu'il ne va pas jeter une exception si le var n'est pas une chaîne, la valeur peut être n'importe quoi.

var val, regex = /^[\-\+]?[\d]+\.?(\d+)?$/;

regex.test(val)       // false 
val = '1234';
regex.test(val)       // true
val = '-213';
regex.test(val)       // true
val = '-213.2312';
regex.test(val)       // true
val = '+213.2312';
regex.test(val)       // true
val = 123;
regex.test(val)       // true
val = new Number(123);
regex.test(val)       // true
val = new String('123');
regex.test(val)       // true
val = '1234e';
regex.test(val)       // false 
val = {};
regex.test(val)       // false 
val = false;
regex.test(val)       // false 
regex.test(undefined) // false 
regex.test(null)      // false 
regex.test(window)    // false 
regex.test(document)  // false 

si vous recherchez le type réel, puis Type de seront les seuls à le faire.

la réponse de @Bitofununisse est bonne, et je trouve une nouvelle voie:

function isNum(n) {
    return !isNaN(n/0);
}

isNum('')  // false
isNum(2)   // true
isNum('2k') // false
isNum('2')  //true

je sais 0 ne peut pas être dividende, mais ici, la fonction fonctionne parfaitement.

POUR INFORMATION, Si vous utilisez jQuery vous avez

$.isNumeric() 

pour gérer ça. Plus de détails sur http://api.jquery.com/jQuery.isNumeric /

jQuery utilise ceci:

function isNumber(obj) {
  return !isNaN( parseFloat( obj ) ) && isFinite( obj );
}

utilisation simple

myVar.constructor == String

ou

myVar.constructor == Number

si vous voulez manipuler des chaînes définies comme objets ou littérales et Sauve vous ne voulez pas utiliser une fonction helper.

function IsNumeric(num) {
    return ((num >=0 || num < 0)&& (parseInt(num)==num) );
}

très tard à la fête; cependant, ce qui suit a toujours bien fonctionné pour moi quand je veux vérifier si une entrée est une chaîne ou un nombre dans un coup.

return !!Object.prototype.toString.call(input).match(/\[object (String|Number)\]/);

a créé un jsperf sur la vérification si une variable est un nombre. Très intéressant! typeof a réellement une utilisation de performance. En utilisant typeof pour tout autre que des nombres, va généralement un 1 / 3ème de la vitesse comme un variable.constructor puisque la majorité des types de données en javascript sont des objets; les nombres ne sont pas!

http://jsperf.com/jemiloii-fastest-method-to-check-if-type-is-a-number

typeof variable === 'number' | le plus rapide | si vous vous voulez un nombre, comme 5, et pas '5'

typeof parseFloat(variable) === 'number' | le plus rapide / si vous voulez un nombre, comme 5, et' 5 '

isNaN() est plus lent, mais pas beaucoup. J'avais de grands espoirs pour parseInt et parseFloat , mais ils étaient horriblement plus lents.

pour la détection des nombres, le passage suivant de JavaScript: the Good Parts de Douglas Crockford est pertinent:

la fonction isFinite est la meilleure façon de déterminer si une valeur peut être utilisée comme un nombre parce qu'elle rejette NaN et L'infini . Malheureusement, isFinite va tenter de convertir son opérande en un nombre, ce n'est donc pas un bon test si une valeur n'est pas en fait un nombre. Vous pouvez définir votre propre fonction isNumber:

var isNumber = function isNumber(value) { return typeof value === 'number' &&
            isFinite(value);
};