이전 VB6 IsNumeric()기능 과 동일한 개념 공간에 무언가가 있기를 바라고 있습니까?

변수 (문자열 포함)가 숫자인지 확인하려면 숫자가 아닌지 확인하십시오.

변수 내용이 문자열인지 숫자인지에 관계없이 작동합니다.

isNaN(num)         // returns true if the variable does NOT contain a valid number

예

isNaN(123)         // false
isNaN('123')       // false
isNaN('1e10000')   // false (This translates to Infinity, which is a number)
isNaN('foo')       // true
isNaN('10px')      // true

물론 필요한 경우이를 무효화 할 수 있습니다. 예를 들어, IsNumeric당신이 준 예제 를 구현하려면 :

function isNumeric(num){
  return !isNaN(num)
}

숫자가 포함 된 문자열을 숫자로 변환하려면

문자열 에 숫자 만 포함 된 경우에만 작동 하고 그렇지 않으면를 반환합니다 NaN.

+num               // returns the numeric value of the string, or NaN 
                   // if the string isn't purely numeric characters

예

+'12'              // 12
+'12.'             // 12
+'12..'            // NaN
+'.12'             // 0.12
+'..12'            // NaN
+'foo'             // NaN
+'12px'            // NaN

문자열을 느슨하게 숫자로 변환하려면

예를 들어 '12px'를 12로 변환하는 데 유용합니다.

parseInt(num)      // extracts a numeric value from the 
                   // start of the string, or NaN.

예

parseInt('12')     // 12
parseInt('aaa')    // NaN
parseInt('12px')   // 12
parseInt('foo2')   // NaN      These last two may be different
parseInt('12a5')   // 12       from what you expected to see. 

수레

곰 염두에두고 있다고는 달리 +num, parseInt(이름에서 알 수 있듯이) 소수점을 다음 모든 잘라낸에 의해 정수에 float를 변환합니다 (사용하려는 경우 parseInt() 때문에 이 문제가, 당신은 아마 더 나은 대신 다른 방법을 사용하여 길 이죠 ) :

+'12.345'          // 12.345
parseInt(12.345)   // 12
parseInt('12.345') // 12

빈 문자열

빈 문자열은 약간 반 직관적 일 수 있습니다. +num빈 문자열 또는 공백이있는 문자열을 0으로 변환 isNaN()하고 동일하다고 가정합니다.

+''                // 0
+'   '             // 0
isNaN('')          // false
isNaN('   ')       // false

그러나 parseInt()동의하지 않습니다 :

parseInt('')       // NaN
parseInt('   ')    // NaN

그리고 당신은 RegExp-way를 갈 수 있습니다 :

var num = "987238";

if(num.match(/^-{0,1}\d+$/)){
  //valid integer (positive or negative)
}else if(num.match(/^\d+\.\d+$/)){
  //valid float
}else{
  //not valid number
}

문자열이 정수인지 (소수점이 아닌) 확인하려고한다면 정규 표현식을 사용하는 것이 좋습니다. 다른 방법 isNaN은 너무 복잡해서 너무 복잡합니다.

function isNumeric(value) {
    return /^-{0,1}\d+$/.test(value);
}

console.log(isNumeric('abcd'));         // false
console.log(isNumeric('123a'));         // false
console.log(isNumeric('1'));            // true
console.log(isNumeric('1234567890'));   // true
console.log(isNumeric('-23'));          // true
console.log(isNumeric(1234));           // true
console.log(isNumeric('123.4'));        // false
console.log(isNumeric(''));             // false
console.log(isNumeric(undefined));      // false
console.log(isNumeric(null));           // false

양의 정수만 허용하려면 다음을 사용하십시오.

function isNumeric(value) {
    return /^\d+$/.test(value);
}

console.log(isNumeric('123'));          // true
console.log(isNumeric('-23'));          // false

당신이 정말로 문자열은 숫자, 숫자 (정수 또는 부동 소수점), 정확히 숫자가 포함되어 있는지 확인하려면, 당신은 할 수 사용 parseInt()/ parseFloat(), Number()또는 !isNaN()스스로. 참고 !isNaN()실제로 반환 true할 때 Number()숫자를 반환하고, false그것을 반환 할 때 NaN, 그래서 토론의 나머지 부분에서 제외됩니다.

