Проверьте, является ли символ номером?

Ответ 1

Вы можете использовать isNaN() чтобы проверить, не является ли это число:

var c = justPrices[i].substr(commapos + 2, 1);

if (!isNaN(parseInt(c, 10))) {
    // Is a number
}

Или более многословно:

if ('0123456789'.indexOf(c) !== -1) {
    // Is a number
}

И если вас не волнует Internet Explorer:

if ('0123456789'.includes(c)) {
    // Is a number
}

Ответ 2

Вы можете использовать операторы сравнения, чтобы увидеть, находится ли он в диапазоне цифр:

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

Ответ 3

вы можете использовать parseInt и проверить с помощью isNaN

или если вы хотите работать непосредственно с вашей строкой, вы можете использовать regexp следующим образом:

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

Ответ 4

РЕДАКТИРОВАТЬ: обновленный ответ Blender является правильным ответом здесь, если вы просто проверяете один символ (а именно !isNaN(parseInt(c, 10))). Мой ответ ниже - хорошее решение, если вы хотите протестировать целые строки.

Вот реализация jQuery isNumeric (в чистом JavaScript), которая работает с полными строками:

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

Комментарий к этой функции гласит:

//parseFloat NaNs - числовые ложные срабатывания (null | true | false | "")
//... но неверно интерпретирует строки начальных чисел, особенно шестнадцатеричные литералы ("0x...")
// вычитаем силы бесконечности в NaN

Я думаю, мы можем верить, что эти парни потратили немало времени на это!

Комментируемый источник здесь. Супер гик обсуждение здесь.

Ответ 5

Вы можете использовать это:

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

Здесь я сравнил его с принятым методом: http://jsperf.com/isdigittest/5. Я не ожидал многого, поэтому я был очень удивлен, когда узнал, что принятый метод был намного медленнее.

Интересно, что, хотя принятый метод - это скорее правильный ввод (например, "5" ) и более медленный для неправильного (например, "a" ), мой метод абсолютно противоположный (быстрый для неправильного и медленного для правильного).

Тем не менее, в худшем случае мой метод в 2 раза быстрее принятого решения для правильного ввода и более чем в 5 раз быстрее для неправильного ввода.

Ответ 6

Интересно, почему никто не опубликовал решение вроде:

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

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

с вызовом типа:

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

Ответ 7

Я думаю, что очень забавно придумывать способы решения этой проблемы. Ниже приведены некоторые из них. (Все функции ниже предполагают, что аргумент является единственным символом. Перейдите на n[0], чтобы обеспечить его выполнение)

Способ 1:

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

Способ 2:

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

Способ 3:

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

Способ 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
  }
})();

Способ 5:

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

Тестовая строка:

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

Ответ 8

Простая функция

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

Ответ 9

Если вы тестируете одиночные символы, то:

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

вернет true или false в зависимости от того, является ли c цифрой или нет.

Ответ 10

Я предлагаю простое регулярное выражение.

Если вы ищете только последний символ в строке:

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

И регулярное выражение еще проще, если вы просто проверяете один символ в качестве входных данных:

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

Ответ 11

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

без строгих режимов:

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

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

true
true
false
false

вывод со строгим режимом:

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

Ответ 12

Пытаться:

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

Ответ 13

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

Исходный код

Ответ 14

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

Источник

Ответ 15

Вы можете попробовать это (работает в моем случае)

Если вы хотите проверить, является ли первый char для строки int:

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

Если вы хотите проверить, является ли char значение int:

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

Ответ 16

Это работает:

Статическое связывание:

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

Связывание прототипа:

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

Он проверит отдельные символы, а также целые строки, чтобы увидеть, являются ли они числовыми.

Ответ 17

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

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

Ответ 18

Простое решение, использующее динамическую проверку типов языка:

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

см. контрольные примеры ниже

function isNumber (string) {
   if(string === ' '.repeat(string.length)){
 return false
   }
   return string - 0 === string * 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'))

Ответ 19

Эта функция работает для всех тестовых случаев, которые я мог найти. Это также быстрее, чем:

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)

Ответ 20

Самое короткое решение:

const isCharDigit = n => n < 10;

Вы также можете применить их:

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

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

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

если вы хотите проверить более 1 чата, вы можете использовать следующие варианты

Регулярное выражение:

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

Сравнение:

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

Проверьте, не является ли это NaN

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

Ответ 21

Насколько я знаю, проще всего просто умножить на 1:

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

Умножение на единицу создает число из любой числовой строки (поскольку у вас есть только один символ, оно всегда будет целым числом от 0 до 9) и NaN для любой другой строки.

Ответ 22

Просто используйте isFinite

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