Überprüfen Sie, ob das Zeichen eine Zahl ist.

Ich muss prüfen, ob justPrices[i].substr(commapos+2,1).

Die Saite ist so etwas wie: "blabla, 120"

In diesem Fall würde geprüft, ob '0' eine Zahl ist. Wie kann das gemacht werden?

Sie können Vergleichsoperatoren verwenden, um festzustellen, ob sie im Bereich der Ziffern liegen:

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

Sie können entweder verwenden parseIntund dann mit überprüfenisNaN

oder wenn Sie direkt an Ihrem String arbeiten möchten, können Sie Regexp wie folgt verwenden:

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

BEARBEITEN: Die aktualisierte Antwort von Blender ist hier die richtige Antwort, wenn Sie nur ein einzelnes Zeichen überprüfen (nämlich !isNaN(parseInt(c, 10)) ) . Meine Antwort unten ist eine gute Lösung, wenn Sie ganze Zeichenfolgen testen möchten.

Hier ist die isNumericImplementierung von jQuery (in reinem JavaScript), die gegen vollständige Zeichenfolgen funktioniert :

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

Der Kommentar für diese Funktion lautet:

// parseFloat NaNs numerisch gegossene False Positives (null | true | false | "")
// ... interpretiert aber Zeichenfolgen mit führenden Zahlen falsch, insbesondere Hex-Literale ("0x ...")
// Subtraktion zwingt Unendlichkeiten zu NaN

Ich denke, wir können darauf vertrauen, dass diese Jungs ziemlich viel Zeit damit verbracht haben!

Kommentierte Quelle hier . Super Geek Diskussion hier .

Ich frage mich, warum niemand eine Lösung veröffentlicht hat wie:

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

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

mit einem Aufruf wie:

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

Sie können dies verwenden:

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

Hier habe ich es mit der akzeptierten Methode verglichen: http://jsperf.com/isdigittest/5 . Ich hatte nicht viel erwartet, also war ich ziemlich überrascht, als ich herausfand, dass die akzeptierte Methode viel langsamer war.

Interessant ist, dass die akzeptierte Methode zwar eine schnellere korrekte Eingabe (z. B. '5') und eine langsamere für falsche (z. B. 'a') ist, meine Methode jedoch genau umgekehrt ist (schnell für falsch und langsamer für korrekt).

Im schlimmsten Fall ist meine Methode jedoch 2-mal schneller als die akzeptierte Lösung für korrekte Eingaben und über 5-mal schneller für falsche Eingaben.

Ich denke, es macht sehr viel Spaß, Wege zu finden, um dies zu lösen. Unten sind einige.
(Alle folgenden Funktionen setzen voraus, dass das Argument ein einzelnes Zeichen ist. Ändern Sie zun[0] , um es zu erzwingen.)

Methode 1:

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

Methode 2:

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

Methode 3:

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

Methode 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
  }
})();

Methode 5:

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

Teststring:

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

Einfache Funktion

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

Wenn Sie einzelne Zeichen testen, dann:

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

gibt true oder false zurück, je nachdem, ob c eine Ziffer ist oder nicht.

Ich schlage eine einfache Regex vor.

Wenn Sie nur nach dem letzten Zeichen in der Zeichenfolge suchen:

/^.*?[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

Und der reguläre Ausdruck ist noch einfacher, wenn Sie nur ein einzelnes Zeichen als Eingabe überprüfen:

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

Die kürzeste Lösung ist:

const isCharDigit = n => n < 10;

Sie können diese auch anwenden:

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

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

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

Wenn Sie mehr als 1 Chat-Zeichen überprüfen möchten, können Sie die nächsten Varianten verwenden

Regulären Ausdruck:

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

Vergleich:

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

Überprüfen Sie, ob es sich nicht um NaN handelt

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));
    }
}

Ausgabe ohne strengen Modus:

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

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

true
true
false
false

Ausgabe im strengen Modus:

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

Versuchen:

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

Das scheint zu funktionieren:

Statische Bindung:

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

Prototypbindung:

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

Es werden sowohl einzelne Zeichen als auch ganze Zeichenfolgen überprüft, um festzustellen, ob sie numerisch sind.

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

Quelle

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

Quellcode

Sie können dies versuchen (in meinem Fall funktioniert)

Wenn Sie testen möchten, ob das erste Zeichen einer Zeichenfolge ein int ist:

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

Wenn Sie testen möchten, ob das Zeichen ein int ist:

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

Diese Funktion funktioniert für alle Testfälle, die ich finden konnte. Es ist auch schneller als:

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)

Soweit ich weiß, ist der einfachste Weg, einfach zu multiplizieren mit 1:

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

Die Multiplikation mit eins ergibt eine Zahl aus einer beliebigen numerischen Zeichenfolge (da Sie nur ein Zeichen haben, ist dies immer eine Ganzzahl von 0 bis 9) und eine NaNfür eine andere Zeichenfolge.

Ähnlich wie bei einer der obigen Antworten habe ich verwendet

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

Dieser Blogpost beleuchtet diese Prüfung, ob eine Zeichenfolge in Javascript | numerisch ist Typoskript & ES6

Eine einfache Lösung, bei der die dynamische Typprüfung der Sprache genutzt wird:

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

siehe Testfälle unten

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'))

Benutz einfach isFinite

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