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

est-ce que quelqu'un sait comment je peux vérifier si une variable est un nombre ou une chaîne en JavaScript?

417
demandé sur Brett DeWoody 2009-08-20 06:23:20

27 réponses

si vous avez affaire à une notation littérale, et non à des constructeurs, vous pouvez utiliser typeof :.

typeof "Hello World"; // string
typeof 123;           // number

si vous créez des nombres et des chaînes via un constructeur, comme var foo = new String("foo") , vous devez garder à l'esprit que typeof peut retourner object pour foo .

peut-être une méthode plus infaillible de vérifier le type serait d'utiliser la méthode trouvée dans underscore.js (source annotée peut être trouvé ici ),

var toString = Object.prototype.toString;

_.isString = function (obj) {
  return toString.call(obj) == '[object String]';
}

renvoie un booléen true pour le suivant:

_.isString("Jonathan"); // true
_.isString(new String("Jonathan")); // true
404
répondu Sampson 2013-04-22 13:00:04

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
179
répondu BitOfUniverse 2017-12-04 14:36:23

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".

72
répondu Alokito 2011-01-13 17:39:48

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);
}
27
répondu snorbi 2012-03-15 22:26:02

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.

22
répondu Jakob Gade 2014-04-20 23:20:08

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>
17
répondu adatapost 2015-01-28 08:55:31

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
16
répondu adius 2016-04-10 17:59:25
//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 .

13
répondu mrrena 2012-05-13 03:09:39

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));
12
répondu Sitch 2011-08-25 19:14:18

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]; }
8
répondu 2013-06-19 12:52:55

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.

7
répondu Luke 2012-03-06 11:01:48

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 .

7
répondu ZagNut 2016-03-16 19:46:34

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.

6
répondu Roland 2013-08-11 09:09:38

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.

5
répondu osomanden 2013-12-23 08:03:20

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"
4
répondu Michael Mikowski 2013-04-21 18:48:39

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

4
répondu Tanah 2016-03-01 10:01:58

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;

}

3
répondu Alex Peta 2011-12-20 15:19:31

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]+$/)
}
3
répondu hackerdiehack 2012-01-23 09:01:46

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.

3
répondu pocesar 2013-02-13 18:51:39

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.

3
répondu towry 2013-03-11 12:36:01

POUR INFORMATION, Si vous utilisez jQuery vous avez

$.isNumeric() 

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

3
répondu Angelos 2013-12-04 11:18:25

jQuery utilise ceci:

function isNumber(obj) {
  return !isNaN( parseFloat( obj ) ) && isFinite( obj );
}
2
répondu Bounasser Abdelwahab 2013-07-22 18:06:46

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.

0
répondu Jonathon 2013-07-25 05:37:38
function IsNumeric(num) {
    return ((num >=0 || num < 0)&& (parseInt(num)==num) );
}
0
répondu hosein 2013-10-03 20:07:25

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)\]/);
0
répondu Wil Moore III 2014-04-13 21:54:28

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.

0
répondu jemiloii 2014-12-05 21:45:35

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);
};
0
répondu Stephen Niedzielski 2015-08-25 22:52:20