문제는 parseFloat()문자열이 숫자가 포함 된 경우 문자열이 포함되지 않은 경우에도이 숫자를 반환 할 것입니다 단지 와 정확히 번호 :

parseFloat("2016-12-31")  // returns 2016
parseFloat("1-1") // return 1
parseFloat("1.2.3") // returns 1.2

문제 Number()는 전달 된 값이 숫자가 아닌 경우 숫자를 반환한다는 것입니다!

Number("") // returns 0
Number(" ") // returns 0
Number(" \u00A0   \t\n\r") // returns 0

자신의 정규 표현식을 롤링 할 때의 문제점은 Javascript가 인식 할 때 부동 소수점 숫자와 일치하는 정확한 정규 표현식을 만들지 않으면 대소 문자를 놓치거나 피해야 할 경우를 인식한다는 것입니다. 그리고 자신의 정규식을 굴릴 수 있다고해도 왜? 더 간단한 내장 방법이 있습니다.

그러나 Number()(및 isNaN())는하지 parseFloat()않아야 할 때 숫자를 반환하는 모든 경우에 대해 올바른 작업을 수행 하고 그 반대의 경우도 마찬가지입니다. 따라서 문자열이 실제로 정확하고 유일한 숫자인지 확인하려면 두 함수를 모두 호출하고 둘 다 true를 반환 하는지 확인하십시오 .

function isNumber(str) {
  if (typeof str != "string") return false // we only process strings!
  // could also coerce to string: str = ""+str
  return !isNaN(str) && !isNaN(parseFloat(str))
}

이 질문에 대한 대답은 몇 가지 다른 사용자가 강조한 바와 같이 몇 가지 결함이 있습니다. 이것은 자바 스크립트로 접근하는 가장 쉽고 입증 된 방법 중 하나입니다.

function isNumeric(n) {
  return !isNaN(parseFloat(n)) && isFinite(n);
}

다음은 좋은 테스트 사례입니다.

console.log(isNumeric(12345678912345678912)); // true
console.log(isNumeric('2 '));                 // true
console.log(isNumeric('-32.2 '));             // true
console.log(isNumeric(-32.2));                // true
console.log(isNumeric(undefined));            // false

// the accepted answer fails at these tests:
console.log(isNumeric(''));                   // false
console.log(isNumeric(null));                 // false
console.log(isNumeric([]));                   // false

isNan 함수를 사용해보십시오 :

isNaN () 함수는 값이 잘못된 숫자 (Not-a-Number)인지 판별합니다.

이 함수는 값이 NaN과 같으면 true를 반환합니다. 그렇지 않으면 false를 반환합니다.

이 함수는 숫자 고유의 Number.isNaN () 메소드와 다릅니다 .

  전역 isNaN () 함수는 테스트 된 값을 숫자로 변환 한 다음 테스트합니다.

Number.isNan ()은 값을 숫자로 변환하지 않으며 숫자 유형이 아닌 값에 대해서는 true를 반환하지 않습니다.

오래된 질문이지만 주어진 답변에 몇 가지 점이 누락되었습니다.

과학적 표기법.

!isNaN('1e+30')이다 true사람들이 번호를 요구하는 경우 그러나 대부분의 경우, 그들은 같은 것들을 일치하지 않습니다 1e+30.

큰 부동 숫자는 이상하게 동작 할 수 있습니다

관찰 (Node.js 사용) :

> var s = Array(16 + 1).join('9')
undefined
> s.length
16
> s
'9999999999999999'
> !isNaN(s)
true
> Number(s)
10000000000000000
> String(Number(s)) === s
false
>

반면에 :

> var s = Array(16 + 1).join('1')
undefined
> String(Number(s)) === s
true
> var s = Array(15 + 1).join('9')
undefined
> String(Number(s)) === s
true
>

따라서 기대하는 경우 String(Number(s)) === s문자열을 최대 15 자리로 제한하는 것이 좋습니다 (앞의 0을 생략 한 후).

무한대

> typeof Infinity
'number'
> !isNaN('Infinity')
true
> isFinite('Infinity')
false
>

모든 것을 감안할 때 주어진 문자열이 다음을 모두 만족하는 숫자인지 확인하십시오.

• 비 과학적 표기법
• 예측에 변환 Number하고 다시String
• 한정된

