(組み込み)JavaScriptで文字列が有効な数値かどうかを確認する方法


1190

古いVB6 IsNumeric()関数と同じ概念空間に何かがあるといいのですが。


3
私が少し前に尋ねたこの関連質問を参照してください。
マイケルハーレン

38
この質問に行く場合は、すべてのRegEx回答をスキップしてください。それはそれを行う方法ではありません。
Joel Coehoorn、2008年

14
正確にそれを実行したくない場合を除きます。特定の文字列が有効な数字のストリームの形式であるかどうかを確認します。なぜそれが間違っているのですか?
SasQ 2014年

17
選択した答えは正しくありません!!! そのコメントを参照してくださいが、基本的には、例えばで失敗isNaN("")isNaN(" ")isNaN(false)それを返すなど、false彼らは数字であることを示唆し、これらのために。
Andrew

1
したがって、選択された答えは正しくありません。正規表現は、それを行う方法でもありません。どちらが正しいですか?
私たちVIR

回答:


2322

変数(文字列を含む)が数値かどうかを確認するには、変数が数値でないかどうかを確認します。

これは、変数の内容が文字列か数値かに関係なく機能します。

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. 

フロート

(名前が示すように)とは異なり+numparseInt浮動小数点を小数点以下をすべて切り捨てて整数に変換することに注意してください(この動作のparseInt() ために使用したい場合は代わりに別の方法を使用することをお勧めします) :

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

空の文字列

空の文字列は少し直感に反するかもしれません。+num空の文字列またはスペースを含む文字列をゼロに変換isNaN()し、同じと見なします。

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

しかしparseInt()同意しません:

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

133
parseIntに関する非常に重要な注意事項は、文字列をintに変換するための基数を指定できることです。これは、基数を指定しないと基数を推測しようとするため、大きな問題です。したがって、たとえば、parseInt( "17")は17(10進数、10)になりますが、parseInt( "08")は0(8進数、8)になります。したがって、特に意図しない限り、明示的に基数として10を指定して、parseInt(number、10)を使用するのが最も安全です。
アダム・ラニー

36
!isNaN(undefined)はfalseを返すことに注意してください。
David Hellsing、2010年

111
これは明らかに間違っています-どのようにして多くの賛成票を得たのですか?isNaN「変数が数値でないかどうかを確認するには」は使用できません。「非数」は、「IEEE-794 NaN」と同じではありませんisNaN。これは、テスト対象です。特に、少なくともブール値と空の文字列をテストする場合、この使用法は失敗します。developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…を参照してください。
EML

46
何かが数値であるかどうかを確認する最速の方法は、「自己と等しい」チェックですvar n = 'a'; if (+n === +n) { // is number }。最新バージョンのChromeのisNaNより〜3994%高速です。ここでパフォーマンステストを参照してください:jsperf.com/isnan-vs-typeof/5
Kevin Jurkowski

22
**警告**この答えは間違っています。自己責任。例:isNaN(1 + false + parseInt("1.do you trust your users?"))
keithpjolley

55

そして、あなたは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
}

40
この場合、RegExp ==悪い
Joel Coehoorn

10
これは、16進数(0x12など)では失敗し、先行ゼロなし(たとえば、.42)および負の数なしで浮動小数点数になります。
Ori

17
@JoelCoehoorn RegExp ==ここでなぜ悪いのかについて詳しく説明しますか?私には有効なユースケースのようです。
computrius 14

6
数値を作成するのに思われる方法は他にもあり(別のコメントの16進数は単なる一例です)、有効と見なされない可能性のある数値が多数あります(型のオーバーフロー、精度が高すぎるなど)。また、正規表現は、組み込みのメカニズムを使用するよりも低速で複雑です
Joel Coehoorn

1
科学表記にも一致する必要があります... 1e10など
Joseph Merdrignac

51

文字列が整数(小数点以下の桁数なし)であるかどうかを確認するだけの場合は、正規表現を使用するとよいでしょう。などの他の方法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

11
console.log(isNumeric( '-1'));
龍南2014年

5
console.log(isNumeric( '2e2'));
ガエル・Barbin

