Kiểm tra xem ký tự có phải là số không?

Tôi cần phải kiểm tra xem justPrices[i].substr(commapos+2,1).

Chuỗi có dạng như: "blabla, 120"

Trong trường hợp này, nó sẽ kiểm tra xem '0' có phải là một số hay không. Điều này có thể giải quyết như thế nào?

Bạn có thể sử dụng các toán tử so sánh để xem nó có nằm trong phạm vi các ký tự chữ số hay không:

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

bạn có thể sử dụng parseIntvà kiểm tra vớiisNaN

hoặc nếu bạn muốn làm việc trực tiếp trên chuỗi của mình, bạn có thể sử dụng regexp như sau:

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

CHỈNH SỬA: Câu trả lời được cập nhật của Blender là câu trả lời phù hợp ở đây nếu bạn chỉ đang kiểm tra một ký tự duy nhất (cụ thể là !isNaN(parseInt(c, 10))). Câu trả lời của tôi dưới đây là một giải pháp tốt nếu bạn muốn kiểm tra toàn bộ chuỗi.

Đây là cách isNumerictriển khai của jQuery (trong JavaScript thuần túy), hoạt động dựa trên chuỗi đầy đủ :

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

Nhận xét cho chức năng này là:

// parseFloat NaNs kết xuất sai số dương (null | true | false | "")
// ... nhưng hiểu sai các chuỗi số đứng đầu, đặc biệt là các ký tự hex ("0x ...")
// phép trừ buộc các số vô hạn thành NaN

Tôi nghĩ chúng ta có thể tin tưởng rằng những cuộc trò chuyện này đã dành khá nhiều thời gian cho việc này!

Nguồn bình luận tại đây . Thảo luận siêu geek ở đây .

Tôi tự hỏi tại sao không ai đăng một giải pháp như:

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

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

với một lời kêu gọi như:

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

Bạn có thể sử dụng cái này:

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

Ở đây, tôi đã so sánh nó với phương pháp được chấp nhận: http://jsperf.com/isdigittest/5 . Tôi đã không mong đợi nhiều, vì vậy tôi khá ngạc nhiên, khi tôi phát hiện ra rằng phương pháp được chấp nhận chậm hơn nhiều.

Điều thú vị là, trong khi phương pháp được chấp nhận là đầu vào đúng nhanh hơn (ví dụ: '5') và chậm hơn cho không chính xác (ví dụ: 'a'), phương pháp của tôi hoàn toàn ngược lại (nhanh hơn cho sai và chậm hơn cho đúng).

Tuy nhiên, trong trường hợp xấu nhất, phương pháp của tôi nhanh hơn 2 lần so với giải pháp được chấp nhận cho đầu vào đúng và nhanh hơn 5 lần cho đầu vào không chính xác.

Tôi nghĩ rất vui khi nghĩ ra cách giải quyết vấn đề này. Dưới đây là một số.
(Tất cả các hàm bên dưới giả sử đối số là một ký tự duy nhất. Thay đổi thành n[0]để thực thi nó)

Phương pháp 1:

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

Phương pháp 2:

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

Phương pháp 3:

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

Phương pháp 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
  }
})();

Phương pháp 5:

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

Chuỗi kiểm tra:

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

Chức năng đơn giản

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

Nếu bạn đang thử nghiệm các ký tự đơn lẻ, thì:

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

sẽ trả về true hoặc false tùy thuộc vào việc c có phải là một chữ số hay không.

Tôi đề nghị một regex đơn giản.

Nếu bạn chỉ đang tìm kiếm ký tự cuối cùng trong chuỗi:

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

Và regex thậm chí còn đơn giản hơn nếu bạn chỉ kiểm tra một ký tự duy nhất làm đầu vào:

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

Giải pháp ngắn nhất là:

const isCharDigit = n => n < 10;

Bạn cũng có thể áp dụng những điều này:

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

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

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

nếu bạn muốn kiểm tra nhiều hơn 1 người trò chuyện, bạn có thể sử dụng các biến thể tiếp theo

Biểu hiện thông thường:

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

So sánh:

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

Kiểm tra xem nó có phải là NaN không

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

đầu ra không có chế độ nghiêm ngặt:

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

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

true
true
false
false

đầu ra với chế độ nghiêm ngặt:

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

Thử:

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

Điều này dường như hoạt động:

Liên kết tĩnh:

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

Liên kết nguyên mẫu:

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

Nó sẽ kiểm tra các ký tự đơn, cũng như toàn bộ chuỗi để xem chúng có phải là số hay không.

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

Nguồn

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

Mã nguồn

Bạn có thể thử điều này (hiệu quả trong trường hợp của tôi)

Nếu bạn muốn kiểm tra xem ký tự đầu tiên của chuỗi có phải là int hay không:

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

Nếu bạn muốn kiểm tra xem char có phải là int hay không:

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

Chức năng này hoạt động cho tất cả các trường hợp thử nghiệm mà tôi có thể tìm thấy. Nó cũng nhanh hơn:

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)

Theo như tôi biết, cách đơn giản nhất là nhân với 1:

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

Phép nhân với một tạo thành một số từ bất kỳ chuỗi số nào (vì bạn chỉ có một ký tự, nó sẽ luôn là số nguyên từ 0 đến 9) và a NaNcho bất kỳ chuỗi nào khác.

Tương tự như một trong những câu trả lời ở trên, tôi đã sử dụng

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

Bài đăng blog này làm sáng tỏ thêm về việc kiểm tra xem chuỗi có phải là số trong Javascript hay không | Chữ ký tên & ES6

Một giải pháp đơn giản bằng cách tận dụng kiểm tra kiểu động của ngôn ngữ:

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

xem các trường hợp thử nghiệm bên dưới

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

Chỉ dùng isFinite

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