Vérifier si la variable est un nombre ou une chaîne en JavaScript
Est-ce que quelqu'un sait comment puis-je vérifier si une variable est un nombre ou une chaîne en JavaScript?
Si vous utilisez 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, tel que var foo = new String("foo"), gardez à l'esprit que typeof peut renvoyer object pour foo.
Une méthode plus fiable pour vérifier le type serait peut-être d'utiliser la méthode décrite dans underscore.js (la source annotée peut être trouvée ici ),
var toString = Object.prototype.toString;
_.isString = function (obj) {
return toString.call(obj) == '[object String]';
}
Cela retourne une valeur booléenne true pour les éléments suivants:
_.isString("Jonathan"); // true
_.isString(new String("Jonathan")); // true
La meilleure façon de faire consiste à utiliser le transtypage de type isNaN +:
Méthode all-in mise à jour:
function isNumber(n) { return !isNaN(parseFloat(n)) && !isNaN(n - 0) }
Le même en utilisant 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 rechercher une méthode sur la chaîne, c’est-à-dire:
if (x.substring) {
// do string thing
} else{
// do other thing
}
ou si vous voulez faire quelque chose avec le contrôle de numéro pour une propriété de numéro,
if (x.toFixed) {
// do number thing
} else {
// do other thing
}
C'est un peu comme "taper du canard", c'est à vous de choisir le sens le plus logique. Je n'ai pas assez de karma pour commenter, mais le typeof échoue pour les chaînes et les nombres en boîte, c'est-à-dire:
alert(typeof new String('Hello World'));
alert(typeof new Number(5));
va alerter "objet".
Vérifiez si la valeur est un littéral de chaîne ou un objet String:
function isString(o) {
return typeof o == "string" || (typeof o == "object" && o.constructor === String);
}
Test de l'unité:
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");
Rechercher un numéro est similaire:
function isNumber(o) {
return typeof o == "number" || (typeof o == "object" && o.constructor === Number);
}
Vous recherchez isNaN():
console.log(!isNaN(123));
console.log(!isNaN(-1.23));
console.log(!isNaN(5-2));
console.log(!isNaN(0));
console.log(!isNaN("0"));
console.log(!isNaN("2"));
console.log(!isNaN("Hello"));
console.log(!isNaN("2005/12/12"));Voir JavaScript isNaN () Function at MDN.
Depuis ES2015, la méthode correcte pour vérifier si une variable .__ détient un nombre valide est la suivante:
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
Essaye ça,
<script>
var regInteger = /^\d+$/;
function isInteger( str ) {
return regInteger.test( str );
}
if(isInteger("1a11")) {
console.log( 'Integer' );
} else {
console.log( 'Non Integer' );
}
</script>
//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 adaptez-le pour retourner un type inconnu:
function realTypeOf(obj) {
return Object.prototype.toString.call(obj).slice(8, -1);
}
//usage
realTypeOf(999); // 'Number'
Mise à jour du 12 mai 2012:Exemple complet sur Javascript: Un meilleur type de type .
Meilleure façon de faire ceci:
function isNumber(num) {
return (typeof num == 'string' || typeof num == 'number') && !isNaN(num - 0) && num !== '';
};
Cela satisfait les cas de test 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 contraindre l'entrée à un nombre ou à une chaîne en ajoutant zéro ou la chaîne nulle, puis d'effectuer une comparaison d'égalité typée.
function is_number(x) { return x === x+0; }
function is_string(x) { return x === x+""; }
Pour certaines raisons insondables, x===x+0 semble mieux fonctionner que x===+x.
Existe-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 "identité" propre à chaque type, applicable à n’importe quelle valeur et produisant 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;}
Ceci est fondamentalement la version de underscore, et dans sa version actuelle est environ quatre fois plus rapide que isNaN(), mais les commentaires dans la source de soulignement mentionnent que "NaN est le seul nombre qui ne s'égalise pas" et ajoute un contrôle pour _. isNumber. Pourquoi? Quels autres objets ne seraient pas égaux? De plus, le trait de soulignement utilise x !== +x--, mais quelle différence le + peut-il faire ici?
Alors pour le paranoïaque:
function is_undefined(x) { return x===[][0]; }
Pouvez-vous simplement le diviser par 1?
Je suppose que le problème serait une entrée de chaîne du type: "123ABG"
var Check = "123ABG"
if(Check == Check / 1)
{
alert("This IS a number \n")
}
else
{
alert("This is NOT a number \n")
}
Juste une façon je l'ai fait récemment.
euh, pourquoi pas juste:
function IsString(obj) {
return obj !== undefined && obj != null && obj.toLowerCase !== undefined;
}
Après un examen approfondi plusieurs mois plus tard, cela garantit uniquement que obj est un objet pour lequel la méthode ou le nom de propriété toLowerCase est défini. J'ai honte de ma réponse. S'il vous plaît voir typeof un voté par le haut.
Je pense que convertir la var en chaîne diminue les performances, du moins ce test effectué dans les derniers navigateurs le montre bien.
Donc, si vous vous souciez de la performance, j'aimerais utiliser ceci:
typeof str === "string" || str instanceof String
pour vérifier si la variable est une chaîne (même si vous utilisez var str = new String("foo"), str instanceof String renverrait true).
Pour ce qui est de vérifier s’il s’agit d’un numéro, je choisirais le natif: isNaN; une fonction.
ou utilisez simplement l'invert de isNaN
si (! isNaN (data)) faire quelque chose avec le nombre sinon c'est une ficelle
et oui - en utilisant jQuery - $ .isNumeric () est plus amusant pour l'argent.
Cette solution résout bon nombre des problèmes soulevés ici!
C'est de loin la méthode la plus fiable que j'ai utilisée de loin. Je n'ai pas inventé cela et je ne me souviens plus où je l'ai 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 de correction
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"
typeof 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 un nom de variable de votre choix
La réponse de @ BitOfUniverse est bonne et je propose un nouveau moyen:
function isNum(n) {
return !isNaN(n/0);
}
isNum('') // false
isNum(2) // true
isNum('2k') // false
isNum('2') //true
Je sais que 0 ne peut pas être un dividende, mais ici la fonction fonctionne parfaitement.
le meilleur moyen que j'ai trouvé qui pense aussi aux nombres positifs et négatifs est de: O'Reilly Javascript et DHTML Cookbook :
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;
}
puisqu'une chaîne telle que '1234' avec typeof affichera 'chaîne', et que l'inverse ne peut jamais se produire (typeof 123 sera toujours un nombre), le mieux est d'utiliser une expression rationnelle simple /^\-?\d+$/.test(var). /^[\-\+]?[\d]+\.?(\d+)?$/ L’aspect important de .test est qu’il NE LANCE PAS d’exception si la variable var n’est pas une chaîne, la valeur peut être quelconque.
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, alors seul typeof fera l'affaire.
Jsut un FYI, si vous utilisez jQuery vous avez
$.isNumeric()
pour gérer cela. Plus de détails sur http://api.jquery.com/jQuery.isNumeric/
Euh? Il suffit d'utiliser des expressions régulières! :)
function isInteger(val) {
return val.match(/^[0-9]$/)
}
function isFloat(val) {
return val.match(/^[0-9]*/\.[0-9]+$/)
}
jQuery utilise ceci:
function isNumber(obj) {
return !isNaN( parseFloat( obj ) ) && isFinite( obj );
}
L'opération XOR peut être utilisée pour détecter un nombre ou une chaîne. nombre ^ 0 donnera toujours le nombre en sortie et chaîne ^ 0 donnera 0 en sortie.
Example:
1) 2 ^ 0 = 2
2) '2' ^ 0 = 2
3) 'Str' ^ 0 = 0
function IsNumeric(num) {
return ((num >=0 || num < 0)&& (parseInt(num)==num) );
}
Que penses-tu de celui-ci?
const numberOrString='10'
const isNumber = !isNaN(numberOrString*1)
Pour détecter les nombres, le passage suivant de JavaScript: The Good Parts de Douglas Crockford est pertinent:
La fonction isFinite est le meilleur moyen de déterminer si une valeur peut être utilisée sous forme de nombre car elle rejette NaN et Infinity. Malheureusement, isFinite essaiera de convertir son opérande en nombre. Ce n'est donc pas un bon test si une valeur n'est pas réellement un nombre. Vous voudrez peut-être définir votre propre fonction isNumber:
var isNumber = function isNumber(value) { return typeof value === 'number' &&
isFinite(value);
};
Vous pouvez simplement utiliser:
!isNaN(+variable);
Très tard à la fête; Cependant, ce qui suit a toujours bien fonctionné pour moi lorsque je souhaite vérifier si une entrée est une chaîne ou un nombre d'un coup.
return !!Object.prototype.toString.call(input).match(/\[object (String|Number)\]/);
Simplement utiliser
myVar.constructor == String
ou
myVar.constructor == Number
si vous souhaitez gérer des chaînes définies comme des objets ou des littéraux et que vous enregistrez, vous ne souhaitez pas utiliser de fonction d'assistance.
Créé un jsperf sur la vérification si une variable est un nombre. Plutôt interessant! typeof a effectivement une utilisation performante. En utilisant typeof pour autre chose que des nombres, la vitesse est généralement 1/3 de celle d'un variable.constructor puisque la majorité des types de données en javascript sont des objets; les chiffres ne sont pas!
http://jsperf.com/jemiloii-fastest-method-to-check-if-type-is-a-number
typeof variable === 'number' | le plus rapide | si vous voulez un nombre, tel que 5, et non '5'typeof parseFloat(variable) === 'number' | le plus rapide | si vous voulez un nombre, tel que 5 et '5'
isNaN() est plus lent, mais pas beaucoup plus lent. J'avais de grands espoirs pour parseInt et parseFloat, mais ils étaient horriblement plus lents.