11
おそらく「isNumeric」の名前を「hasOnlyDigits」に変更するだけです。多くの場合、それはまさにあなたが探しているチェックです。
gus3001 2017年

1
これは私が探していたもので、php ctype_digitと同等です
Miguel Pynto

/^-?\d+$/正しい?
スキマ

36

文字列に数値、任意の数値(整数または浮動小数点)、および正確に数値のみが含まれていることを確認したい場合は、/ 、、またはそれ自体を使用することはできません。注実際に返却されたときに番号を返しますし、それが戻ってくるとき、私は議論の残りの部分から除外されます。parseInt()parseFloat()Number()!isNaN()!isNaN()trueNumber()falseNaN

問題は、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()数値を返すべきではないときに返すすべてのケースで正しいことを行い、逆も同様です。文字列が正確とだけは本当に数であれば見つけるために、両方の機能を呼び出して、彼らがどうかを確認両方のリターン真:

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

2
文字列に先頭または末尾のスペースがある場合、これはtrueを返します。' 1''2 'および' 3 'すべてがtrueを返します。
Rudey 2017

&&!/ ^ \ s + | \ s + $ / g.test(str)
Ultroman the Tacoman

2
@RuudLenders-多くのインターフェースでは、誤って余分なスペースを入れてしまうため、文字列を有効な数字にするために切り捨てられる末尾のスペースがあったとしても、ほとんどの人は気にしません。
Ian

3
数値文字列がユーザー入力からのものである場合も同様です。しかし、isNumber関数を必要とするほとんどの人はユーザーインターフェイスを扱っていないので、とにかくスペースについて言及するべきだと思いました。また、適切な数値入力では、スペースを開始することはできません。
Rudey 2017年

36

この質問に対する受け入れられた回答には、かなりの数の欠陥があります(他のユーザーのカップルによって強調されています)。これは、JavaScriptでアプローチする最も簡単で実績のある方法の1つです。

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

22

isNan関数を試してください。

isNaN()関数は、値が不正な数値(Not-a-Number)かどうかを判別します。

この関数は、値がNaNと等しい場合にtrueを返します。それ以外の場合はfalseを返します。

この関数は、Number固有のNumber.isNaN()メソッドとは異なります。

  グローバルisNaN()関数は、テストされた値を数値に変換してからテストします。

Number.isNan()は値を数値に変換せず、数値タイプではない値に対してtrueを返しません...


2
空の文字列のチェックを必ず追加してください。isNaN( '')はfalseを返しますが、この場合はおそらくtrueを返します。
マイケルハーレン、

3
isFiniteはより良いチェックです。Infinityの奇妙なコーナーケースを扱います
JonnyRaa

3
@MichaelHaren十分ではありません! isNaN()リターンfalseのためのANY「\ u00A0」のようなものを含めだけ空白文字を含む文字列、。
Michael

1
警告:次の値では機能しません:null、 ""(空の文字列)およびfalse。
ジェニー・オライリー2017

この回答は11年前、承認されたものの数分前に与えられたことに気づきましたが、それが好きかどうかは別として、受け入れられた回答にはそれ以上の会話があるため、この回答は質問への回答に実際には何も追加しません。新しい読者の注意をそらさないように、削除することをお勧めします。また、そうすると、規律バッジがもらえると思います。
Dan Dascalescu、

14

古い質問ですが、与えられた回答にはいくつかの点が欠けています。

科学表記。

!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桁に制限します(先行ゼロを省略した後)。

無限

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

しかし、これでも完成には程遠いです。先行ゼロはここでは処理されませんが、長さテストを台無しにします。


1
「しかし、人々が数字を求めるほとんどの場合、彼らは1e + 30のようなものと一致したくないのです」なぜあなたはこれを言うでしょうか?文字列に数字が含まれているかどうかを知りたい場合、文字列に数字が含まれているかどうかを知りたいように思えます。1e+ 30は数字です。確かに、JavaScriptで数値の文字列をテストしている場合は、それを一致させる必要があります。
Dan Jones

9

