数値が浮動小数点または整数であることを確認するにはどうすればよいですか?


717

どの番号であることを見つけるためにfloatinteger

1.25 --> float  
1 --> integer  
0 --> integer  
0.25 --> float

47
私はあなたがここで何を求めているのか理解しましたが、ただ明確にするために:<nit-pick>JavaScriptには異なる整数型と浮動小数点型はありません。JavaScriptのすべての数値は単なるNumberです。</nit-pick>
マットボール

4
であるInfinityあなたが懸念している限りとして、整数または非整数値は?ここでの答えは、このスコアにかなり均等に分配されます。
マイクサミュエル

11
@MikeSamuel数学的に正確です。無限大は実数ではなく、すべての整数は実数であるためInfinity、整数と見なすことはできません。
rvighne 2014

@rvighne、質問は「実数」ではなく「実数」について尋ねます。どちらにしても、コンピューターは計算可能な数値しか表現できないため、実数は無関係です。
マイクサミュエル

2
@rvighne、私たちは、無限大とNaNが実数ではないという事実は、IEEE-754浮動小数点数が実数のサブセットではないことを意味することに同意します。IEEE-754に基づくすべての数値解析は、この事実に対処する必要があります。私が理解していないのは、この事実がis_integralがカーディナリティに対してどのように動作するかを決定する方法だということです。個人的には、((x%1)== 0)は適切なプロキシであり、IEEE-754によって完全に指定されていると思うので、異なる数の線の間の対応について議論する必要はありません。
マイクサミュエル

回答:


1256

1で割ったときの余りを確認します。

function isInt(n) {
   return n % 1 === 0;
}

引数が数値であることを知らない場合は、2つのテストが必要です。

function isInt(n){
    return Number(n) === n && n % 1 === 0;
}

function isFloat(n){
    return Number(n) === n && n % 1 !== 0;
}

この回答が書かれてから5年後の2019年の更新、ソリューションはECMA Script 2015で標準化されました。そのソリューションはこの回答でカバーされています


138
慎重に、これはまた、空の文字列に対してtrueを返します整数を表す文字列、truefalsenull、空の配列、多分それ以上の単一整数、整数を表す文字列を含む配列、およびを含む配列。
Dagg Nabbit

17
素敵なトリックですが、空の文字列""1.0 isInt("");&&のisInt(1.0);両方のチェックに失敗するため、正解ではありません&& 両方の結果は、trueこのデモを参照してくださいjsbin.com/elohuq/1/edit
Champ

9
いな、===の使用は、一般に==よりも推奨されます。これは、型の安全性が向上し、予測可能で均一な動作になるためです。以前の回答者が述べたように、この回答は完全に100%不正解です。null、空の文字列、1.0などの値はすべて、整数として誤って登録されます(===チェックを使用した場合でも)。
whoblitz 2013

54
問題は、数値が整数かどうかを確認する方法であり、値を確認する方法ではありませんでした。
ケネベック2014年

24
文字列を検証しない方法についての多くの敵意のあるコメント。それはOPの質問の一部ではありません。配列の最後の要素を取得することについて質問するためにSOに行き、誰かがでfunction last (array) { return array[array.length - 1]; }答えた場合、引数が最初に配列であるかどうかをチェックしないため、それは「ただ間違っている」か「SOの最悪の回答」ですか?はい、引数をチェックするのは良い習慣ですが、それは開発者の責任です。SOの回答は短く、できるだけ明確に質問に直接回答する必要があります。
Mミラー

150

これらの関数を試して、値が小数部のないプリミティブな数値であり、正確な整数として表現できるサイズの制限内にあるかどうかをテストします。

function isFloat(n) {
    return n === +n && n !== (n|0);
}

function isInteger(n) {
    return n === +n && n === (n|0);
}

5
非常に優れたエクスプロイトです。これは(n===+n数値をチェックしたり、丸めたりするために)自分のものですn|0が、組み込みの演算子を使用しています。ファンキー
Claudiu

7
@John Hartsock文字列が数値になることは決してありません。文字列です。この関数のポイントは、値が小数部を持たず、正確な整数として表現できるサイズの制限内にあるJavascript数値であるかどうかをテストすることです。文字列に数値を表す文字のシーケンスが含まれているかどうかを確認する場合は、parseFloat()最初に呼び出します。
先のとがった

