JavaScriptで変数が整数かどうかを確認するにはどうすればよいですか？

405

JavaScriptで変数が整数であるかどうかを確認し、そうでない場合はアラートをスローするにはどうすればよいですか？私はこれを試しましたが、うまくいきません：

<html>
    <head>
        <script type="text/javascript">
            var data = 22;
            alert(NaN(data));
        </script>
    </head>
</html>
javascript 
— JBa
ソース
2
ここで1つの可能性は、を使用することparseIntです。
— Paul
2
jsben.ch/#/htLVw-それを行う一般的な方法のベンチマーク
— EscapeNetscape
ここでのすべての答えは本当に時代遅れです。今日、私Number.isIntegerはどちらにこだわるのが最も難しい方法に固執することをお勧めします。
— Benjamin Gruenbaum
@Benjamim数値が整数に変換できる文字列である場合はどうなりますか？HTMLでは、すべてが文字列です。したがって、Number.isInteger（ "69"）はfalseです
— joedotnot

回答:

344

以下のように===演算子（厳密な等価）を使用します。

if (data === parseInt(data, 10))
    alert("data is integer")
else
    alert("data is not an integer")
— プラナグ
ソース
95
これはNaNを整数としてカウントします。また、私の方法に対してパフォーマンスが低下します。jsperf.com/numbers-and-integers
— Blake Regalia
2
上記のコードで例を実行すると、aが整数として、もう一方が整数ではないことが警告されます。NaNの場合、NaNのタイプは、pareIntの戻り値のタイプとは異なります。 （）.....
— プラナグ2013
1
もう少し詳しく説明してもらえますか？「例」は、parseIntを使用すると、typeofキーワードとモジュラス演算子を使用する場合よりもパフォーマンスが低下することを示しています。（NaN！= NaN）の現在の意味がわかります
— Blake Regalia
4
JavaScriptの@connorbodeはすべての数値が同じ型（floatまたはdoubleはありません）である2.0 === 2ため、不要な小数は同じ数値の異なる表現にすぎないため、true parseInt(2.0) === 2.0と同等parseInt(2) === 2です
— Michael Theriot
1
@BlakeRegalia：高速ですが、彼の方法はこの回答からすべての可能な値を渡しません：stackoverflow.com/a/14794066/843732
— c00000fd
506

それもまた、文字列を潜在的な整数としてキャストしたいですか？

これは行います：

function isInt(value) {
  return !isNaN(value) && 
         parseInt(Number(value)) == value && 
         !isNaN(parseInt(value, 10));
}

ビットごとの操作

単純な解析とチェック

function isInt(value) {
  var x = parseFloat(value);
  return !isNaN(value) && (x | 0) === x;
}

短絡し、解析操作を保存します。

function isInt(value) {
  if (isNaN(value)) {
    return false;
  }
  var x = parseFloat(value);
  return (x | 0) === x;
}

またはおそらく両方を一度に：

function isInt(value) {
  return !isNaN(value) && (function(x) { return (x | 0) === x; })(parseFloat(value))
}

テスト：

isInt(42)        // true
isInt("42")      // true
isInt(4e2)       // true
isInt("4e2")     // true
isInt(" 1 ")     // true
isInt("")        // false
isInt("  ")      // false
isInt(42.1)      // false
isInt("1a")      // false
isInt("4e2a")    // false
isInt(null)      // false
isInt(undefined) // false
isInt(NaN)       // false

ここにフィドルがあります：http : //jsfiddle.net/opfyrqwp/28/

パフォーマンス

テストの結果、短絡ソリューションが最高のパフォーマンス（ops / sec）を持っていることがわかりました。

// Short-circuiting, and saving a parse operation
function isInt(value) {
  var x;
  if (isNaN(value)) {
    return false;
  }
  x = parseFloat(value);
  return (x | 0) === x;
}

ここにベンチマークがあります：http : //jsben.ch/#/htLVw

短くて鈍い形の短絡回路が好きな場合：

function isInt(value) {
  var x;
  return isNaN(value) ? !1 : (x = parseFloat(value), (0 | x) === x);
}

もちろん、私はミニファイアにそれを任せることをお勧めします。

