타이프 스크립트에서 문자열이 숫자인지 확인하는 방법

타이프 스크립트에서 문자열이 숫자인지 확인하는 방법

Typescript에 isNaN이 숫자 값만 받아들인다는 오류가 표시됩니다.

isNaN('9BX46B6A')

false가 반환되는 이유는parseFloat('9BX46B6A')까지 평가하다.9

isNaN(parseFloat('9BX46B6A'))

Visual Studio에 오류가 표시되어도 실행할 수 있지만 올바른 방법으로 실행하고 싶습니다.

현재 이 수정된 함수를 작성했습니다.

static isNaNModified = (inputStr: string) => {
    var numericRepr = parseFloat(inputStr);
    return isNaN(numericRepr) || numericRepr.toString().length != inputStr.length;
}

문자열을 숫자로 변환하는 방법은Number,것은 아니다.parseFloat.

Number('1234') // 1234
Number('9BX9') // NaN

단항 더하기 연산자를 사용할 수도 있습니다.

+'1234' // 1234
+'9BX9' // NaN

NaN(작업자)에 대해 확인할 때 주의하십시오.===그리고.!==뜻대로 되지 않다NaN) 사용방법:

 isNaN(+maybeNumber) // returns true if NaN, otherwise false

function isNumber(value: string | number): boolean
{
   return ((value != null) &&
           (value !== '') &&
           !isNaN(Number(value.toString())));
}

갱신하다

이 메서드는 rxjs v6에서 더 이상 사용할 수 없습니다.

---

rxjs 라이브러리에서 isNumeric 연산자를 사용하여 해결했습니다(rxjs/util/isNumeric Import).

import { isNumeric } from 'rxjs/util/isNumeric';

. . .

var val = "5700";
if (isNumeric(val)){
   alert("it is number !");
}

간단한 해결책은 다음과 같습니다.

const isNumeric = (val: string) : boolean => {
   return !isNaN(Number(val));
}

// isNumberic("2") => true
// isNumeric("hi") => false;

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

Number.isFinite(Infinity);  // false
Number.isFinite(NaN);       // false
Number.isFinite(-Infinity); // false
Number.isFinite('0');       // false
Number.isFinite(null);      // false

Number.isFinite(0);         // true
Number.isFinite(2e64);      // true

주의: 글로벌 기능에는 큰 차이가 있습니다.isFinite()후자Number.isFinite()전자의 경우 스트링 강제가 행해집니다.따라서isFinite('0') === true와 동시에Number.isFinite('0') === false.

또, IE에서는 사용할 수 없는 것에 주의해 주세요.

간단한 답변: (공백과 늘을 확인합니다)

isNaN(+'111') = false;
isNaN(+'111r') = true;
isNaN(+'r') = true;
isNaN(+'') = false;   
isNaN(null) = false;   

https://codepen.io/CQCoder/pen/zYGEjxd?editors=1111

기존 솔루션과 이미 테스트된 솔루션을 선택합니다.예를 들어, 이것은 typescript의 rxjs에서 유래합니다.

function isNumeric(val: any): val is number | string {
  // parseFloat NaNs numeric-cast false positives (null|true|false|"")
  // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
  // subtraction forces infinities to NaN
  // adding 1 corrects loss of precision from parseFloat (#15100)
  return !isArray(val) && (val - parseFloat(val) + 1) >= 0;
}

rxjs/isNumeric.ts

rxjs isArray() 함수와 간단한 입력이 없는 경우:

function isNumeric(val: any): boolean {
  return !(val instanceof Array) && (val - parseFloat(val) + 1) >= 0;
}

이러한 기능은 항상 사용 사례와 함께 테스트해야 합니다.특수한 값 유형이 있는 경우 이 함수는 솔루션이 아닐 수 있습니다.여기서 기능을 테스트할 수 있습니다.

결과는 다음과 같습니다.

enum         : CardTypes.Debit   : true
decimal      : 10                : true
hexaDecimal  : 0xf10b            : true
binary       : 0b110100          : true
octal        : 0o410             : true
stringNumber : '10'              : true

string       : 'Hello'           : false
undefined    : undefined         : false
null         : null              : false
function     : () => {}          : false
array        : [80, 85, 75]      : false
turple       : ['Kunal', 2018]   : false
object       : {}                : false

보시는 바와 같이 이 기능을 enum과 함께 사용할 경우 주의해야 합니다.

변수가 문자열, 숫자 또는 모든 유형일 수 있다는 점을 고려하면 Angular/Typescript의 전체 숫자(비플로트)에 대해 다음을 사용할 수 있습니다.

var isFullNumber: boolean = 
    Number.isInteger(Number(yourVariable)) && yourVariable !== null;

@tarrbal이 지적한 대로 편집 - 다음 것만 사용할 수 없습니다.

Number.isInteger(yourVariable);

다음 3가지 테스트를 확인합니다.

let testVariables = [0, 1, "0", "1", "A", {}, -3, 0.1, NaN, null, undefined]; 

