Karakter sayı mı kontrol edin?

Kontrol etmem gerek justPrices[i].substr(commapos+2,1).

Dize şuna benzer: "blabla, 120"

Bu durumda, '0'ın bir sayı olup olmadığını kontrol eder. Bu nasıl yapılabilir?

Rakam karakterleri aralığında olup olmadığını görmek için karşılaştırma operatörlerini kullanabilirsiniz:

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

ya kullanabilir parseIntve sonra kontrol edebilirsinizisNaN

veya doğrudan dizeniz üzerinde çalışmak istiyorsanız, şu şekilde regexp kullanabilirsiniz:

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

DÜZENLEME: Yalnızca tek bir karakteri (yani !isNaN(parseInt(c, 10))) kontrol ediyorsanız, Blender'ın güncellenmiş yanıtı burada doğru yanıttır . Tüm dizeleri test etmek istiyorsanız aşağıdaki cevabım iyi bir çözümdür.

İşte jQuery'nin tam dizelereisNumeric karşı çalışan uygulaması (saf JavaScript'te) :

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

Bu işlevin açıklaması şu şekildedir:

// parseFloat NaNs sayısal döküm yanlış pozitifler (null | true | false | "")
// ... ancak önde gelen sayı dizelerini, özellikle onaltılık değişmezleri yanlış yorumlar ("0x ...")
// çıkarma sonsuzlukları NaN'ye zorlar

Sanırım bu ahbapların bunun için epey zaman harcadıklarına güvenebiliriz!

Burada yorum yapılan kaynak . Burada süper inek tartışma .

Merak ediyorum neden kimse böyle bir çözüm göndermedi:

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

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

gibi bir çağrı ile:

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

Bunu kullanabilirsiniz:

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

Burada kabul edilen yöntemle karşılaştırdım: http://jsperf.com/isdigittest/5 . Çok şey beklemiyordum, bu yüzden kabul edilen yöntemin çok daha yavaş olduğunu öğrendiğimde oldukça şaşırdım.

İlginç olan, kabul edilen yöntem daha hızlı doğru girdi (ör. '5') ve yanlış için daha yavaş (ör. 'A') iken, benim yöntemim tam tersidir (yanlış için hızlı ve doğru için daha yavaştır).

Yine de, en kötü durumda, yöntemim doğru giriş için kabul edilen çözümden 2 kat, yanlış giriş için 5 kattan daha hızlıdır.

Bunu çözmenin yollarını bulmanın çok eğlenceli olduğunu düşünüyorum. Aşağıda bazıları verilmiştir.
(Aşağıdaki tüm işlevler bağımsız değişkenin tek bir karakter olduğunu varsayar . Zorlamak için değiştirin n[0])

Yöntem 1:

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

Yöntem 2:

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

Yöntem 3:

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

Yöntem 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
  }
})();

Yöntem 5:

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

Test dizesi:

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

Basit işlev

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

Tek karakterleri test ediyorsanız, o zaman:

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

c'nin rakam olup olmamasına bağlı olarak doğru veya yanlış döndürür.

Basit bir normal ifade öneririm.

Dizedeki son karakteri arıyorsanız:

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

Ve giriş olarak tek bir karakteri kontrol ediyorsanız normal ifade daha da basittir:

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

En kısa çözüm:

const isCharDigit = n => n < 10;

Bunları da uygulayabilirsiniz:

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

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

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

1'den fazla karakter kontrol etmek istiyorsanız, sonraki varyantları kullanabilirsiniz

Düzenli ifade:

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

Karşılaştırma:

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

NaN olup olmadığını kontrol edin

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

katı mod olmadan çıktı:

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

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

true
true
false
false

katı modda çıktı:

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

Deneyin:

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

Yukarıdaki cevaplardan birine benzer şekilde, kullandım

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

Bu blog yazısı , Javascript'te bir dizenin sayısal olup olmadığını kontrol etmek için biraz daha ışık tutuyor | Typescript & ES6

Dilin dinamik tür denetiminden yararlanarak basit bir çözüm:

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

aşağıdaki test durumlarına bakın

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

Bu işe yarıyor gibi görünüyor:

Statik bağlama:

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

Prototip bağlama:

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

Sayısal olup olmadıklarını görmek için tek karakterleri ve tüm dizeleri kontrol edecektir.

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

Kaynak

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

Kaynak kodu

Bunu deneyebilirsin (benim durumumda çalıştı)

Bir dizenin ilk karakterinin int olup olmadığını test etmek istiyorsanız:

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

Karakterin int olup olmadığını test etmek istiyorsanız:

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

Bu işlev bulabildiğim tüm test durumları için çalışıyor. Ayrıca şunlardan daha hızlıdır:

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)

Bildiğim kadarıyla en kolay yol şununla çarpmaktır 1:

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

Bir ile çarpma, herhangi bir sayısal dizeden bir sayı oluşturur (yalnızca bir karakteriniz olduğundan, bu her zaman 0'dan 9'a kadar bir tam sayı olacaktır) ve NaNdiğer dizeler için a.

Sadece kullan isFinite

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