— クリスク
ソース
4
@krisk-複数のソリューションに賛成。また、提供された4つのバリアントjsperf.com/tfm-is-integerに対してクイックテストを実行し、短絡ソリューションが最高のパフォーマンスを発揮することを確認しました。
— tfmontague、2015年
1
2099999999999999にfalseを返します：- （
— jkucharovic
1
@jkucharovicビットごとのOR演算子が原因です。非ビットワイズバージョンを使用すると、trueが返されます。
— krisk
1
これは「2」になります。真と評価
— cyberwombat 2017年
1
進数2.0である@cyberwombatウェル:-)
— クバBeránek
120

問題の変数について何も知らないと仮定すると、このアプローチをとるべきです：

if(typeof data === 'number') {
    var remainder = (data % 1);
    if(remainder === 0) {
        // yes, it is an integer
    }
    else if(isNaN(remainder)) {
        // no, data is either: NaN, Infinity, or -Infinity
    }
    else {
        // no, it is a float (still a number though)
    }
}
else {
    // no way, it is not even a number
}

簡単に言えば：

if(typeof data==='number' && (data%1)===0) {
    // data is an integer
}
— ブレイクレガリア
ソース
8
どういう意味ですか？これは、JavaScriptのデータ型をチェックし"1.0"、文字列であるため、数値ではありません。それ以外の場合、この1ようvar my_var=1.0;に設定すると、変数の値になります。これは、この関数によって整数として正しく識別されます。
— ブレイクレガリア2014
4
まもなく、Number.isInteger()動作します...それまでは、これは良い方法です
— Claudiu
Number.isIntegerは動作しません。私は何か間違ったことをしているに違いありません。ブレイクのソリューション％1は完全に機能します。
— mcmacerson 2017
104

Number.isInteger() 行く方法のようです。

MDNはNumber.isInteger()、主にすべてのバージョンのIEをサポートしていないブラウザに対して、次のポリフィルも提供しています。

MDNページへのリンク

Number.isInteger = Number.isInteger || function(value) {
    return typeof value === "number" && 
           isFinite(value) && 
           Math.floor(value) === value;
};
— ウォルターロマン
ソース
2
MDNは9007199254740992のテストを削除しました
— BernhardDöbler'30
2
これは最も簡単で「正しい」答えです。つまり、JavaScriptにはすでに整数性をチェックするメソッドがあります。新しいものを書く必要はありません。isNaN（）は整数かどうかではなく、数値かどうかをテストします。
— Globewalldesk
66

数に余りがあるかどうかを確認できます。

var data = 22;

if(data % 1 === 0){
   // yes it's an integer.
}

あなたの入力がテキストである可能性があり、最初にそれがそうでないことを確認したいなら、あなたはタイプを最初に確認することができます：

var data = 22;

if(typeof data === 'number'){
     // yes it is numeric

    if(data % 1 === 0){
       // yes it's an integer.
    }
}
— いや
ソース
3
@Erwinus：0 % 1 === 0コンソールで実行します 。返品trueとして0 % 1返品0。
— いいえ、2013年
IEで試してみてください;-)
— Codebeat 2013年
1
@Erwinus：IE9、IE8、IE7互換モードで0 % 1戻り0ます。
— 2013年
本物の古いIEでそれを試してください。それに加えて、ゼロをチェックし、ブラウザに依存せずに何をすべきかをプログラミングするのは常に良い方法です。
— コードビート2013年
62
@アーウィナス：事実を混同していると思います。ゼロ除算エラーは、ゼロを数値で除算したときではなく、ゼロで除算したときに発生します。IEのバージョンとは何の関係もありません。
— いいえ、2013年
15

まず第一に、NaNは「数」（奇妙なことだとわかっているので、それを転がしてください）であり、「関数」ではありません。

変数のタイプが数値の場合は両方をチェックする必要があり、整数をチェックする場合は係数を使用します。

alert(typeof data === 'number' && data%1 == 0);
— フィル
ソース
2
する必要があります：alert（typeof data == 'number' &&（data == 0 || data％1 == 0））; ゼロによる除算を避けるため。
— コードビート2013年
19
@Erwinus 0％1は、依然として1で除算されます
— Phil
@Philは(0 == 0 || 0 % 1 == 0)に評価されtrueます。
— tomekwi 2015年
あ、ちなみに0 % 1 == 0評価もtrue！%除算ではありません！
— tomekwi 2015年
13