let isFullNumber: boolean;
let ix: number = 1;
testVariables.forEach(v => {
isFullNumber = Number.isInteger(v);                         // <---
console.log(ix++, ': ', v, isFullNumber);
})

console.log('--------------');

ix = 1;
testVariables.forEach(v => {
isFullNumber = Number.isInteger(Number(v));                 // <---
console.log(ix++, ': ', v, isFullNumber);
})

console.log('--------------');
ix = 1;
testVariables.forEach(v => {
isFullNumber = Number.isInteger(Number(v)) && v !== null;   // <---
console.log(ix++, ': ', v, isFullNumber);
})

그리고 다음 3가지 결과가 있습니다.

1   :       0           true
2   :       1           true
3   :       0           false <- would expect true
4   :       1           false <- would expect true
5   :       A           false
6   :       {}          false
7   :       -3          true
8   :       0.1         false
9   :       NaN         false
10  :       null        false
11  :       undefined   false
----------------------------
1   :       0           true
2   :       1           true
3   :       0           true
4   :       1           true
5   :       A           false
6   :       {}          false
7   :       -3          true
8   :       0.1         false
9   :       NaN         false
10  :       null        true <- would expect false
11  :       undefined   false
----------------------------
1   :       0           true
2   :       1           true
3   :       0           true
4   :       1           true
5   :       A           false
6   :       {}          false
7   :       -3          true
8   :       0.1         false
9   :       NaN         false
10  :       null        false
11  :       undefined   false

대부분의 경우 확인하고 싶은 값은 문자열 또는 숫자입니다.따라서 사용하는 함수는 다음과 같습니다.

const isNumber = (n: string | number): boolean => 
    !isNaN(parseFloat(String(n))) && isFinite(Number(n));

---

코드 앤 박스 테스트

const willBeTrue = [0.1, '1', '-1', 1, -1, 0, -0, '0', "-0", 2e2, 1e23, 1.1, -0.1, '0.1', '2e2', '1e23', '-0.1', ' 898', '080']

const willBeFalse = ['9BX46B6A', "+''", '', '-0,1', [], '123a', 'a', 'NaN', 1e10000, undefined, null, NaN, Infinity, () => {}]

각 답변을 훑어보고 이 간단한 원라이너가 아직 발표되지 않은 것에 놀랐습니다.

const isNumber = (val: string | number) => !!(val || val === 0) && !isNaN(Number(val.toString()));

이게 제 trusty isNumber 함수입니다.그것을 현명하게 사용하다.

function isNumber(numStr: string) {
  return !isNaN(parseFloat(numStr)) && !isNaN(+numStr)
}

테스트

it("test valid isNumber", () => {
  expect(isNumber("0")).toEqual(true)
  expect(isNumber("-1")).toEqual(true)
})

it("test invalid isNumber", () => {
  expect(isNumber('" 1000 "')).toEqual(false)
  expect(isNumber('" 100,00.00 "')).toEqual(false)
  expect(isNumber("100,00.00")).toEqual(false)
  expect(isNumber("")).toEqual(false)
  expect(isNumber(null as any as string)).toEqual(false)
  expect(isNumber("abc")).toEqual(false)
  expect(isNumber("10%")).toEqual(false)
  expect(isNumber("#10")).toEqual(false)
  expect(isNumber("2^10")).toEqual(false)
  expect(isNumber("2!")).toEqual(false)
  expect(isNumber("(10)")).toEqual(false)
  expect(isNumber("10px")).toEqual(false)
})

솔루션:

 function isNumeric(val: unknown): val is string | number {
  return (
    !isNaN(Number(Number.parseFloat(String(val)))) &&
    isFinite(Number(val))
  );
}

// true
isNumeric("-10");
isNumeric("0");
isNumeric("0xff");
isNumeric("0xFF");
isNumeric("8e5");
isNumeric("3.1415");
isNumeric("+10");
isNumeric("144");
isNumeric("5");

// false
isNumeric("-0x42");
isNumeric("7.2acdgs");
isNumeric("");
isNumeric({});
isNumeric(NaN);
isNumeric(null);
isNumeric(true);
isNumeric(Infinity);
isNumeric(undefined);
isNumeric([]);
isNumeric("some string");

 const isNumeric = (value: string): boolean =>
  !new RegExp(/[^\d]/g).test(value.trim());

소수점을 허용하려면

   const isNumeric = (value: string): boolean =>
      !new RegExp(/[^\d.]/g).test(value.trim());

이는 특수한 경우(예: null)에 적용됩니다.

if(!isNaN(yourValue) && yourValue !== true && yourValue !== false) {
    // then it's a number
} else {
    // then it's not a number
}

var sum=0인 경우, var x;

그럼 이건 어때요? sum+=(x|0);

문자열을 숫자로 해석할 수 있는지 여부는 실행 시 고려 사항입니다.타이프스크립트는 컴파일 시간(런타임이 아님)의 안전성에 중점을 두고 있기 때문에 이 사용 사례를 지원하지 않습니다.

언급URL : https://stackoverflow.com/questions/23437476/in-typescript-how-to-check-if-a-string-is-numeric