Vérifiez si le caractère est un nombre?

J'ai besoin de vérifier si justPrices[i].substr(commapos+2,1) .

La chaîne est quelque chose comme: "blabla, 120"

Dans ce cas, il vérifierait si «0» est un nombre. Comment cela peut-il être fait?

Vous pouvez utiliser des opérateurs de comparaison pour voir s'il se trouve dans la plage de caractères numériques:

var c = justPrices[i].substr(commapos+2,1);
if (c >= '0' && c <= '9') {
    // it is a number
} else {
    // it isn't
}

vous pouvez utiliser parseIntet vérifier avecisNaN

ou si vous voulez travailler directement sur votre chaîne, vous pouvez utiliser une expression régulière comme ceci:

function is_numeric(str){
    return /^\d+$/.test(str);
}

EDIT: La réponse mise à jour de Blender est la bonne réponse ici si vous ne vérifiez qu'un seul caractère (à savoir !isNaN(parseInt(c, 10)) ). Ma réponse ci-dessous est une bonne solution si vous souhaitez tester des chaînes entières.

Voici l' isNumericimplémentation de jQuery (en JavaScript pur), qui fonctionne avec des chaînes complètes :

function isNumeric(s) {
    return !isNaN(s - parseFloat(s));
}

Le commentaire de cette fonction se lit comme suit:

// parseFloat NaNs faux positifs à conversion numérique (null | true | false | "")
// ... mais interprète mal les chaînes de nombres de début, en particulier les littéraux hexadécimaux ("0x ...")
// la soustraction force l'infini à NaN

Je pense que nous pouvons être sûrs que ces gars ont passé pas mal de temps là-dessus!

Source commentée ici . Discussion super geek ici .

Je me demande pourquoi personne n'a publié une solution comme:

var charCodeZero = "0".charCodeAt(0);
var charCodeNine = "9".charCodeAt(0);

function isDigitCode(n) {
   return(n >= charCodeZero && n <= charCodeNine);
}

avec une invocation comme:

if (isDigitCode(justPrices[i].charCodeAt(commapos+2))) {
    ... // digit
} else {
    ... // not a digit
}

Vous pouvez utiliser ceci:

function isDigit(n) {
    return Boolean([true, true, true, true, true, true, true, true, true, true][n]);
}

Ici, je l'ai comparé à la méthode acceptée: http://jsperf.com/isdigittest/5 . Je ne m'attendais pas à grand-chose, donc j'ai été assez surpris quand j'ai découvert que la méthode acceptée était beaucoup plus lente.

Ce qui est intéressant, c'est que bien que la méthode acceptée soit une entrée correcte plus rapide (par exemple '5') et plus lente pour incorrect (par exemple 'a'), ma méthode est exactement opposée (rapide pour incorrect et plus lente pour correcte).

Pourtant, dans le pire des cas, ma méthode est 2 fois plus rapide que la solution acceptée pour une entrée correcte et plus de 5 fois plus rapide pour une entrée incorrecte.

Je pense que c'est très amusant de trouver des moyens de résoudre ce problème. En voici quelques-uns.
(Toutes les fonctions ci-dessous supposent que l' argument est un seul caractère. Remplacez parn[0] pour l'appliquer)

Méthode 1:

function isCharDigit(n){
  return !!n.trim() && n > -1;
}

Méthode 2:

function isCharDigit(n){
  return !!n.trim() && n*0==0;
}

Méthode 3:

function isCharDigit(n){
  return !!n.trim() && !!Number(n+.1); // "+.1' to make it work with "." and "0" Chars
}

Méthode 4:

var isCharDigit = (function(){
  var a = [1,1,1,1,1,1,1,1,1,1];
  return function(n){
    return !!a[n] // check if `a` Array has anything in index 'n'. Cast result to boolean
  }
})();

Méthode 5:

function isCharDigit(n){
  return !!n.trim() && !isNaN(+n);
}

Chaîne de test:

var str = ' 90ABcd#?:.+', char;
for( char of str ) 
  console.log( char, isCharDigit(char) );

Fonction simple

function isCharNumber(c){
    return c >= '0' && c <= '9';
}

Si vous testez des caractères uniques, alors:

var isDigit = (function() {
    var re = /^\d$/;
    return function(c) {
        return re.test(c);
    }
}());

retournera vrai ou faux selon que c est un chiffre ou non.

Je suggère une simple regex.

Si vous recherchez uniquement le dernier caractère de la chaîne:

/^.*?[0-9]$/.test("blabla,120");  // true
/^.*?[0-9]$/.test("blabla,120a"); // false
/^.*?[0-9]$/.test("120");         // true
/^.*?[0-9]$/.test(120);           // true
/^.*?[0-9]$/.test(undefined);     // false
/^.*?[0-9]$/.test(-1);            // true
/^.*?[0-9]$/.test("-1");          // true
/^.*?[0-9]$/.test(false);         // false
/^.*?[0-9]$/.test(true);          // false

Et l'expression régulière est encore plus simple si vous ne vérifiez qu'un seul caractère comme entrée:

var char = "0";
/^[0-9]$/.test(char);             // true

La solution la plus courte est:

const isCharDigit = n => n < 10;

Vous pouvez également les appliquer:

const isCharDigit = n => Boolean(++n);

const isCharDigit = n => '/' < n && n < ':';

const isCharDigit = n => !!++n;

si vous souhaitez vérifier plus d'un chatacter, vous pouvez utiliser les variantes suivantes

Expression régulière:

const isDigit = n => /\d+/.test(n);

Comparaison:

const isDigit = n => +n == n;

Vérifiez si ce n'est pas NaN

const isDigit = n => !isNaN(n);

var Is = {
    character: {
        number: (function() {
            // Only computed once
            var zero = "0".charCodeAt(0), nine = "9".charCodeAt(0);

            return function(c) {
                return (c = c.charCodeAt(0)) >= zero && c <= nine;
            }
        })()
    }
};

isNumber = function(obj, strict) {
    var strict = strict === true ? true : false;
    if (strict) {
        return !isNaN(obj) && obj instanceof Number ? true : false;
    } else {
        return !isNaN(obj - parseFloat(obj));
    }
}

sortie sans mode strict:

var num = 14;
var textnum = '14';
var text = 'yo';
var nan = NaN;

isNumber(num);
isNumber(textnum);
isNumber(text);
isNumber(nan);

true
true
false
false

sortie en mode strict:

var num = 14;
var textnum = '14';
var text = 'yo';
var nan = NaN;

isNumber(num, true);
isNumber(textnum, true);
isNumber(text, true);
isNumber(nan);

true
false
false
false

Essayer:

function is_numeric(str){
        try {
           return isFinite(str)
        }
        catch(err) {
            return false
        }
    }

Similaire à l'une des réponses ci-dessus, j'ai utilisé

 var sum = 0; //some value
 let num = parseInt(val); //or just Number.parseInt
 if(!isNaN(num)) {
     sum += num;
 }

Cet article de blog apporte un peu plus de lumière sur cette vérification si une chaîne est numérique en Javascript | Typographie et ES6

Une solution simple en tirant parti de la vérification de type dynamique du langage:

function isNumber (string) {
   //it has whitespace
   if(string.trim() === ''){
     return false
   }
   return string - 0 === string * 1
}

voir les cas de test ci-dessous

function isNumber (str) {
   if(str.trim() === ''){
     return false
   }
   return str - 0 === str * 1
}


console.log('-1' + ' → ' + isNumber ('-1'))    
console.log('-1.5' + ' → ' + isNumber ('-1.5')) 
console.log('0' + ' → ' + isNumber ('0'))    
console.log(', ,' + ' → ' + isNumber (', ,'))  
console.log('0.42' + ' → ' + isNumber ('0.42'))   
console.log('.42' + ' → ' + isNumber ('.42'))    
console.log('#abcdef' + ' → ' + isNumber ('#abcdef'))
console.log('1.2.3' + ' → ' + isNumber ('1.2.3')) 
console.log('' + ' → ' + isNumber (''))    
console.log('blah' + ' → ' + isNumber ('blah'))

Cela semble fonctionner:

Liaison statique:

String.isNumeric = function (value) {
    return !isNaN(String(value) * 1);
};

Reliure prototype:

String.prototype.isNumeric = function () {
    return !isNaN(this.valueOf() * 1);
};

Il vérifiera les caractères uniques, ainsi que les chaînes entières pour voir si elles sont numériques.

square = function(a) {
    if ((a * 0) == 0) {
        return a*a;
    } else {
        return "Enter a valid number.";
    }
}

La source

function is_numeric(mixed_var) {
    return (typeof(mixed_var) === 'number' || typeof(mixed_var) === 'string') &&
        mixed_var !== '' && !isNaN(mixed_var);
}

Code source

Vous pouvez essayer ceci (a fonctionné dans mon cas)

Si vous souhaitez tester si le premier caractère d'une chaîne est un entier:

if (parseInt(YOUR_STRING.slice(0, 1))) {
    alert("first char is int")
} else {
    alert("first char is not int")
}