그렇게 쉬운 일이 아닙니다. 간단한 버전은 다음과 같습니다.

  function isNonScientificNumberString(o) {
    if (!o || typeof o !== 'string') {
      // Should not be given anything but strings.
      return false;
    }
    return o.length <= 15 && o.indexOf('e+') < 0 && o.indexOf('E+') < 0 && !isNaN(o) && isFinite(o);
  }

그러나 이것조차도 완전하지 않습니다. 선행 0은 여기서 처리되지 않지만 길이 테스트를 망칩니다.

나는 테스트했으며 Michael의 솔루션이 가장 좋습니다. 위의 답변에 투표하십시오 (이 페이지에서 "실제로 문자열을 확인하려면"를 찾으십시오). 본질적으로 그의 대답은 다음과 같습니다.

function isNumeric(num){
  num = "" + num; //coerce num to be a string
  return !isNaN(num) && !isNaN(parseFloat(num));
}

https://jsfiddle.net/wggehvp9/5/에 기록 된 모든 테스트 사례에서 작동합니다.

다음과 같은 경우에는 다른 많은 솔루션이 실패합니다 : '', null, "", true 및 []. 이론적으로 적절한 오류 처리와 함께 사용할 수 있습니다.

return !isNaN(num);

또는

return (+num === +num);

/ \ s /, null, "", true, false, [] (및 기타?)에 대한 특수 처리

생성자에 인수를 전달할 때 Number 의 결과를 사용할 수 있습니다 .

인수 (문자열)를 숫자로 변환 할 수없는 경우 NaN을 반환하므로 제공된 문자열이 유효한 숫자인지 여부를 결정할 수 있습니다.

주 : 빈 문자열 또는 전달 참고 '\t\t'및 '\n\t'번호는 0을 반환합니다 같은; true를 전달하면 1이 반환되고 false가 0을 반환합니다.

    Number('34.00') // 34
    Number('-34') // -34
    Number('123e5') // 12300000
    Number('123e-5') // 0.00123
    Number('999999999999') // 999999999999
    Number('9999999999999999') // 10000000000000000 (integer accuracy up to 15 digit)
    Number('0xFF') // 255
    Number('Infinity') // Infinity  

    Number('34px') // NaN
    Number('xyz') // NaN
    Number('true') // NaN
    Number('false') // NaN

    // cavets
    Number('    ') // 0
    Number('\t\t') // 0
    Number('\n\t') // 0

어쩌면 평소보다 훨씬 더 엄격한 확인이 필요한 한두 사람 이이 질문에 올 수 있습니다 . 이 경우 유용 할 수 있습니다.

if(str === String(Number(str))) {
  // it's a "perfectly formatted" number
}

조심해! 이 같은 문자열을 거부합니다 .1, 40.000, 080, 00.1. 매우 까다 롭습니다 .이 테스트를 통과 하려면 문자열 이 숫자 의 " 가장 완벽한 형태 " 와 일치해야합니다 .

그것은 Stringand Number생성자를 문자열을 숫자로 캐스트 한 다음 다시 되돌려 JavaScript 엔진의 "완벽한 최소 형식"(초기 Number생성자 로 변환 된 형식 )이 원래 문자열과 일치 하는지 확인 합니다.

parseInt (), 그러나이 함수는 예를 들어 parseInt ( "100px")에 대해 100을 반환한다는 점에서 약간 다릅니다.

인용문:

isNaN (num) // 변수에 유효한 숫자가 없으면 true를 반환합니다.

선행 / 트레일 공백을 확인해야하는 경우 (예 : 특정 숫자의 숫자가 필요한 경우, PIN에 대해 '111'또는 '111'이 아닌 '1111'을 가져와야하는 경우) 입력.

사용하는 것이 좋습니다 :

var num = /^\d+$/.test(num)

jQuery의 구현이 충분하지 않은 이유는 무엇입니까?

function isNumeric(a) {
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0;
};

Michael은 다음과 같이 제안했습니다 (여기에서 "user1691651-John"의 변경된 버전을 도난했지만).

function isNumeric(num){
    num = "" + num; //coerce num to be a string
    return !isNaN(num) && !isNaN(parseFloat(num));
}

다음은 성능이 좋지 않지만 결과가 확실한 솔루션입니다. jQuery 1.12.4 구현과 Michael의 대답으로 이루어지며 앞 / 뒤 공백을 추가로 확인합니다 (Michael 버전은 앞 / 뒤 공백이있는 숫자에 대해 true를 반환하기 때문에).