4
@John Hartsock:数値プリミティブが渡されない限り、trueを返しません。関数の名前を考えると、それは理にかなっていると思います。そのような関数が作成されている場合は、isString、isBooleanなどの候補となる必要があります。
Dagg Nabbit、

4
@Pointy:倍精度浮動小数点数は、2 ^ 53までの整数値を表すことができます。つまり、OPが数学の意味(整数)または32ビットのデータの意味で整数について尋ねていたかどうかによって異なります。後者の場合、ソリューションは完璧です。
djd

8
JavaScriptでは、|(OR)のようなビット演算子は、符号付き32ビット整数でのみ動作します。OPは、目標が符号付きint32値をチェックすることであるかどうかを述べていません。したがって、これは範囲外の数値では機能しません。間違っているものisInteger(5000000000)を返しfalseます!
OnurYıldırım2015年

93

なぜこのようなものではないのですか?

var isInt = function(n) { return parseInt(n) === n };

これは実際に私にとって良い解決策の中核です。正の整数を許可し、浮動小数点数、文字列、負の整数を禁止する必要がありました。
Imran-UK

4
これは、このスレッドの他のソリューションよりもはるかに優れたソリューションのようです。コミュニティは、おそらくいくつかの批判を提供できますか?
スビチェンコ2014

5
変数y = 1.00; y === parseInt(y、10); //これは私にとってtrueを返しますが、これは私たちが本当に望んでいることではありません。
whoughton 2014年

私が目にする唯一の「欠点」は、指定nされた数値がによって文字列に変換されることparseIntです。MDNを参照してください。しかし、私はこのソリューションを使用します。:)
RhinoDevel 2015年

2
@ekussberg:なぜfalseを返す必要があるのですか?1はintです。2番目の引数である02は無視されます。
Flimzy 2016

88

と呼ばれるメソッドがあり、Number.isInteger()現在IE以外のすべてに実装されています。MDNは他のブラウザにもポリフィルを提供します:

Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' && 
    isFinite(value) && 
    Math.floor(value) === value;
};

ただし、ほとんどの使用例ではNumber.isSafeInteger 、値が高すぎたり低すぎたりして小数位が失われるかどうかもチェックすることをお勧めします。MDNにもこのためのポリフィルがあります。(isInteger上記のpollyfill も必要です。)

if (!Number.MAX_SAFE_INTEGER) {
    Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
}
Number.isSafeInteger = Number.isSafeInteger || function (value) {
   return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};

これは私のChromeでも機能し、おそらく将来の
道のり

1
私の意見では、最良の解決策です。
Automatico、

1
ポリフィルを使用したこれは、最も信頼性が高く、シンプルなソリューションです。
Francesco Pasa

2
@SergeyPanfilov 12.0 ∈ ℤ
КонстантинВан

1
この回答が提供されてから仕様が変更されたかどうかはわかりませんが、上記の関数はの正しいポリフィルではないことに注意してくださいNumber.isInteger。ただし、の正しいポリフィルですNumber.isSafeIntegerNumber.isInteger数値が「安全な整数」であるかどうかをチェックしないでください。MDN:isIntegerおよびisSafeIntegerを参照してください。
nunocastromartins

33

単純な正規表現を使用できます。

function isInt(value) {

    var er = /^-?[0-9]+$/;

    return er.test(value);
}

または、必要に応じて、以下の関数も使用できます。それらはPHPJSプロジェクトによって開発されました。

is_int() =>変数の型が整数かどうか、およびその内容が整数かどうかを確認します

is_float() =>変数の型が浮動小数点かどうか、およびその内容が浮動小数点かどうかを確認します

ctype_digit() =>変数の型が文字列であり、その内容が10進数のみであるかどうかを確認します

アップデート1

@ChrisBartleyコメントに感謝します


1
単純な符号なし整数のテストに最適です。
tothemario 2014

7
1つのライナー:/^[0-9]+$/.test(String(value))
tothemario 2014

短くて少し読みにくいワンライナー:/^[0-9]+$/.test(''+value)
skeggse