使用中は注意してください

数値％1

空の文字列（ ''）またはブール値（trueまたはfalse）は整数として返されます。あなたはそれをしたくないかもしれません

false % 1 // true
'' % 1 //true

Number.isInteger（data）

Number.isInteger(22); //true
Number.isInteger(22.2); //false
Number.isInteger('22'); //false

ブラウザーで機能を組み込みます。古いブラウザをサポートしない

代替案：

Math.round(num)=== num

ただし、Math.round（）も空の文字列とブール値では失敗します

— ジャンカー・マブブ
ソース
8

ポスターのような整数が必要かどうかを確認するには：

if (+data===parseInt(data)) {return true} else {return false}

データの前に+があることに注意してください（文字列を数値に変換します）。

次に例を示します。

data=10
+data===parseInt(data)
true

data="10"
+data===parseInt(data)
true

data="10.2"
+data===parseInt(data)
false
— ユーザー603749
ソース
6
これは私の場合（文字列内の整数であっても構わない）の場合、最も賢い解決策のようです。しかし、なぜ行くだけではないのreturn (+data===parseInt(data))ですか？
— スイスミスター
6

最も単純で最もクリーンなECMAScript 6以前のソリューション（文字列やnullなどの非数値が関数に渡された場合でもfalseを返すのに十分堅牢なもの）は次のようになります。

function isInteger(x) { return (x^0) === x; }

上記のソリューションほどエレガントではありませんが、次のソリューションも機能します。

function isInteger(x) { return Math.round(x) === x; }

上記の実装では、Math.ceil（）またはMath.floor（）を（Math.round（）の代わりに）同様に使用できることに注意してください。

または代わりに：

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

かなり一般的な不正解の1つは次のとおりです。

function isInteger(x) { return parseInt(x, 10) === x; }

このparseIntベースのアプローチはxの多くの値でうまく機能しますが、xがかなり大きくなると、正しく機能しなくなります。問題は、parseInt（）が数字を解析する前に最初のパラメーターを文字列に強制変換することです。したがって、数値が十分に大きくなると、その文字列表現は指数形式（1e + 21など）で表示されます。したがって、parseInt（）は1e + 21を解析しようとしますが、e文字に到達すると解析を停止し、値1を返します。

> String(1000000000000000000000)
'1e+21'

> parseInt(1000000000000000000000, 10)
1

> parseInt(1000000000000000000000, 10) === 1000000000000000000000
false
— アルセンアレクサンヤン
ソース
6

誰も言及しなかった理由 Number.isInteger()ですか？

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger

私にとって完璧に機能し、NaN最初の数で問題を解決します。

— 夜
ソース
1
これはES6であるため、古いブラウザ（IE <= 11など）ではサポートされていません。上記のドキュメントはポリフィルを提供します。
— ビショップ
Number.isInteger()3.5年前に誰かが言及しました：stackoverflow.com/a/27424770/5208540
— Alex Stragies
私たちは入力から値をキャッチしようとしているかどうかを確認、入力値が文字列データ型であるとして、その後、Number.isIntegerは常にfalseを返します
— Shinigamae
6

ES6では、Number Objectに新しいメソッドが追加されています。

その中で、引数が整数の場合、Number.isInteger（）メソッドはtrueを返します。

使用例：

Number.isInteger(10);        // returns true
Number.isInteger(10.5);      // returns false
— アルン・ジョシュラ
ソース
4

ECMA-262 6.0（ES6）標準にはNumber.isIntegerが含まれます関数がます。

古いブラウザーのサポートを追加するために、コミュニティからサポートされている強力なソリューションを使用することを強くお勧めします。

https://github.com/paulmillr/es6-shim

純粋なES6 JSポリフィルライブラリですです。

このlibにはes5-shimが必要です。README.mdに従ってください。

— ジヴェンコア
ソース
4

たとえば、文字列形式の整数であるNumber.isInteger(Number(value))かどうvalueかを試して、var value = "23"これをに評価することもできますtrue。Number.isInteger(parseInt(value))これは常に正しい値を返すとは限らないため、試してはいけません。たとえばvar value = "23abc"、あなたが使用する場合parseInt実装 trueが返されます。

