J'espère qu'il y a quelque chose dans le même espace conceptuel que l'ancienne IsNumeric()
fonction VB6 ?
isNaN("")
, isNaN(" ")
, isNaN(false)
, etc. renvoie false
pour ces derniers , ce qui implique qu'ils sont des nombres.
J'espère qu'il y a quelque chose dans le même espace conceptuel que l'ancienne IsNumeric()
fonction VB6 ?
isNaN("")
, isNaN(" ")
, isNaN(false)
, etc. renvoie false
pour ces derniers , ce qui implique qu'ils sont des nombres.
Réponses:
Cela fonctionne indépendamment du fait que le contenu variable soit une chaîne ou un nombre.
isNaN(num) // returns true if the variable does NOT contain a valid number
isNaN(123) // false
isNaN('123') // false
isNaN('1e10000') // false (This translates to Infinity, which is a number)
isNaN('foo') // true
isNaN('10px') // true
Bien sûr, vous pouvez annuler cela si vous en avez besoin. Par exemple, pour implémenter l' IsNumeric
exemple que vous avez donné:
function isNumeric(num){
return !isNaN(num)
}
Fonctionne uniquement si la chaîne ne contient que des caractères numériques, sinon elle retourne NaN
.
+num // returns the numeric value of the string, or NaN
// if the string isn't purely numeric characters
+'12' // 12
+'12.' // 12
+'12..' // NaN
+'.12' // 0.12
+'..12' // NaN
+'foo' // NaN
+'12px' // NaN
Utile pour convertir '12px' en 12, par exemple:
parseInt(num) // extracts a numeric value from the
// start of the string, or NaN.
parseInt('12') // 12
parseInt('aaa') // NaN
parseInt('12px') // 12
parseInt('foo2') // NaN These last two may be different
parseInt('12a5') // 12 from what you expected to see.
Gardez à l' esprit que, contrairement à +num
, parseInt
(comme son nom l' indique) vous permet de convertir un flotteur en un entier en coupant tout ce qui suit le point décimal (si vous souhaitez utiliser en parseInt()
raison de ce comportement, vous êtes probablement mieux d'utiliser une autre méthode à la place ) :
+'12.345' // 12.345
parseInt(12.345) // 12
parseInt('12.345') // 12
Les chaînes vides peuvent être un peu contre-intuitives. +num
convertit les chaînes vides ou les chaînes avec des espaces à zéro et isNaN()
suppose la même chose:
+'' // 0
+' ' // 0
isNaN('') // false
isNaN(' ') // false
Mais parseInt()
n'est pas d'accord:
parseInt('') // NaN
parseInt(' ') // NaN
isNaN
"Pour vérifier si une variable n'est pas un nombre". "not a number" n'est pas la même chose que "IEEE-794 NaN", qui est ce qui isNaN
teste. En particulier, cette utilisation échoue lors du test des booléens et des chaînes vides, au moins. Voir developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .
var n = 'a'; if (+n === +n) { // is number }
il est ~ 3994% plus rapide que isNaN dans la dernière version de Chrome. Voir le test de performance ici: jsperf.com/isnan-vs-typeof/5
isNaN(1 + false + parseInt("1.do you trust your users?"))
Et vous pouvez utiliser la méthode RegExp:
var num = "987238";
if(num.match(/^-{0,1}\d+$/)){
//valid integer (positive or negative)
}else if(num.match(/^\d+\.\d+$/)){
//valid float
}else{
//not valid number
}
Si vous essayez simplement de vérifier si une chaîne est un nombre entier (pas de décimales), l'expression régulière est une bonne façon de procéder. D'autres méthodes telles que isNaN
trop compliquées pour quelque chose d'aussi simple.
function isNumeric(value) {
return /^-{0,1}\d+$/.test(value);
}
console.log(isNumeric('abcd')); // false
console.log(isNumeric('123a')); // false
console.log(isNumeric('1')); // true
console.log(isNumeric('1234567890')); // true
console.log(isNumeric('-23')); // true
console.log(isNumeric(1234)); // true
console.log(isNumeric('123.4')); // false
console.log(isNumeric('')); // false
console.log(isNumeric(undefined)); // false
console.log(isNumeric(null)); // false
Pour autoriser uniquement les nombres entiers positifs , utilisez ceci:
function isNumeric(value) {
return /^\d+$/.test(value);
}
console.log(isNumeric('123')); // true
console.log(isNumeric('-23')); // false
/^-?\d+$/
droite?
Si vous voulez vraiment vous assurer qu'une chaîne ne contient qu'un nombre, un nombre (entier ou à virgule flottante), et exactement un numéro, vous ne pouvez pas utiliser parseInt()
/ parseFloat()
, Number()
ou !isNaN()
par eux - mêmes. Notez que !isNaN()
revient réellement true
quand Number()
retournerait un nombre, et false
quand il retourneraitNaN
, donc je l'exclurai du reste de la discussion.
Le problème avec parseFloat()
est qu'il retournera un nombre si la chaîne contient n'importe quel nombre, même si la chaîne ne contient pas seulement et exactement un nombre:
parseFloat("2016-12-31") // returns 2016
parseFloat("1-1") // return 1
parseFloat("1.2.3") // returns 1.2
Le problème Number()
est qu'il retournera un nombre dans les cas où la valeur transmise n'est pas du tout un nombre!
Number("") // returns 0
Number(" ") // returns 0
Number(" \u00A0 \t\n\r") // returns 0
Le problème avec le roulement de votre propre expression régulière est que, sauf si vous créez l'expression exacte exacte pour correspondre à un nombre à virgule flottante car Javascript le reconnaît, vous allez manquer des cas ou reconnaître des cas où vous ne devriez pas. Et même si vous pouvez rouler votre propre regex, pourquoi? Il existe des moyens intégrés plus simples de le faire.
Cependant, il s'avère que Number()
(et isNaN()
) fait la bonne chose pour chaque cas où parseFloat()
renvoie un nombre alors qu'il ne devrait pas, et vice versa. Donc, pour savoir si une chaîne est vraiment exactement et seulement un nombre, appelez les deux fonctions et voyez si elles retournent toutes les deux vrai:
function isNumber(str) {
if (typeof str != "string") return false // we only process strings!
// could also coerce to string: str = ""+str
return !isNaN(str) && !isNaN(parseFloat(str))
}
' 1'
, '2 '
Et ' 3 '
tout retour vrai.
isNumber
fonction ne s'occupent pas des interfaces utilisateur. De plus, une bonne entrée de nombre ne permettra pas de commencer par les espaces.
La réponse acceptée pour cette question a quelques défauts (comme l'ont souligné quelques autres utilisateurs). C'est l'un des moyens les plus simples et éprouvés de l'aborder en javascript:
function isNumeric(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
Voici quelques bons cas de test:
console.log(isNumeric(12345678912345678912)); // true
console.log(isNumeric('2 ')); // true
console.log(isNumeric('-32.2 ')); // true
console.log(isNumeric(-32.2)); // true
console.log(isNumeric(undefined)); // false
// the accepted answer fails at these tests:
console.log(isNumeric('')); // false
console.log(isNumeric(null)); // false
console.log(isNumeric([])); // false
Essayez la fonction isNan :
La fonction isNaN () détermine si une valeur est un nombre illégal (Not-a-Number).
Cette fonction renvoie true si la valeur est égale à NaN. Sinon, elle renvoie faux.
Cette fonction est différente de la méthode Number.isNaN () spécifique à Number .
La fonction globale isNaN () convertit la valeur testée en nombre, puis la teste.
Number.isNan () ne convertit pas les valeurs en Number et ne renverra pas true pour toute valeur qui n'est pas du type Number ...
isNaN()
renvoie false
pour TOUTE chaîne contenant uniquement des caractères d'espacement, y compris des éléments comme '\ u00A0'.
Vieille question, mais il manque plusieurs points dans les réponses données.
Notation scientifique.
!isNaN('1e+30')
est true
, cependant, dans la plupart des cas, lorsque les gens demandent des chiffres, ils ne veulent pas faire correspondre des choses comme1e+30
.
Les grands nombres flottants peuvent se comporter bizarrement
Observez (en utilisant Node.js):
> var s = Array(16 + 1).join('9')
undefined
> s.length
16
> s
'9999999999999999'
> !isNaN(s)
true
> Number(s)
10000000000000000
> String(Number(s)) === s
false
>
D'autre part:
> var s = Array(16 + 1).join('1')
undefined
> String(Number(s)) === s
true
> var s = Array(15 + 1).join('9')
undefined
> String(Number(s)) === s
true
>
Donc, si l'on attend String(Number(s)) === s
, mieux vaut limiter vos chaînes à 15 chiffres au maximum (après avoir omis les zéros de tête).
Infini
> typeof Infinity
'number'
> !isNaN('Infinity')
true
> isFinite('Infinity')
false
>
Compte tenu de tout cela, vérifier que la chaîne donnée est un nombre satisfaisant à toutes les conditions suivantes:
Number
et retour àString
n'est pas une tâche si facile. Voici une version simple:
function isNonScientificNumberString(o) {
if (!o || typeof o !== 'string') {
// Should not be given anything but strings.
return false;
}
return o.length <= 15 && o.indexOf('e+') < 0 && o.indexOf('E+') < 0 && !isNaN(o) && isFinite(o);
}
Cependant, même celui-ci est loin d'être terminé. Les zéros non significatifs ne sont pas traités ici, mais ils vissent le test de longueur.
J'ai testé et la solution de Michael est la meilleure. Votez pour sa réponse ci-dessus (recherchez sur cette page "Si vous voulez vraiment vous assurer qu'une chaîne" pour la trouver). En substance, sa réponse est la suivante:
function isNumeric(num){
num = "" + num; //coerce num to be a string
return !isNaN(num) && !isNaN(parseFloat(num));
}
Cela fonctionne pour chaque cas de test, que j'ai documenté ici: https://jsfiddle.net/wggehvp9/5/
La plupart des autres solutions échouent pour ces cas limites: '', null, "", true et []. En théorie, vous pouvez les utiliser avec une gestion des erreurs appropriée, par exemple:
return !isNaN(num);
ou
return (+num === +num);
avec une gestion spéciale pour / \ s /, null, "", true, false, [] (et autres?)
Vous pouvez utiliser le résultat de Number lorsque vous passez un argument à son constructeur.
Si l'argument (une chaîne) ne peut pas être converti en nombre, il renvoie NaN, vous pouvez donc déterminer si la chaîne fournie était un nombre valide ou non.
Remarques: Notez lorsque vous passez une chaîne vide ou '\t\t'
et '\n\t'
que Number renvoie 0; La réussite de true renvoie 1 et false renvoie 0.
Number('34.00') // 34
Number('-34') // -34
Number('123e5') // 12300000
Number('123e-5') // 0.00123
Number('999999999999') // 999999999999
Number('9999999999999999') // 10000000000000000 (integer accuracy up to 15 digit)
Number('0xFF') // 255
Number('Infinity') // Infinity
Number('34px') // NaN
Number('xyz') // NaN
Number('true') // NaN
Number('false') // NaN
// cavets
Number(' ') // 0
Number('\t\t') // 0
Number('\n\t') // 0
Number
constructeur est exactement le même que +x
.
Number()
gère également les nombres flottants, comme Number.parseFloat()
nonNumber.parseInt()
Peut-être qu'une ou deux personnes rencontrent cette question qui ont besoin d'un contrôle beaucoup plus strict que d'habitude (comme je l'ai fait). Dans ce cas, cela pourrait être utile:
if(str === String(Number(str))) {
// it's a "perfectly formatted" number
}
Il faut se méfier! Cela rejette les chaînes comme .1
, 40.000
, 080
, 00.1
. C'est très difficile - la chaîne doit correspondre à la " forme parfaite la plus minimale " du nombre pour que ce test réussisse.
Il utilise le constructeur String
et Number
pour convertir la chaîne en un nombre et inversement et vérifie ainsi si la "forme minimale parfaite" du moteur JavaScript (celle à laquelle il a été converti avec le Number
constructeur initial ) correspond à la chaîne d'origine.
(str === String(Math.round(Number(str))))
.
"Infinity"
, "-Infinity"
et "NaN"
passer ce test. Cependant, cela peut être résolu à l'aide d'un Number.isFinite
test supplémentaire .
str === ("" + +str)
. Il vérifie essentiellement si la chaîne est le résultat de la chaîne d'un numéro JS. Sachant cela, nous pouvons également voir un problème: le test réussit 0.000001
mais échoue 0.0000001
, c'est-à-dire quand 1e-7
passe à la place. De même pour les très gros nombres.
parseInt (), mais sachez que cette fonction est un peu différente en ce sens qu'elle retourne par exemple 100 pour parseInt ("100px").
parseInt(09)
.
paraseInt(09, 10)
, 10
argument. parseInt('09')
est maintenant égal à 9.
Citation:
isNaN (num) // renvoie vrai si la variable ne contient PAS de nombre valide
n'est pas entièrement vrai si vous devez vérifier les espaces de début / fin - par exemple lorsqu'une certaine quantité de chiffres est requise, et que vous devez obtenir, par exemple, «1111» et non «111» ou «111» pour peut-être un code PIN contribution.
Mieux utiliser:
var num = /^\d+$/.test(num)
'-1'
, '0.1'
et '1e10'
toutes renvoient false. De plus, les valeurs supérieures à l'infini positif ou inférieures à l'infini négatif renvoient true, alors qu'elles devraient probablement renvoyer false.
Pourquoi l'implémentation de jQuery n'est-elle pas assez bonne?
function isNumeric(a) {
var b = a && a.toString();
return !$.isArray(a) && b - parseFloat(b) + 1 >= 0;
};
Michael a suggéré quelque chose comme ça (bien que j'ai volé la version modifiée de "user1691651 - John" ici):
function isNumeric(num){
num = "" + num; //coerce num to be a string
return !isNaN(num) && !isNaN(parseFloat(num));
}
Ce qui suit est une solution avec probablement de mauvaises performances, mais des résultats solides. C'est un engin fabriqué à partir de l'implémentation de jQuery 1.12.4 et de la réponse de Michael, avec une vérification supplémentaire pour les espaces de début / fin (car la version de Michael renvoie vrai pour les chiffres avec des espaces de début / fin):
function isNumeric(a) {
var str = a + "";
var b = a && a.toString();
return !$.isArray(a) && b - parseFloat(b) + 1 >= 0 &&
!/^\s+|\s+$/g.test(str) &&
!isNaN(str) && !isNaN(parseFloat(str));
};
Cette dernière version a cependant deux nouvelles variables. On pourrait contourner l'un d'entre eux en faisant:
function isNumeric(a) {
if ($.isArray(a)) return false;
var b = a && a.toString();
a = a + "";
return b - parseFloat(b) + 1 >= 0 &&
!/^\s+|\s+$/g.test(a) &&
!isNaN(a) && !isNaN(parseFloat(a));
};
Je n'ai pas testé beaucoup de ceux-ci, autrement que de tester manuellement les quelques cas d'utilisation que je vais rencontrer avec ma situation actuelle, qui est tout à fait standard. Il s'agit d'une situation "debout sur les épaules des géants".
Eh bien, j'utilise celui que j'ai fait ...
Cela fonctionne jusqu'à présent:
function checkNumber(value) {
if ( value % 1 == 0 )
return true;
else
return false;
}
Si vous rencontrez un problème, dites-le moi, s'il vous plaît.
return !isNaN(parseInt(value, 10));
Si quelqu'un arrive aussi loin, j'ai passé du temps à pirater cela en essayant de patcher moment.js ( https://github.com/moment/moment ). Voici quelque chose que j'en ai retiré:
function isNumeric(val) {
var _val = +val;
return (val !== val + 1) //infinity check
&& (_val === +val) //Cute coercion check
&& (typeof val !== 'object') //Array/object check
}
Gère les cas suivants:
Vrai! :
isNumeric("1"))
isNumeric(1e10))
isNumeric(1E10))
isNumeric(+"6e4"))
isNumeric("1.2222"))
isNumeric("-1.2222"))
isNumeric("-1.222200000000000000"))
isNumeric("1.222200000000000000"))
isNumeric(1))
isNumeric(0))
isNumeric(-0))
isNumeric(1010010293029))
isNumeric(1.100393830000))
isNumeric(Math.LN2))
isNumeric(Math.PI))
isNumeric(5e10))
Faux! :
isNumeric(NaN))
isNumeric(Infinity))
isNumeric(-Infinity))
isNumeric())
isNumeric(undefined))
isNumeric('[1,2,3]'))
isNumeric({a:1,b:2}))
isNumeric(null))
isNumeric([1]))
isNumeric(new Date()))
Ironiquement, celui avec lequel je lutte le plus:
isNumeric(new Number(1)) => false
Toutes les suggestions sont les bienvenues. :]
isNumeric(' ')
et isNumeric('')
?
&& (val.replace(/\s/g,'') !== '') //Empty && (val.slice(-1) !== '.') //Decimal without Number
afin d'aborder le problème mentionné ci-dessus et celui que j'avais moi-même.
Utilisation de JavaScript simple:
Number.isNaN(Number('1')); // false
Number.isNaN(Number('asdf')); // true
Utilisation de Lodash:
_.isNaN(_.toNumber('1')); // false
_.isNaN(_.toNumber('asdf')); // true
function isNumberCandidate(s) {
const str = (''+ s).trim();
if (str.length === 0) return false;
return !isNaN(+str);
}
console.log(isNumberCandidate('1')); // true
console.log(isNumberCandidate('a')); // false
console.log(isNumberCandidate('000')); // true
console.log(isNumberCandidate('1a')); // false
console.log(isNumberCandidate('1e')); // false
console.log(isNumberCandidate('1e-1')); // true
console.log(isNumberCandidate('123.3')); // true
console.log(isNumberCandidate('')); // false
console.log(isNumberCandidate(' ')); // false
console.log(isNumberCandidate(1)); // true
console.log(isNumberCandidate(0)); // true
console.log(isNumberCandidate(NaN)); // false
console.log(isNumberCandidate(undefined)); // false
console.log(isNumberCandidate(null)); // false
console.log(isNumberCandidate(-1)); // true
console.log(isNumberCandidate('-1')); // true
console.log(isNumberCandidate('-1.2')); // true
console.log(isNumberCandidate(0.0000001)); // true
console.log(isNumberCandidate('0.0000001')); // true
console.log(isNumberCandidate(Infinity)); // true
console.log(isNumberCandidate(-Infinity)); // true
console.log(isNumberCandidate('Infinity')); // true
if (isNumberCandidate(s)) {
// use +s as a number
+s ...
}
Peut-être que cela a été refait trop souvent, mais j'ai aussi combattu avec celle-ci aujourd'hui et je voulais poster ma réponse, car je n'ai vu aucune autre réponse qui le fasse aussi simplement ou complètement:
var isNumeric = function(num){
return (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);
}
const isNumeric = (num) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);
const isNumeric = (num: any) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num as number);
Cela semble assez simple et couvre toutes les bases que j'ai vues sur les nombreux autres postes et que j'ai imaginé moi-même:
// Positive Cases
console.log(0, isNumeric(0) === true);
console.log(1, isNumeric(1) === true);
console.log(1234567890, isNumeric(1234567890) === true);
console.log('1234567890', isNumeric('1234567890') === true);
console.log('0', isNumeric('0') === true);
console.log('1', isNumeric('1') === true);
console.log('1.1', isNumeric('1.1') === true);
console.log('-1', isNumeric('-1') === true);
console.log('-1.2354', isNumeric('-1.2354') === true);
console.log('-1234567890', isNumeric('-1234567890') === true);
console.log(-1, isNumeric(-1) === true);
console.log(-32.1, isNumeric(-32.1) === true);
console.log('0x1', isNumeric('0x1') === true); // Valid number in hex
// Negative Cases
console.log(true, isNumeric(true) === false);
console.log(false, isNumeric(false) === false);
console.log('1..1', isNumeric('1..1') === false);
console.log('1,1', isNumeric('1,1') === false);
console.log('-32.1.12', isNumeric('-32.1.12') === false);
console.log('[blank]', isNumeric('') === false);
console.log('[spaces]', isNumeric(' ') === false);
console.log('null', isNumeric(null) === false);
console.log('undefined', isNumeric(undefined) === false);
console.log([], isNumeric([]) === false);
console.log('NaN', isNumeric(NaN) === false);
Vous pouvez également essayer le vôtre isNumeric
fonction et juste passer dans ces cas d'utilisation et rechercher «vrai» pour chacun d'eux.
Ou, pour voir les valeurs que chacun renvoie:
Souvent, un «nombre valide» signifie un nombre Javascript excluant NaN et Infinity, c'est-à-dire un «nombre fini».
Pour vérifier la validité numérique d'une valeur (à partir d'une source externe par exemple), vous pouvez définir dans le style ESlint Airbnb:
/**
* Returns true if 'candidate' is a finite number or a string referring (not just 'including') a finite number
* To keep in mind:
* Number(true) = 1
* Number('') = 0
* Number(" 10 ") = 10
* !isNaN(true) = true
* parseFloat('10 a') = 10
*
* @param {?} candidate
* @return {boolean}
*/
function isReferringFiniteNumber(candidate) {
if (typeof (candidate) === 'number') return Number.isFinite(candidate);
if (typeof (candidate) === 'string') {
return (candidate.trim() !== '') && Number.isFinite(Number(candidate));
}
return false;
}
et utilisez-le de cette façon:
if (isReferringFiniteNumber(theirValue)) {
myCheckedValue = Number(theirValue);
} else {
console.warn('The provided value doesn\'t refer to a finite number');
}
Épargnez-vous le casse-tête d'essayer de trouver une solution «intégrée».
Il n'y a pas de bonne réponse, et la réponse extrêmement votée dans ce fil est fausse.
npm install is-number
En JavaScript, il n'est pas toujours aussi simple qu'il devrait l'être de vérifier de manière fiable si une valeur est un nombre. Il est courant que les développeurs utilisent +, - ou Number () pour convertir une valeur de chaîne en un nombre (par exemple, lorsque les valeurs sont renvoyées par l'entrée utilisateur, les correspondances d'expression régulière, les analyseurs, etc.). Mais il existe de nombreux cas de bord non intuitifs qui donnent des résultats inattendus:
console.log(+[]); //=> 0
console.log(+''); //=> 0
console.log(+' '); //=> 0
console.log(typeof NaN); //=> 'number'
J'ai récemment écrit un article sur les moyens de garantir qu'une variable est un nombre valide: https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md L'article explique comment garantir la virgule flottante ou l'entier, si c'est le cas important ( +x
vs~~x
).
L'article suppose que la variable est un string
ou un number
pour commencer et trim
est disponible / polyfilled. Il ne serait pas difficile de l'étendre pour gérer d'autres types également. Voici la viande de celui-ci:
// Check for a valid float
if (x == null
|| ("" + x).trim() === ""
|| isNaN(+x)) {
return false; // not a float
}
// Check for a valid integer
if (x == null
|| ("" + x).trim() === ""
|| ~~x !== +x) {
return false; // not an integer
}
Ma tentative d'un peu déroutant, peut-être pas la meilleure solution
function isInt(a){
return a === ""+~~a
}
console.log(isInt('abcd')); // false
console.log(isInt('123a')); // false
console.log(isInt('1')); // true
console.log(isInt('0')); // true
console.log(isInt('-0')); // false
console.log(isInt('01')); // false
console.log(isInt('10')); // true
console.log(isInt('-1234567890')); // true
console.log(isInt(1234)); // false
console.log(isInt('123.4')); // false
console.log(isInt('')); // false
// other types then string returns false
console.log(isInt(5)); // false
console.log(isInt(undefined)); // false
console.log(isInt(null)); // false
console.log(isInt('0x1')); // false
console.log(isInt(Infinity)); // false
042
) et hexadécimal ( 0x45f
)
Dans mon application, nous n'autorisons que az AZ et 0-9 caractères. J'ai trouvé la réponse ci-dessus en utilisant " chaîne % 1 === 0" a fonctionné à moins que la chaîne ne commence par 0xnn (comme 0x10) et qu'elle la renvoie sous forme numérique lorsque nous ne le voulons pas. Le simple piège suivant dans ma vérification numérique semble faire l'affaire dans nos cas spécifiques.
function isStringNumeric(str_input){
//concat a temporary 1 during the modulus to keep a beginning hex switch combination from messing us up
//very simple and as long as special characters (non a-z A-Z 0-9) are trapped it is fine
return '1'.concat(str_input) % 1 === 0;}
Avertissement : Cela pourrait exploiter un bogue de longue date dans Javascript et Actionscript [Number ("1" + the_string)% 1 === 0)], je ne peux pas parler pour cela, mais c'est exactement ce dont nous avions besoin.
% 1
opération numérique sur eux), et cela interprétera la chaîne comme un littéral hexadécimal ou flottant.
Ma solution:
// returns true for positive ints;
// no scientific notation, hexadecimals or floating point dots
var isPositiveInt = function(str) {
var result = true, chr;
for (var i = 0, n = str.length; i < n; i++) {
chr = str.charAt(i);
if ((chr < "0" || chr > "9") && chr != ",") { //not digit or thousands separator
result = false;
break;
};
if (i == 0 && (chr == "0" || chr == ",")) { //should not start with 0 or ,
result = false;
break;
};
};
return result;
};
Vous pouvez ajouter des conditions supplémentaires à l'intérieur de la boucle, pour répondre à vos besoins particuliers.
Vous pouvez utiliser des types, comme avec la bibliothèque de flux , pour obtenir une vérification statique de l'heure de compilation. Bien sûr, pas terriblement utile pour la saisie des utilisateurs.
// @flow
function acceptsNumber(value: number) {
// ...
}
acceptsNumber(42); // Works!
acceptsNumber(3.14); // Works!
acceptsNumber(NaN); // Works!
acceptsNumber(Infinity); // Works!
acceptsNumber("foo"); // Error!
Voici une ligne pour vérifier s'il sNum
s'agit d'une valeur numérique valide; il a été testé pour une grande variété d'entrées:
!isNaN(+s.replace(/\s|\$/g, '')); // returns True if numeric value
J'utilise ce qui suit:
const isNumber = s => !isNaN(+s)
1..1
, 1,1
, -32.1.12
et ne parvient plus important undefined
et NaN
. Si vous avez réussi undefined
ou NaN
que cela vous retournerait un faux positif disant que c'était un nombre.