3
負の整数を処理しません。test()はブール値を返すため、三項演算子も必要ありません。これはそれを行う必要があります:return /^-?\d+$/.test(String(value));
クリス・バートリー

@ChrisBartley、ありがとう!クレジットを含めて更新しました。すべて問題ないか確認してください。
Marcio Mazzucato 2014

19

値が数値であるか、数値に安全に変換できるかどうかをチェックする効率的な関数を次に示します。

function isNumber(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    if (typeof value == 'number') {
        return true;
    }
    return !isNaN(value - 0);
}

そして整数の場合(値が浮動小数点の場合はfalseを返します):

function isInteger(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    return value % 1 == 0;
}

ここでの効率は、値がすでに数値の場合、parseInt(またはparseNumber)が回避されることです。両方の解析関数は常に最初に文字列に変換してから、その文字列を解析しようとしますが、値がすでに数値である場合、これは無駄になります。

最適化のためのさらなるアイデアを提供してくれたここの他の投稿に感謝します!


3
この関数は空の文字列では失敗します。isNumber( '')はtrueです。
Jason Grout 2013

14
function isInteger(x) { return typeof x === "number" && isFinite(x) && Math.floor(x) === x; }
function isFloat(x) { return !!(x % 1); }

// give it a spin

isInteger(1.0);        // true
isFloat(1.0);          // false
isFloat(1.2);          // true
isInteger(1.2);        // false
isFloat(1);            // false
isInteger(1);          // true    
isFloat(2e+2);         // false
isInteger(2e+2);       // true
isFloat('1');          // false
isInteger('1');        // false
isFloat(NaN);          // false
isInteger(NaN);        // false
isFloat(null);         // false
isInteger(null);       // false
isFloat(undefined);    // false
isInteger(undefined);  // false

4
どうやら、.0で終わるフロートはJavaScriptで自動的にIntにキャストされます。

で失敗しました1.2。常に0.1 0.2 0.3で数値関数をテストします
Lukas Liesis

@LukasLiesisは私には向かない。
doubleOrt 2017年

ここでは厳密な等価演算子は必要ありません。
doubleOrt 2017年

isFloat(1563457121531)はfalseを返します
Aalex Gabi

9
function isInt(n) 
{
    return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
    return n != "" && !isNaN(n) && Math.round(n) != n;
}

すべてのケースで機能します。


2
+1これは良いです。期待通りにisInt('1')戻りますtrue(少なくとも私にとって)。奇妙なことに、これもまた戻っtrueてきisInt([5])ます。私にとっては問題ではありませんでしたが、あなたのためかもしれません。
acdcjunior 2013

2
isFloat(12.0)はfalse
django

6

他の人が述べたように、あなたはJSでダブルスしか持っていません。それでは、数値を整数としてどのように定義しますか?丸められた数がそれ自体と等しいかどうかを確認してください:

function isInteger(f) {
    return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }

3
値が数値であることを確認したい場合があります... isFloat('abc')戻り値true
Dagg Nabbit

isFloat(NaN) // true
shime 2014年

@shime:良いキャッチ。NaNは技術的には浮動小数点数ですが...
Claudiu 2014年


5

これが私が整数に使用するものです:

Math.ceil(parseFloat(val)) === val

短くて素敵です:)いつでも動作します。これは、私が間違っていない場合、David Flanaganが提案するものです。


これは、暗号化されたビット単位の演算に依存しない、短く単純な答えであるため、これが好きです。
ジム

なんでparseFloat
doubleOrt 2017年

4

それは本当にあなたが達成したいことに依存します。強く型付けされた言語を「エミュレート」したい場合は、試さないことをお勧めします。他の人が言及したように、すべての数値は同じ表現(同じ型)を持っています。

以下のようなものを使用してクラウディウが提供:

isInteger( 1.0 ) ->正しい

常識的には問題ありませんが、Cのようなものでは false


4

小数部がゼロの浮動小数点数(たとえば、1.0、12.00、0.0)は暗黙的に整数にキャストされるため、浮動小数点かどうかを確認することはできません。



3

それほど複雑である必要はありません。整数のparseFloat()とparseInt()の同等の数値は同じになります。したがって、あなたはそうすることができます:

function isInt(value){ 
    return (parseFloat(value) == parseInt(value)) && !isNaN(value);
}

その後

if (isInt(x)) // do work

これは文字列チェックも可能にするため、厳密ではありません。強力な型ソリューションが必要な場合(別名、文字列では機能しません):

function is_int(value){ return !isNaN(parseInt(value * 1) }

isInteger(12.0)はtrue
django

3
var isInt = function (n) { return n === (n | 0); };

これでうまくいかないケースはありませんでした。


なぜこれがfalseを返すのですか?console.log(isInt(7932938942839482938));
itsme 14

4
それはMaxIntを超えているからです。
ankr

Int max length nopeを設定できますか?intの長さが返されない場合はどうなりますか?
itme 14

1
@ekussbergはい。これ2はが整数であり23、関数の2番目の引数と見なされるためです。JavaScriptでは、小数点は区切り記号としてドットを使用して記述されているため、そうする必要があります2.23
ankr 2016年

1
または、ビット単位の操作について学ぶ絶好の機会です。あなたはそれからこれから多くの利益を得るでしょう。
ankr

2

これは、INTとFLOATの両方をチェックするための最終的なコードです

function isInt(n) { 
   if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
       return true;
   } else {
       return false;
   }
} 

または

function isInt(n) {   
   return typeof n == 'number' && Math.Round(n) % 1 == 0;   
}   

これは、nが偶然に数値である場合にのみ浮動小数点をテストします
hacklikecrack

2
function isInteger(n) {
   return ((typeof n==='number')&&(n%1===0));
}

function isFloat(n) {
   return ((typeof n==='number')&&(n%1!==0));
}

function isNumber(n) {
   return (typeof n==='number');
}

整数は浮動小数点数ではありませんか?私へのニュース。
Maarten Bodewes 2014年

2

それは次のように簡単です:

if( n === parseInt(n) ) ...

コンソールでこれを試してください:

x=1;
x===parseInt(x); // true
x="1";
x===parseInt(x); // false
x=1.1;
x===parseInt(x); // false, obviously

// BUT!

x=1.0;
x===parseInt(x); // true, because 1.0 is NOT a float!

これは多くの人々を混乱させます。何かが.0であるときはいつでも、それはもうフロートではありません。整数です。または、Cの当時のような厳密な区別がないため、単に「数値」と呼ぶことができます。古き良き時代。

したがって、基本的には、1.000が整数であるという事実を受け入れて整数をチェックするだけです。

興味深いサイドノート

膨大な数についてのコメントがありました。巨大な数値は、このアプローチでは問題がないことを意味します。parseIntが数値を処理できない場合(数値が大きすぎるため)、実際の値以外の値が返されるため、テストはFALSEを返します。これは良いことです。何か「数値」を考える場合、通常はJSがそれを使って計算できると期待するからです。そうです、数値は制限されており、parseIntはこれを考慮に入れて、このように表現します。

これを試して:

<script>

var a = 99999999999999999999;
var b = 999999999999999999999; // just one more 9 will kill the show!
var aIsInteger = (a===parseInt(a))?"a is ok":"a fails";
var bIsInteger = (b===parseInt(b))?"b is ok":"b fails";
alert(aIsInteger+"; "+bIsInteger);

</script>

私のブラウザー(IE8)では、これは "a is ok; b fail"を返します。これは、bの数が非常に多いためです。制限は異なる場合がありますが、古典を引用するには、20桁で「だれでも十分なはずです」と思います。


(数学POVからの)整数のみをチェックする必要がある場合、これは問題ありませんが、(計算POVからの)整数のように実際に機能することを確認したい場合は、巨大な数値に対しては正しくありません。このコメントを参照してください。
Dagg Nabbit、2014

うーん…どうしてそう思うの?つまり、parseIntが何かを返し、それが変数自体に等しいと思われる場合、nが本当に整数として機能することを確認できます。99999999999999999999(つまり、 "9"の20倍)は数値であり、 "9"を1つ追加するとparseIntが失敗する(1を返す)ことがわかりました。ブラウザに依存する場合があります。ただし、はい、制限があり、いいえ、その制限から外れているものは、上記のチェックではtrueを返しません。
dkellner 14