しかし、厳密に整数値がNumber.isInteger(value)必要な場合は、おそらくトリックを実行する必要があります。

— gbozee
ソース
1
これはIEではサポートされていないことに注意してください。述べたように ドキュメンタリーで、ここで私は私のスクリップは、あなたがチェックしているVARが定義されていない場合は特にこのために停止してしまった
— mikewasmike
4 
var x = 1.5;
if(!isNaN(x)){
 console.log('Number');
 if(x % 1 == 0){
   console.log('Integer');
 }
}else {
 console.log('not a number');
}
— Hemant
ソース
3
29の回答の後、あなたの回答を際立たせるためのもう少しの説明が期待されます...
— ブラソフィロ
3

次のように、変数が整数に丸められた同じ変数と等しいかどうかを確認します。

if(Math.round(data) != data) {
    alert("Variable is not an integer!");
}
— エリオット・ボンネビル
ソース
ブロックに変更して反転するだけtrueでNaN、この関数のforの戻りに関する問題を非常に簡単に修正できます。これが機能するのは、それ自体が等しくないJavaScriptの唯一の値だからです。たとえば、新しいコードは!=!==ifNaNif (Math.round(x) === x) { /* x IS an integer! */ }
— mgthomas99 '12
3

その上、Number.isInteger()。多分ここにNumber.isSafeInteger()別のオプションがあります ES6指定を使用することによって。

Number.isSafeInteger(..)ES6より前のブラウザーでポリフィルするには：

Number.isSafeInteger = Number.isSafeInteger || function(num) {
    return typeof num === "number" && 
           isFinite(num) && 
           Math.floor(num) === num &&
           Math.abs( num ) <= Number.MAX_SAFE_INTEGER;
};
— Zangw
ソース
3

Number.isInteger() お使いのブラウザがサポートしている場合は、それが最善の方法です。そうでない場合は、多くの方法があると思います。

function isInt1(value){
  return (value^0) === value
}

または：

function isInt2(value){
  return (typeof value === 'number') && (value % 1 === 0); 
}

または：

function isInt3(value){
  return parseInt(value, 10) === value; 
}

または：

function isInt4(value){
  return Math.round(value) === value; 
}

これで結果をテストできます：

var value = 1
isInt1(value)   // return true
isInt2(value)   // return true
isInt3(value)   // return true
isInt4(value)   // return true

var value = 1.1
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

var value = 1000000000000000000
isInt1(value)   // return false
isInt2(value)   // return true
isInt3(value)   // return false
isInt4(value)   // return true

var value = undefined
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

var value = '1' //number as string
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

したがって、これらのメソッドはすべて機能しますが、数値が非常に大きい場合、parseIntおよび^演算子は適切に機能しません。

— チャールズ・チュー
ソース
3

ちょうどこれを試してください：

let number = 5;
if (Number.isInteger(number)) {
    //do something
}
— Jan WebDev
ソース
Number.isInteger（）は、IEブラウザーのすべてのバージョンでサポートされているわけではありません。
— SKR
2

この関数を使用できます：

function isInteger(value) {
    return (value == parseInt(value));
}

値が整数値を含む文字列であってもtrueを返します。
したがって、結果は次のようになります。

alert(isInteger(1)); // true
alert(isInteger(1.2)); // false
alert(isInteger("1")); // true
alert(isInteger("1.2")); // false
alert(isInteger("abc")); // false
— 強皮症
ソース
2

私のアプローチ：

a >= 1e+21テストは、数値でなければならない値に対してのみパスでき、非常に大きなます。この説明で提供されている他のソリューションとは異なり、これはすべてのケースを確実にカバーします。

a === (a|0)与えられた関数の引数がビット単位に変換された値と完全に同じ（===）である場合、それは引数が整数であることを意味します。

a|0その0任意の値に戻りますa数値でない場合、およびa実際の数である、それは小数点以下のものを剥ぎ取るだろう、そう1.0001なるだろう1

function isInteger(a){
    return a >= 1e+21 ? true : a === (a|0)
}