function isNumeric(a) {
    var str = a + "";
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0 &&
           !/^\s+|\s+$/g.test(str) &&
           !isNaN(str) && !isNaN(parseFloat(str));
};

그러나 후자 버전에는 두 가지 새로운 변수가 있습니다. 다음을 수행하여 그 중 하나를 해결할 수 있습니다.

function isNumeric(a) {
    if ($.isArray(a)) return false;
    var b = a && a.toString();
    a = a + "";
    return b - parseFloat(b) + 1 >= 0 &&
            !/^\s+|\s+$/g.test(a) &&
            !isNaN(a) && !isNaN(parseFloat(a));
};

나는 현재의 곤경에 부딪 칠 몇 가지 유스 케이스를 수동으로 테스트하는 것 이외의 다른 방법으로 이것들 중 많은 것을 테스트하지 않았습니다. 이것은 모두 매우 표준적인 것입니다. 이것은 "거대한 어깨 위에 서있는"상황입니다.

TypeScript에는 다음과 같이 유효하지 않습니다.

declare function isNaN(number: number): boolean;

TypeScript의 경우 다음을 사용할 수 있습니다.

/^\d+$/.test(key)

글쎄, 내가 만든 것을 사용하고 있습니다 ...

지금까지 노력하고 있습니다 :

function checkNumber(value) {
    if ( value % 1 == 0 )
    return true;
    else
    return false;
}

문제가 있으면 알려주세요.

누구 든지이 문제를 해결했다면 moment.js ( https://github.com/moment/moment ) 를 패치하려고 시도하는 데 시간을 보냈습니다 . 여기 내가 가져간 것이 있습니다.

function isNumeric(val) {
    var _val = +val;
    return (val !== val + 1) //infinity check
        && (_val === +val) //Cute coercion check
        && (typeof val !== 'object') //Array/object check
}

다음과 같은 경우를 처리합니다.

진실! :

isNumeric("1"))
isNumeric(1e10))
isNumeric(1E10))
isNumeric(+"6e4"))
isNumeric("1.2222"))
isNumeric("-1.2222"))
isNumeric("-1.222200000000000000"))
isNumeric("1.222200000000000000"))
isNumeric(1))
isNumeric(0))
isNumeric(-0))
isNumeric(1010010293029))
isNumeric(1.100393830000))
isNumeric(Math.LN2))
isNumeric(Math.PI))
isNumeric(5e10))

그릇된! :

isNumeric(NaN))
isNumeric(Infinity))
isNumeric(-Infinity))
isNumeric())
isNumeric(undefined))
isNumeric('[1,2,3]'))
isNumeric({a:1,b:2}))
isNumeric(null))
isNumeric([1]))
isNumeric(new Date()))

아이러니하게도, 내가 가장 힘들어하는 것 :

isNumeric(new Number(1)) => false

모든 제안을 환영합니다. :]

일반 자바 스크립트 사용 :

Number.isNaN(Number('1')); // false
Number.isNaN(Number('asdf')); // true

Lodash 사용하기 :

_.isNaN(_.toNumber('1')); // false
_.isNaN(_.toNumber('asdf')); // true

function isNumberCandidate(s) {
  const str = (''+ s).trim();
  if (str.length === 0) return false;
  return !isNaN(+str);
}

console.log(isNumberCandidate('1'));       // true
console.log(isNumberCandidate('a'));       // false
console.log(isNumberCandidate('000'));     // true
console.log(isNumberCandidate('1a'));      // false 
console.log(isNumberCandidate('1e'));      // false
console.log(isNumberCandidate('1e-1'));    // true
console.log(isNumberCandidate('123.3'));   // true
console.log(isNumberCandidate(''));        // false
console.log(isNumberCandidate(' '));       // false
console.log(isNumberCandidate(1));         // true
console.log(isNumberCandidate(0));         // true
console.log(isNumberCandidate(NaN));       // false
console.log(isNumberCandidate(undefined)); // false
console.log(isNumberCandidate(null));      // false
console.log(isNumberCandidate(-1));        // true
console.log(isNumberCandidate('-1'));      // true
console.log(isNumberCandidate('-1.2'));    // true
console.log(isNumberCandidate(0.0000001)); // true
console.log(isNumberCandidate('0.0000001')); // true
console.log(isNumberCandidate(Infinity));    // true
console.log(isNumberCandidate(-Infinity));    // true