Si vous voulez tester si le char est un int:

if (parseInt(YOUR_CHAR)) {
    alert("first char is int")
} else {
    alert("first char is not int")
}

Cette fonction fonctionne pour tous les cas de test que j'ai pu trouver. C'est aussi plus rapide que:

function isNumeric (n) {
  if (!isNaN(parseFloat(n)) && isFinite(n) && !hasLeading0s(n)) {
    return true;
  }
  var _n = +n;
  return _n === Infinity || _n === -Infinity;
}

var isIntegerTest = /^\d+$/;
var isDigitArray = [!0, !0, !0, !0, !0, !0, !0, !0, !0, !0];

function hasLeading0s(s) {
  return !(typeof s !== 'string' ||
    s.length < 2 ||
    s[0] !== '0' ||
    !isDigitArray[s[1]] ||
    isIntegerTest.test(s));
}
var isWhiteSpaceTest = /\s/;

function fIsNaN(n) {
  return !(n <= 0) && !(n > 0);
}

function isNumber(s) {
  var t = typeof s;
  if (t === 'number') {
    return (s <= 0) || (s > 0);
  } else if (t === 'string') {
    var n = +s;
    return !(fIsNaN(n) || hasLeading0s(s) || !(n !== 0 || !(s === '' || isWhiteSpaceTest.test(s))));
  } else if (t === 'object') {
    return !(!(s instanceof Number) || fIsNaN(+s));
  }
  return false;
}

function testRunner(IsNumeric) {
  var total = 0;
  var passed = 0;
  var failedTests = [];

  function test(value, result) {
    total++;
    if (IsNumeric(value) === result) {
      passed++;
    } else {
      failedTests.push({
        value: value,
        expected: result
      });
    }
  }
  // true
  test(0, true);
  test(1, true);
  test(-1, true);
  test(Infinity, true);
  test('Infinity', true);
  test(-Infinity, true);
  test('-Infinity', true);
  test(1.1, true);
  test(-0.12e-34, true);
  test(8e5, true);
  test('1', true);
  test('0', true);
  test('-1', true);
  test('1.1', true);
  test('11.112', true);
  test('.1', true);
  test('.12e34', true);
  test('-.12e34', true);
  test('.12e-34', true);
  test('-.12e-34', true);
  test('8e5', true);
  test('0x89f', true);
  test('00', true);
  test('01', true);
  test('10', true);
  test('0e1', true);
  test('0e01', true);
  test('.0', true);
  test('0.', true);
  test('.0e1', true);
  test('0.e1', true);
  test('0.e00', true);
  test('0xf', true);
  test('0Xf', true);
  test(Date.now(), true);
  test(new Number(0), true);
  test(new Number(1e3), true);
  test(new Number(0.1234), true);
  test(new Number(Infinity), true);
  test(new Number(-Infinity), true);
  // false
  test('', false);
  test(' ', false);
  test(false, false);
  test('false', false);
  test(true, false);
  test('true', false);
  test('99,999', false);
  test('#abcdef', false);
  test('1.2.3', false);
  test('blah', false);
  test('\t\t', false);
  test('\n\r', false);
  test('\r', false);
  test(NaN, false);
  test('NaN', false);
  test(null, false);
  test('null', false);
  test(new Date(), false);
  test({}, false);
  test([], false);
  test(new Int8Array(), false);
  test(new Uint8Array(), false);
  test(new Uint8ClampedArray(), false);
  test(new Int16Array(), false);
  test(new Uint16Array(), false);
  test(new Int32Array(), false);
  test(new Uint32Array(), false);
  test(new BigInt64Array(), false);
  test(new BigUint64Array(), false);
  test(new Float32Array(), false);
  test(new Float64Array(), false);
  test('.e0', false);
  test('.', false);
  test('00e1', false);
  test('01e1', false);
  test('00.0', false);
  test('01.05', false);
  test('00x0', false);
  test(new Number(NaN), false);
  test(new Number('abc'), false);
  console.log('Passed ' + passed + ' of ' + total + ' tests.');
  if (failedTests.length > 0) console.log({
    failedTests: failedTests
  });
}
testRunner(isNumber)

Autant que je sache, le moyen le plus simple est simplement de multiplier par 1:

var character = ... ; // your character
var isDigit = ! isNaN(character * 1);

La multiplication par un fait un nombre à partir de n'importe quelle chaîne numérique (comme vous n'avez qu'un seul caractère, ce sera toujours un entier de 0 à 9) et un NaNpour toute autre chaîne.

Juste utiliser isFinite

const number = "1";
if (isFinite(number)) {
    // do something
}