/// tests ///////////////////////////
[
  1,                        // true
  1000000000000000000000,   // true
  4e2,                      // true
  Infinity,                 // true
  1.0,                      // true
  1.0000000000001,          // false
  0.1,                      // false
  "0",                      // false
  "1",                      // false
  "1.1",                    // false
  NaN,                      // false
  [],                       // false
  {},                       // false
  true,                     // false
  false,                    // false
  null,                     // false
  undefined                 // false
].forEach( a => console.log(typeof a, a, isInteger(a)) )
スニペットを展開

— vsync
ソース
1
良いアイデア！テストを表示したことも気に入っていますが、残念ながら、これは「0」の文字列値を考慮していません。
— ジャマー
@vsyncちょっと、意図的ではありません。私はもともと賛成票を投じましたが、以前のコメントのために元に戻すことにしました。誤ってダブルクリックしたのでしょう。
— ジャマー
1

これには正規表現を使用できます。

function isInteger(n) {
    return (typeof n == 'number' && /^-?\d+$/.test(n+''));
}
— Macloving
ソース
1

|演算子を使用します。

(5.3 | 0) === 5.3 // => false
(5.0 | 0) === 5.0 // => true

したがって、テスト関数は次のようになります。

var isInteger = function (value) {
  if (typeof value !== 'number') {
    return false;
  }

  if ((value | 0) !== value) {
    return false;
  }

  return true;
};
— ゴロ・ローデン
ソース
1

これは、もう1つのシナリオ（121.）、最後のドットを解決します

function isInt(value) {
        var ind = value.indexOf(".");
        if (ind > -1) { return false; }

        if (isNaN(value)) {
            return false;
        }

        var x = parseFloat(value);
        return (x | 0) === x;

    }
— ムハンマド・ラフィック
ソース
1

セパレータなしの正の整数値の場合：

return ( data !== '' && data === data.replace(/\D/, '') );

テスト1.空でない場合2.値がその値の非数字文字の置換の結果と等しい場合。

— ダニエル
ソース
1

OKはマイナスになりました、原因は私の例を説明しなかったので、より多くの例:)：

私は正規表現とテスト方法を使用しています：

var isInteger = /^[0-9]\d*$/;

isInteger.test(123); //true
isInteger.test('123'); // true
isInteger.test('sdf'); //false
isInteger.test('123sdf'); //false

// If u want to avoid string value:
typeof testVal !== 'string' && isInteger.test(testValue);
— ヴァシル・グトニック
ソース
テストが関数ではないためか、マイナスになりました。
— imlokesh 2017
@imlokesh「関数ではない」とはどういう意味ですか？oO「テスト方法」を使用して書いた。
— Vasyl Gutnyk
何の問題@imlokeshない、私は生産にそれを使用して原因私はちょうどUを尋ねる:)と私はuが、いくつかのバグ:)見つかったと思った
— ワシルGutnyk
1

この方法で試すこともできます 

var data = 22;
if (Number.isInteger(data)) {
    console.log("integer");
 }else{
     console.log("not an integer");
 }

または

if (data === parseInt(data, 10)){
    console.log("integer");
}else{
    console.log("not an integer");
}
— Adeojo Emmanuel IMM
ソース
これにより、に対して誤った結果が生成されdata=22.5;ます。また、両方のブランチにはconsole.log("not an integer"):: S
— Colin Breameが2018年
0

変数（文字列または数値）が整数かどうかを確認する必要があり、次の条件を使用しました。

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

http://jsfiddle.net/e267369d/1/

他の回答のいくつかは同様の解決策を持っています（とのparseFloat組み合わせに依存しますisNaN）が、私はもっと簡単でわかりやすいはずです。

編集：コンマを含む文字列（ "1,2"など）でメソッドが失敗することがわかりました。また、特定のケースでは、文字列が有効な整数でない場合に関数を失敗させたいことにも気付きました（フロートで失敗するはずです） 、さらには1.0）。だからここに私の関数Mk IIがあります：

function isInt(a){
    return !isNaN(a) && parseInt(a) == parseFloat(a) && (typeof a != 'string' || (a.indexOf('.') == -1 && a.indexOf(',') == -1));
}

http://jsfiddle.net/e267369d/3/

もちろん、実際に整数の浮動小数点数（1.0のもの）を受け入れる関数が必要な場合は、ドット条件をいつでも削除できますa.indexOf('.') == -1。

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