Periksa apakah karakter adalah angka?

Saya perlu memeriksa apakah justPrices[i].substr(commapos+2,1).

Stringnya kira-kira seperti: "blabla, 120"

Dalam hal ini akan memeriksa apakah '0' adalah angka. Bagaimana ini bisa dilakukan?

Anda dapat menggunakan operator perbandingan untuk melihat apakah itu dalam kisaran karakter digit:

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

Anda dapat menggunakan parseIntdan memeriksaisNaN

atau jika Anda ingin bekerja secara langsung pada string Anda, Anda dapat menggunakan regexp seperti ini:

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

EDIT: Jawaban terbaru Blender adalah jawaban yang benar di sini jika Anda hanya memeriksa satu karakter (yaitu !isNaN(parseInt(c, 10))). Jawaban saya di bawah ini adalah solusi yang baik jika Anda ingin menguji seluruh string.

Berikut adalah isNumericimplementasi jQuery (dalam JavaScript murni), yang bekerja dengan string penuh :

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

Komentar untuk fungsi ini berbunyi:

// parseFloat NaNs numeric-cast false positives (null | true | false | "")
// ... tetapi salah mengartikan string angka-terdepan, terutama hex literal ("0x ...")
// pengurangan memaksa infinitas ke NaN

Saya pikir kita bisa percaya bahwa orang-orang ini telah menghabiskan cukup banyak waktu untuk ini!

Sumber berkomentar di sini . Diskusi super geek di sini .

Saya bertanya-tanya mengapa tidak ada yang memposting solusi seperti:

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

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

dengan doa seperti:

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

Anda dapat menggunakan ini:

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

Di sini, saya membandingkannya dengan metode yang diterima: http://jsperf.com/isdigittest/5 . Saya tidak berharap banyak, jadi saya cukup terkejut, ketika saya menemukan bahwa metode yang diterima jauh lebih lambat.

Hal yang menarik adalah, meskipun metode yang diterima adalah input yang benar lebih cepat (mis. '5') dan lebih lambat untuk yang salah (mis. 'A'), metode saya justru sebaliknya (cepat untuk yang salah dan lebih lambat untuk yang benar).

Namun, dalam kasus terburuk, metode saya 2 kali lebih cepat daripada solusi yang diterima untuk masukan yang benar dan lebih dari 5 kali lebih cepat untuk masukan yang salah.

Saya pikir sangat menyenangkan menemukan cara untuk menyelesaikan ini. Berikut ini beberapa.
(Semua fungsi di bawah ini menganggap argumen adalah satu karakter. Ubah ke n[0]untuk memaksakannya)

Metode 1:

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

Metode 2:

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

Metode 3:

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

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

Metode 5:

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

String uji:

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

Fungsi sederhana

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

Jika Anda menguji karakter tunggal, maka:

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

akan mengembalikan true atau false tergantung pada apakah c adalah digit atau bukan.

Saya menyarankan regex sederhana.

Jika Anda hanya mencari karakter terakhir dalam string:

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

Dan regex bahkan lebih sederhana jika Anda hanya memeriksa satu karakter sebagai masukan:

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

Solusi terpendek adalah:

const isCharDigit = n => n < 10;

Anda juga dapat menerapkan ini:

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

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

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

jika Anda ingin memeriksa lebih dari 1 karakter, Anda dapat menggunakan varian berikutnya

Ekspresi Reguler:

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

Perbandingan:

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

Periksa apakah bukan 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));
    }
}

keluaran tanpa mode ketat:

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

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

true
true
false
false

keluaran dengan mode ketat:

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

Mencoba:

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

Ini sepertinya berhasil:

Pengikatan statis:

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

Pengikatan prototipe:

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

Ini akan memeriksa karakter tunggal, serta seluruh string untuk melihat apakah mereka numerik.

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

Sumber

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

Kode sumber

Anda dapat mencoba ini (berhasil dalam kasus saya)

Jika Anda ingin menguji apakah karakter pertama dari sebuah string adalah int:

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

Jika Anda ingin menguji apakah char adalah int:

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

Fungsi ini berfungsi untuk semua kasus uji yang dapat saya temukan. Ini juga lebih cepat dari:

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)

Sejauh yang saya tahu, cara termudah adalah dengan mengalikannya dengan 1:

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

Perkalian dengan satu membuat angka dari string numerik apa pun (karena Anda hanya memiliki satu karakter, itu akan selalu berupa bilangan bulat dari 0 hingga 9) dan NaNuntuk string lainnya.

Mirip dengan salah satu jawaban di atas, saya dulu

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

Posting blog ini menjelaskan lebih lanjut tentang pemeriksaan ini jika sebuah string adalah numerik dalam Javascript | Ketikan & ES6

Solusi sederhana dengan memanfaatkan pemeriksaan tipe dinamis bahasa:

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

lihat kasus uji di bawah

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

Gunakan saja isFinite

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