console.log(isNumberCandidate('Infinity'));  // true

if (isNumberCandidate(s)) {
  // use +s as a number
  +s ...
}

2019 : ES3, ES6 및 TypeScript 예제 포함

어쩌면 이것은 너무 많이 다시 해쉬되었을 수도 있지만 오늘도 이것과 싸워서 간단하거나 철저하게 수행하는 다른 답변을 보지 못했기 때문에 내 답변을 게시하고 싶었습니다.

ES3

var isNumeric = function(num){
    return (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);  
}

ES6

const isNumeric = (num) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);

타이프 스크립트

const isNumeric = (num: any) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num as number);

이것은 매우 단순 해 보이며 다른 많은 게시물에서 보았고 스스로 생각한 모든 기초를 다룹니다.

// Positive Cases
console.log(0, isNumeric(0) === true);
console.log(1, isNumeric(1) === true);
console.log(1234567890, isNumeric(1234567890) === true);
console.log('1234567890', isNumeric('1234567890') === true);
console.log('0', isNumeric('0') === true);
console.log('1', isNumeric('1') === true);
console.log('1.1', isNumeric('1.1') === true);
console.log('-1', isNumeric('-1') === true);
console.log('-1.2354', isNumeric('-1.2354') === true);
console.log('-1234567890', isNumeric('-1234567890') === true);
console.log(-1, isNumeric(-1) === true);
console.log(-32.1, isNumeric(-32.1) === true);
console.log('0x1', isNumeric('0x1') === true);  // Valid number in hex
// Negative Cases
console.log(true, isNumeric(true) === false);
console.log(false, isNumeric(false) === false);
console.log('1..1', isNumeric('1..1') === false);
console.log('1,1', isNumeric('1,1') === false);
console.log('-32.1.12', isNumeric('-32.1.12') === false);
console.log('[blank]', isNumeric('') === false);
console.log('[spaces]', isNumeric('   ') === false);
console.log('null', isNumeric(null) === false);
console.log('undefined', isNumeric(undefined) === false);
console.log([], isNumeric([]) === false);
console.log('NaN', isNumeric(NaN) === false);

당신은 또한 자신을 시도 할 수 있습니다 isNumeric 기능을 하고 이러한 유스 케이스의 과거를 지나서 그들 모두에 대해 "true"를 스캔 할 수 있습니다.

또는 각각 반환하는 값을 보려면

2019 : 실용적이고 엄격한 수치 유효성 검사

종종 '유효한 숫자'는 NaN과 무한대를 제외한 자바 스크립트 숫자, 즉 '유한 숫자'를 의미합니다.

외부 소스 등의 값의 숫자 유효성을 확인하려면 ESlint Airbnb 스타일로 정의 할 수 있습니다.

/**
 * Returns true if 'candidate' is a finite number or a string referring (not just 'including') a finite number
 * To keep in mind:
 *   Number(true) = 1
 *   Number('') = 0
 *   Number("   10  ") = 10
 *   !isNaN(true) = true
 *   parseFloat('10 a') = 10
 *
 * @param {?} candidate
 * @return {boolean}
 */
function isReferringFiniteNumber(candidate) {
  if (typeof (candidate) === 'number') return Number.isFinite(candidate);
  if (typeof (candidate) === 'string') {
    return (candidate.trim() !== '') && Number.isFinite(Number(candidate));
  }
  return false;
}

이 방법으로 사용하십시오 :

if (isReferringFiniteNumber(theirValue)) {
  myCheckedValue = Number(theirValue);
} else {
  console.warn('The provided value doesn\'t refer to a finite number');
}

PFB 작업 솔루션 :

 function(check){ 
    check = check + "";
    var isNumber =   check.trim().length>0? !isNaN(check):false;
    return isNumber;
    }

"내장"솔루션을 찾는 데 어려움을 겪지 마십시오.

좋은 답변이 없으며이 글에서 크게 반박 된 답변이 잘못되었습니다.

npm install is-number

JavaScript에서 값이 숫자인지 확실하게 확인하는 것만 큼 항상 간단하지는 않습니다. 개발자가 +,-또는 Number ()를 사용하여 문자열 값을 숫자로 캐스트하는 것이 일반적입니다 (예 : 사용자 입력, 정규식 일치, 파서 등에서 값이 반환되는 경우). 그러나 예기치 않은 결과를 초래하는 직관적이지 않은 많은 경우가 있습니다.