つまり、ビット単位の演算子(数値を32ビットの整数として扱う)は、32ビットの整数として表現できない数値に対して期待される結果を与えないため、これらの数値を整数として識別すべきではありません。これは、提案されたNumber.isInteger仕組みと一致しています。
Dagg Nabbit、2014

特定の方法で保存されなくても、何かが真の整数になる場合があります。おっしゃるとおりですが、整数は小数部分を持たないため整数であり、浮動小数点のような結果を得ることなく任意に加算/減算できます。数値をビットフィールドとして扱う場合、それらがどのように格納されているかを推測していることになります-私の意見では-実際には機能しますが、100%信頼できる方法ではありません。「特定の方法で格納された整数」を探しているのであれば、すべてのプラットフォームで安全に使用できる単一行のテストがあるかどうかはわかりません。
dkellner 2014

32ビット整数として表現できる数値は、ビット単位の演算子で100%確実に機能します。あなたは「それらがどのように保存されているかについて何も考えていない」わけではありません。仕様に従って、数値は符号付き32ビットビッグエンディアンの2の補数の整数に変換されます。この形式で表現できない数値は、整数と見なすべきではありません。繰り返しますが、これはNumber.isInteger動作方法と一致しています。単一行のテストはn === (n | 0)、別の回答に示されています。
Dagg Nabbit、2014

2

この解決策は私にとってうまくいきました。

<html>
<body>
  <form method="post" action="#">
    <input type="text" id="number_id"/>
    <input type="submit" value="send"/>
  </form>
  <p id="message"></p>
  <script>
    var flt=document.getElementById("number_id").value;
    if(isNaN(flt)==false && Number.isInteger(flt)==false)
    {
     document.getElementById("message").innerHTML="the number_id is a float ";
    }
   else 
   {
     document.getElementById("message").innerHTML="the number_id is a Integer";
   }
  </script>
</body>
</html>

1

整数の場合、これを使用します

function integer_or_null(value) {
    if ((undefined === value) || (null === value)) {
        return null;
    }
    if(value % 1 != 0) {
        return null;
    }
    return value;
}

1

Javaスクリプトではinternally 64 bit floating point、すべての数値はであり、Javaのdoubleと同じです。JavaScriptには異なるタイプはなく、すべてtypeで表されnumberます。したがって、instanceofチェックを行うことができません。ただし、uは、上記の解を使用して、小数かどうかを確認できます。Javaスクリプトの設計者は、単一の型で感じたので、多数の型キャストエラーを回避できます。


1

Numberオブジェクトでは、直接mod演算子(%)を使用できない場合があります。その場合は、このソリューションを使用できます。

if(object instanceof Number ){
   if( ((Number) object).doubleValue() % 1 == 0 ){
      //your object is an integer
   }
   else{
      //your object is a double
   }
}

1

ここでいくつかの答えを試して、私はこの解決策を書きました。これは、文字列内の数値でも機能します。

function isInt(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return !(number - parseInt(number));
}

function isFloat(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return number - parseInt(number) ? true : false;
}

    var tests = {
        'integer' : 1,
        'float' : 1.1,
        'integerInString' : '5',
        'floatInString' : '5.5',
        'negativeInt' : -345,
        'negativeFloat' : -34.98,
        'negativeIntString' : '-45',
        'negativeFloatString' : '-23.09',
        'notValidFalse' : false,
        'notValidTrue' : true,
        'notValidString' : '45lorem',
        'notValidStringFloat' : '4.5lorem',
        'notValidNan' : NaN,
        'notValidObj' : {},
        'notValidArr' : [1,2],
    };

    function isInt(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return !(number - parseInt(number));
    }
    
    function isFloat(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return number - parseInt(number) ? true : false;
    }

    function testFunctions(obj) {
        var keys = Object.keys(obj);
        var values = Object.values(obj);

        values.forEach(function(element, index){
            console.log(`Is ${keys[index]} (${element}) var an integer? ${isInt(element)}`);
            console.log(`Is ${keys[index]} (${element}) var a float? ${isFloat(element)}`);
        });
    }

    testFunctions(tests);