私はテストしましたが、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、[](およびその他?)の特別な処理


1
これはまだ末尾/先頭のスペースでtrueを返します。&&!/ ^ \ s + | \ s + $ / g.test(str)
Ultroman the Tacoman

2
したがって、「123」は数値ではなくfalseである必要がありますが、「1234」は数値である必要がありますか?私はそれが好きなので、 "123"は数値ですが、先頭または末尾のスペースで値を変更する必要がある場合は、開発者の裁量に任される場合があります。
JohnP2 2017年

8

コンストラクターに引数を渡すときに、Numberの結果を使用できます。

引数(文字列)を数値に変換できない場合は、NaNを返すため、指定した文字列が有効な数値であったかどうかを判断できます。

注:空の文字列を渡す場合'\t\t''\n\t'、Numberが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

Numberコンストラクタはまったく同じです+x
GregRos

注意点として、ES6のことを心に留めておくNumber()のハンドルは、同様の数字をフロートなどNumber.parseFloat()ないNumber.parseInt()
zurfyx

7

たぶん、この質問に出くわして、通常よりもはるかに厳しいチェックが必要な人が1人か2人いるでしょう(私が行ったように)。その場合、これは役に立つかもしれません:

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

注意してください!これは、のような文字列を拒否します.140.00008000.1。これは非常にうるさいです- このテストに合格するには、文字列が数値の「最も最小限の完全な形式」と一致する必要があります。

Stringand Numberコンストラクターを使用して文字列を数値にキャストし、再び戻します。これにより、JavaScriptエンジンの「完全な最小形式」(初期Numberコンストラクターで変換されたもの)が元の文字列と一致するかどうかを確認します。


2
@JoeRoccに感謝します。私もこれが必要でしたが、整数のためだけに追加しました(str === String(Math.round(Number(str))))
keithpjolley

ことに注意してください"Infinity""-Infinity"と、"NaN"このテストに合格。ただし、これは追加のNumber.isFiniteテストを使用して修正できます。
GregRos

これはとまったく同じstr === ("" + +str)です。基本的に、文字列がJS番号を文字列化した結果であるかどうかをチェックします。このことを知って、我々はまた、問題を見ることができます:テストは合格のための0.000001が、ために失敗した0.0000001ときである、1e-7代わりに渡します。非常に大きな数でも同じです。
GregRos 2018


4

見積もり:

isNaN(num)//変数に有効な数値が含まれていない場合はtrueを返します

先頭/末尾のスペースを確認する必要がある場合や、たとえば、特定の桁数が必要で、たとえば、PINの「111」や「111」ではなく「1111」を取得する必要がある場合は、完全に当てはまるわけではありません。入力。

使用するのが良い:

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

'-1''0.1'および'1e10'すべてはfalseを返します。さらに、正の無限大よりも大きい値または負の無限大よりも小さい値はtrueを返しますが、おそらくfalseを返すはずです。
Rudey 2017

4

jQueryの実装が十分でないのはなぜですか?

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

マイケルはこのようなことを提案しました(ここでは「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));
};

ただし、後者のバージョンには2つの新しい変数があります。これらのいずれかを回避するには、次のようにします。

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

私はこれらのどれもあまりテストしていません。現在の苦境に遭遇するいくつかのユースケースを手動でテストする以外の方法では、これらはすべて非常に標準的なものです。これは、「巨人の肩の上に立つ」状況です。


4

TypeScriptでは無効です。

declare function isNaN(number: number): boolean;

TypeScriptの場合、次を使用できます。

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


3

さて、私が作ったこれを使っています...

これまでのところ機能しています:

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

何か問題があったら教えてください。


12
これは、空の文字列、空の配列、false、nullに対して誤った結果をもたらします。
Ori

2
それはトリプルイコールではないでしょうか?
toasted_flakes 2013年

1
私のアプリケーションでは、az AZと0-9文字のみを許可しています。文字列が0xnnで始まっていなければ、上記が機能することがわかりましたが、それが不必要なときに数値として返されます。
rwheadon 2014

6
「戻り値%1 === 0」を実行するだけ
ブライアンシャーマーホーン

