문자가 숫자인지 확인하시겠습니까?

문자가 숫자인지 확인하시겠습니까?

제가 확인해 봐야 할 필요가.justPrices[i].substr(commapos+2,1).

문자열은 "블라블라, 120"과 같습니다.

이 경우 '0'이 숫자인지 확인합니다.이것이 어떻게 행해지는가?

비교 연산자를 사용하여 숫자 문자 범위에 있는지 확인할 수 있습니다.

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

둘 중 하나를 사용할 수 있습니다.parseInt그리고 확인하기 보다는isNaN

또는 문자열을 직접 작업하려면 다음과 같이 regexp를 사용할 수 있습니다.

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

편집: 한 글자만 확인한다면 블렌더의 업데이트된 답변이 정답입니다(즉,!isNaN(parseInt(c, 10))). 아래의 제 답변은 만약 당신이 전체 문자열을 테스트하고 싶습니다.

여기 jQuery's.isNumeric구현(순수 자바스크립트로), 전체 문자열에 대해 작동합니다.

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

이 기능에 대한 설명은 다음과 같습니다.

// parseFloat NaNs 숫자 캐스트 false positives(null|true|false|")
// 선두 숫자 문자열, 특히 16진수 문자열("0x...")을 잘못 해석합니다.")
// 뺄셈은 NaN에 무한대의 힘을 줍니다.

우리는 이 친구들이 이 일에 꽤 많은 시간을 썼다는 것을 믿을 수 있다고 생각합니다!

여기에 댓글을 달았습니다.대단한 괴짜 토론입니다.

단순함수

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

확인하고 싶다면c정말로 한명의 캐릭터입니다.

function isCharNumber(c) {
  return typeof c === 'string' && c.length == 1 && c >= '0' && c <= '9';
}

왜 아무도 다음과 같은 해결책을 게시하지 않았는지 궁금합니다.

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
}

다음을 사용할 수 있습니다.

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배 이상 빠릅니다.

이를 해결할 수 있는 방법을 생각해 내는 것은 매우 재미있는 일이라고 생각합니다.아래는 몇 가지입니다.
(아래의 모든 함수는 인수가 단일 문자라고 가정합니다.다음으로 변경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) );

간단한 레젝스를 추천합니다.

문자열의 마지막 문자만 찾는 경우:

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

가장 짧은 솔루션은 다음과 같습니다.

const isCharDigit = n => n < 10;

다음 사항도 적용할 수 있습니다.

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

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

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

만약 당신이 하나 이상의 chatter를 확인하기를 원한다면, 당신은 다음 변형을 사용할 수 있습니다.

정규식:

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

비교:

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

NaN이 아닌지 확인

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

단일 문자를 테스트하는 경우 다음을 수행합니다.

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

['e','0'].forEach(c => console.log(
  `isDigit("${c}") : ${isDigit(c)}`)
);

c가 숫자인지 아닌지에 따라 true 또는 false를 반환합니다.

위의 답변들 중 하나와 유사하게, 저는 다음을 사용했습니다.

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

이 블로그 게시물은 문자열이 자바스크립트로 숫자인지 확인하는 내용을 좀 더 알려드립니다. | Typscript & ES6

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

여기에 그것을 하는 간단한 기능이 있습니다.

function is_number(char) {
    return !isNaN(parseInt(char));
}

Returns: true, false

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

시도:

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

언어의 동적 유형 검사를 활용한 간단한 솔루션:

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

아래의 테스트 사례를 참조합니다.

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

합니다.isNaN그리고.parseInt함수:

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

또 할 만한 - 1 를 들어 - 1 ) (:character * 1parseInt(character)- ) - 으로도.0빈 문자열과 공백만 포함하는 문자열에서 여기에 적합하지 않습니다.

나는 이것을 사용하고 있습니다.

const isNumber = (str) => (
    str.length === str.trim().length 
    && str.length > 0
    && Number(str) >= 0
)

문자열 또는 단일 문자에 사용할 수 있습니다.

이 답변을 좀 더 편리하게 수정하고 문자열이 아닌 문자로 제한합니다.

const charCodeZero = "0".charCodeAt(0);
const charCodeNine = "9".charCodeAt(0);
function isDigit(s:string) {
    return s.length==1&& s.charCodeAt(0) >= charCodeZero && s.charCodeAt(0) <= charCodeNine;
}

console.log(isDigit('4'))   //true
console.log(isDigit('4s'))  //false
console.log(isDigit('s'))   //false

작동하는 것 같습니다.

정적 바인딩:

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

프로토타입 바인딩:

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

숫자인지 확인하기 위해 전체 문자열뿐만 아니라 단일 문자도 확인합니다.

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

원천

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

소스코드

이거 한번 해보세요 (제 경우에는 효과가 있습니다)

문자열의 첫 번째 문자가 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")
}

이 기능은 제가 찾을 수 있는 모든 테스트 케이스에 대해 작동합니다.또한 다음보다 더 빠릅니다.

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)

간단한 regex 솔루션을 사용하여 한 문자만 확인합니다.

function isDigit(chr) {
      return  chr.match(/[0-9]/i);
}

letch = '6'; // 또는 정수 값을 가지는 다른 문자열

사용할 수 있는 간단한 함수 : !isNaN(ch - '0')

해 보십시오.isNAN

일반적으로:

isNAN(char)

예:

let isNum = !isNAN('5')  // true
let isNum = !isNAN('a')  // false

으로.isFinite

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

언급URL : https://stackoverflow.com/questions/8935632/check-if-character-is-number