console.log(+[]); //=> 0
console.log(+''); //=> 0
console.log(+'   '); //=> 0
console.log(typeof NaN); //=> 'number'

나는 최근에 변수를 확인하는 방법에 대한 기사가 유효한 숫자 쓴 : https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md 기사는 방법에 대해 설명, 부동 소수점 또는 정수를 보장하기 위해 그의 경우 중요 ( +xvs~~x ).

이 기사에서는 변수가 a string또는 a number로 시작하고 trim사용 가능 / 폴리 필 된 것으로 가정합니다 . 다른 유형을 처리하도록 확장하기도 어렵지 않습니다. 그 고기는 다음과 같습니다.

// Check for a valid float
if (x == null
    || ("" + x).trim() === ""
    || isNaN(+x)) {
    return false;  // not a float
}

// Check for a valid integer
if (x == null
    || ("" + x).trim() === ""
    || ~~x !== +x) {
    return false;  // not an integer
}

약간 혼란스러운 시도, 아마도 최고의 해결책은 아닙니다.

function isInt(a){
    return a === ""+~~a
}


console.log(isInt('abcd'));         // false
console.log(isInt('123a'));         // false
console.log(isInt('1'));            // true
console.log(isInt('0'));            // true
console.log(isInt('-0'));           // false
console.log(isInt('01'));           // false
console.log(isInt('10'));           // true
console.log(isInt('-1234567890'));  // true
console.log(isInt(1234));           // false
console.log(isInt('123.4'));        // false
console.log(isInt(''));             // false

// other types then string returns false
console.log(isInt(5));              // false
console.log(isInt(undefined));      // false
console.log(isInt(null));           // false
console.log(isInt('0x1'));          // false
console.log(isInt(Infinity));       // false

내 응용 프로그램에서는 az AZ 및 0-9 문자 만 허용합니다. 문자열이 0xnn (예 : 0x10)으로 시작하지 않으면 " string % 1 === 0"을 사용하여 위의 대답을 찾은 다음 원하지 않는 경우 숫자로 반환합니다. 내 숫자 검사에서 다음과 같은 간단한 트랩은 특정 경우에 트릭을 수행하는 것 같습니다.

function isStringNumeric(str_input){   
    //concat a temporary 1 during the modulus to keep a beginning hex switch combination from messing us up   
    //very simple and as long as special characters (non a-z A-Z 0-9) are trapped it is fine   
    return '1'.concat(str_input) % 1 === 0;}

경고 : 이것은 Javascript 및 Actionscript [Number ( "1"+ the_string) % 1 === 0)]의 오랜 버그를 악용 할 수 있지만, 말할 수는 없지만 정확히 필요한 것입니다.

내 해결책 :

// returns true for positive ints; 
// no scientific notation, hexadecimals or floating point dots

var isPositiveInt = function(str) { 
   var result = true, chr;
   for (var i = 0, n = str.length; i < n; i++) {
       chr = str.charAt(i);
       if ((chr < "0" || chr > "9") && chr != ",") { //not digit or thousands separator
         result = false;
         break;
       };
       if (i == 0 && (chr == "0" || chr == ",")) {  //should not start with 0 or ,
         result = false;
         break;
       };
   };
   return result;
 };

특정 요구에 맞게 루프 내부에 추가 조건을 추가 할 수 있습니다.

플로우 라이브러리 y 와 같이 유형을 사용하여 정적 컴파일 시간 검사를 얻을 수 있습니다. 물론 사용자 입력에는별로 유용하지 않습니다.

// @flow

function acceptsNumber(value: number) {
  // ...
}

acceptsNumber(42);       // Works!
acceptsNumber(3.14);     // Works!
acceptsNumber(NaN);      // Works!
acceptsNumber(Infinity); // Works!
acceptsNumber("foo");    // Error!

다음 sNum은 유효한 숫자 값 인지 확인하는 한 줄짜리 줄입니다 . 다양한 입력에 대해 테스트되었습니다.

!isNaN(+s.replace(/\s|\$/g, ''));  // returns True if numeric value

그냥 사용 isNaN()하면 문자열을 숫자 로 변환하고 유효한 숫자를 얻으면 false... 을 반환합니다 .

isNaN("Alireza"); //return true
isNaN("123"); //return false

나는 다음을 사용하고 있습니다 :

const isNumber = s => !isNaN(+s)