Just doreturn !isNaN(parseInt(value, 10));
DarkNeuron

3

誰かがこれまでにこれまでにダウンした場合、私はこれに時間を費やして、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

どんな提案も歓迎します。:]


2
何についてisNumeric(' ')isNumeric('')
Alex Cory 2017年

&& (val.replace(/\s/g,'') !== '') //Empty && (val.slice(-1) !== '.') //Decimal without Number上記の問題と自分が抱えていた問題に対処するために追加します。
frankenapps 2018年


3
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 ...
}

素晴らしい回答ありがとうございます!
M.Abulsoud

3

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」をスキャンすることもできます。

または、それぞれが返す値を確認するには:

<code> isNumeric()</ code>に対する各テストの結果


3

2019:実用的で厳密な数値妥当性チェック

多くの場合、「有効な数」は、NaNと無限大を除くJavascriptの数、つまり「有限数」を意味します。

値の数値の有効性を確認するには(たとえば、外部ソースから)、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');
}

2

PFBは実用的なソリューションです。

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

2

「組み込み」のソリューションを見つけようとする頭痛の種を省いてください。

良い答えはありません、そしてこのスレッドで非常に賛成された答えは間違っています。

npm install is-number

JavaScriptでは、値が数値であるかどうかを確実にチェックする必要があるため、必ずしも簡単ではありません。開発者が+、-、またはNumber()を使用して文字列値を数値にキャストすることは一般的です(たとえば、値がユーザー入力、正規表現一致、パーサーなどから返される場合)。しかし、予期しない結果が生じる直感的でないエッジケースが多数あります。

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

1

私は最近、変数が有効な数値であることを確認する方法についての記事を書きました:https : //github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.mdこの記事では、浮動小数点または整数を確認する方法について説明しています重要(+x~~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
}

1

少し混乱する私の試み、Pherhapsは最良の解決策ではない

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

これは、2頭の悪いことないような(1)科学的表記及び(2)は、ベース10の表記などオクタル(のような任意の非進表記のためのない仕事、あまりにも悪くはない042)および16進数(0x45f
ドミ

これは数値を探すという質問には答えず、intを探すだけです。
ジェレミー

0

私のアプリケーションでは、az AZと0-9文字のみを許可しています。上記の " string%1 === 0" を使用した答えは、文字列が0xnn(0x10など)で始まっていない限り機能し、不要な場合は数値として返されます。私の数値チェックの次の簡単なトラップは、私たちの特定のケースでうまくいくようです。

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)]の長年のバグを悪用している可能性があります。私はそれについて話すことはできませんが、まさに私たちが必要としていたことです。


なぜそれがJavaScriptのバグなのでしょうか?
ベルギ14

私は単にperlまたはCで同様のソリューションを使用して同じ動作を確認していません。私はJavaScriptまたはActionscriptのプログラミング言語開発者ではないので、私が経験している動作が本当に意図的なものかどうかはわかりません。
rwheadon 14

ええと、JavaScriptは暗黙の型キャストについて少しずさんですが、一度理解すれば、それがどのように機能するかを簡単に理解できます。文字列を数値にキャストすると(数値% 1演算を呼び出すことにより)、文字列は16進数または浮動小数点リテラルとして解釈されます。
ベルギ14

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

ループ内に条件を追加して、特定のニーズに合わせることができます。


0

フローライブラリー yのような型を使用して、静的なコンパイル時間チェックを行うことができます。もちろん、ユーザー入力にはそれほど役立ちません。

// @flow

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

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

0

次にsNum、が有効な数値かどうかを確認するためのワンライナーを示します。さまざまな入力に対してテストされています。

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

0

使用するだけでisNaN()、これは文字列を数値に変換し、有効な数値を取得した場合はfalse... を返します。

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

0

私は以下を使用しています:

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

比較的うまく機能することは多くの場合ですが、、、、のような失敗のケースが1..1あり1,1-32.1.12さらに重要なのはundefinedとの失敗NaNです。合格したundefined場合はNaN、それが数値であるとの誤検知が返されます。
ジェレミー
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.