0

これは、おそらく%の回答ほどパフォーマンスが良くないため、最初に文字列に変換する必要はありませんが、まだ誰も投稿していないので、正常に機能する別のオプションを次に示します。

function isInteger(num) {
    return num.toString().indexOf('.') === -1;
}

グッドアプローチ
IMHO

ES6メソッドのcontains()によってこの答えがさらに簡単になることを付け加えます
Axle

0

これらの好奇心が強い人のために、Benchmark.jsを使用して、この投稿で最も投票された回答(および今日投稿された回答)をテストしました。これが私の結果です。

var n = -10.4375892034758293405790;
var suite = new Benchmark.Suite;
suite
    // kennebec
    .add('0', function() {
        return n % 1 == 0;
    })
    // kennebec
    .add('1', function() {
        return typeof n === 'number' && n % 1 == 0;
    })
    // kennebec
    .add('2', function() {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    })

    // Axle
    .add('3', function() {
        return n.toString().indexOf('.') === -1;
    })

    // Dagg Nabbit
    .add('4', function() {
        return n === +n && n === (n|0);
    })

    // warfares
    .add('5', function() {
        return parseInt(n) === n;
    })

    // Marcio Simao
    .add('6', function() {
        return /^-?[0-9]+$/.test(n.toString());
    })

    // Tal Liron
    .add('7', function() {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    });

// Define logs and Run
suite.on('cycle', function(event) {
    console.log(String(event.target));
}).on('complete', function() {
    console.log('Fastest is ' + this.filter('fastest').pluck('name'));
}).run({ 'async': true });

0 x 12,832,357 ops/sec ±0.65% (90 runs sampled)
1 x 12,916,439 ops/sec ±0.62% (95 runs sampled)
2 x 2,776,583 ops/sec ±0.93% (92 runs sampled)
3 x 10,345,379 ops/sec ±0.49% (97 runs sampled)
4 x 53,766,106 ops/sec ±0.66% (93 runs sampled)
5 x 26,514,109 ops/sec ±2.72% (93 runs sampled)
6 x 10,146,270 ops/sec ±2.54% (90 runs sampled)
7 x 60,353,419 ops/sec ±0.35% (97 runs sampled)

Fastest is 7 Tal Liron

0

これが私のコードです。空の文字列(そうでない場合は渡されます)ではないことを確認してから、数値形式に変換します。ここで、「1.1」を1.1に等しくしたいかどうかに応じて、これが探しているものである場合とそうでない場合があります。

var isFloat = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseFloat(n));
};
var isInteger = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseInt(n));
};

var isNumeric = function(n){

   if(isInteger(n) || isFloat(n)){
        return true;
   }
   return false;

};

0

正と負の両方の整数に対してtrueを返すこの小さな関数が好きです。

function isInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
}

これは、1または "1"が "1.0"になり、isNaN()がfalseを返す(その後、否定して返す)ためですが、1.0または "1.0"は "1.0.0"になり、 "string"は "string"になります。 0、どちらも数値ではないため、isNaN()はfalseを返します(ここでも否定されます)。

正の整数のみが必要な場合は、次のバリアントがあります。

function isPositiveInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}

または、負の整数の場合:

function isNegativeInt(val) {
    return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
}

isPositiveInt()は、連結された数値文字列をテストする値の前に移動することで機能します。たとえば、isPositiveInt(1)の結果、isNaN()は「01」を評価し、falseと評価されます。一方、isPositiveInt(-1)はisNaN()が「0-1」を評価し、trueと評価されます。戻り値を無効にします。これにより、必要なものが得られます。isNegativeInt()も同様に機能しますが、isNaN()の戻り値を否定しません。

編集:

私の元の実装は、配列と空の文字列に対してもtrueを返します。この実装にはその欠陥はありません。また、valが文字列または数値ではない場合、または空の文字列である場合に早期に戻るという利点があり、これらの場合により速くなります。最初の2つの句を次のように置き換えることで、さらに変更できます。

typeof(val) != "number"

(文字列ではなく)リテラル数値のみを一致させたい場合

編集:

まだコメントを投稿できないので、これを回答に追加します。@Asokが投稿したベンチマークは非常に有益です。ただし、最も高速な関数は、浮動小数点数、配列、ブール値、および空の文字列に対してTRUEを返すため、要件に適合しません。

各関数をテストするために次のテストスイートを作成し、私の回答もリストに追加しました(文字列を解析する関数8とそうでない関数9)。

funcs = [
    function(n) {
        return n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    },
    function(n) {
        return n.toString().indexOf('.') === -1;
    },
    function(n) {
        return n === +n && n === (n|0);
    },
    function(n) {
        return parseInt(n) === n;
    },
    function(n) {
        return /^-?[0-9]+$/.test(n.toString());
    },
    function(n) {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    },
    function(n) {
        return ["string","number"].indexOf(typeof(n)) > -1 && n !== '' && !isNaN(n+".0");
    }
];
vals = [
    [1,true],
    [-1,true],
    [1.1,false],
    [-1.1,false],
    [[],false],
    [{},false],
    [true,false],
    [false,false],
    [null,false],
    ["",false],
    ["a",false],
    ["1",null],
    ["-1",null],
    ["1.1",null],
    ["-1.1",null]
];

for (var i in funcs) {
    var pass = true;
    console.log("Testing function "+i);
    for (var ii in vals) {
        var n = vals[ii][0];
        var ns;
        if (n === null) {
            ns = n+"";
        } else {
            switch (typeof(n)) {
                case "string":
                    ns = "'" + n + "'";
                    break;
                case "object":
                    ns = Object.prototype.toString.call(n);
                    break;
                default:
                    ns = n;
            }
            ns = "("+typeof(n)+") "+ns;
        }

        var x = vals[ii][1];
        var xs;
        if (x === null) {
            xs = "(ANY)";
        } else {
            switch (typeof(x)) {
                case "string":
                    xs = "'" + n + "'";
                    break;
                case "object":
                    xs = Object.prototype.toString.call(x);
                    break;
                default:
                    xs = x;
            }
            xs = "("+typeof(x)+") "+xs;
        }

        var rms;
        try {
            var r = funcs[i](n);
            var rs;
            if (r === null) {
                rs = r+"";
            } else {
                switch (typeof(r)) {
                    case "string":
                        rs = "'" + r + "'";
                        break;
                    case "object":
                        rs = Object.prototype.toString.call(r);
                        break;
                    default:
                        rs = r;
                }
                rs = "("+typeof(r)+") "+rs;
            }

            var m;
            var ms;
            if (x === null) {
                m = true;
                ms = "N/A";
            } else if (typeof(x) == 'object') {
                m = (xs === rs);
                ms = m;
            } else {
                m = (x === r);
                ms = m;
            }
            if (!m) {
                pass = false;
            }
            rms = "Result: "+rs+", Match: "+ms;
        } catch (e) {
            rms = "Test skipped; function threw exception!"
        }

        console.log("    Value: "+ns+", Expect: "+xs+", "+rms);
    }
    console.log(pass ? "PASS!" : "FAIL!");
}

また、リストに関数#8を追加してベンチマークを再実行しました。少し恥ずかしいので、結果を投稿しません(たとえば、その機能は速くありません)...

(要約-出力が非常に長いため、成功したテストを削除しました)結果は次のとおりです。

Testing function 0
Value: (object) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 1
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 2
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 3
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) 'a', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 4
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 5
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 6
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 7
Value: (number) 1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (number) -1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
FAIL!

Testing function 8
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 9
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

各関数がどこで失敗しているかを確認できるように失敗し、(文字列) '#'テストを実行すると、各関数が文字列内の整数値と浮動小数点値をどのように処理するかを確認できます。ではないかもしれない。

テストされた10個の関数のうち、実際にOPの要件に適合するのは[1,3,5,6,8,9]です。


0

フローティング検証の条件:

if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0)) 

整数検証の条件:

if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0)) 

これがお役に立てば幸いです。


0
function int(a) {
  return a - a === 0 && a.toString(32).indexOf('.') === -1
}

function float(a) {
  return a - a === 0 && a.toString(32).indexOf('.') !== -1
}

typeof a === 'number'文字列を除外する場合は追加できます。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.