数値がfloatかintegerかを確認するにはどうすればいいですか？
数値がfloatまたはintegerであることを見つける方法は？
1.25 --> float
1 --> integer
0 --> integer
0.25 --> float
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;
}
これらの関数を試して、値が小数部分を持たず、正確な整数として表すことができるもののサイズ制限内にある数プリミティブ値であるかどうかをテストします。
function isFloat(n) {
return n === +n && n !== (n|0);
}
function isInteger(n) {
return n === +n && n === (n|0);
}
どうしてこんな感じじゃないの？
var isInt = function(n) { return parseInt(n) === n };
Number.isInteger()というメソッドがあり、これは現在最新のFirefoxでのみ実装されており、まだEcmaScript 6の提案の一部です。しかし、 _ mdn _ は他のブラウザ用のポリフィルを提供します。これはECMA調和で指定されたものと一致します。
if (!Number.isInteger) {
Number.isInteger = function isInteger (nVal) {
return typeof nVal === "number" && isFinite(nVal) && nVal > -9007199254740992 && nVal < 9007199254740992 && Math.floor(nVal) === nVal;
};
}
単純な正規表現を使うことができます。
function isInt(value) {
var er = /^-?[0-9]+$/;
return er.test(value);
}
また、必要に応じて以下の機能を使用することもできます。 PHPJSプロジェクト によって開発されています。
is_int() =>変数の型が整数かどうか、またその内容が整数かどうかをチェックする
is_float() =>変数の型がfloatかどうか、またその内容がfloatかどうかをチェックする
ctype_digit() =>変数の型が文字列かどうか、またその内容が10進数のみの場合
更新1
今度は負の数もチェックします、 @ChrisBartleyのコメントありがとうございます ！
値が数値か、または を安全に aに変換できるかどうかをチェックする効率的な関数は次のとおりです。
function isNumber(value) {
if ((undefined === value) || (null === value)) {
return false;
}
if (typeof value == 'number') {
return true;
}
return !isNaN(value - 0);
}
整数の場合（値がfloatの場合はfalseを返します）
function isInteger(value) {
if ((undefined === value) || (null === value)) {
return false;
}
return value % 1 == 0;
}
ここでの効率は、値がすでに数値である場合にparseInt（またはparseNumber）が回避されることです。両方の構文解析関数 always を最初に文字列に変換してからその文字列を解析しようとします。値がすでに数値の場合は無駄になります。
最適化のためのさらなるアイデアを提供してくれたこちらの他の記事に感謝します。
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
function isInt(n)
{
return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
return n != "" && !isNaN(n) && Math.round(n) != n;
}
すべての場合に有効です。
他の人が言ったように、あなたはJSにはダブルスしかありません。それでは、整数を整数としてどのように定義しますか。丸められた数がそれ自体と等しいかどうかを確認してください。
function isInteger(f) {
return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }
これが私が整数に使うものです：
Math.ceil(parseFloat(val)) === val
短く、いいね:)いつも働いています。私が間違っていないなら、これはDavid Flanaganが提案するものです。
小数部がゼロの浮動小数点数（1.0、12.00、0.0など）は暗黙的に整数にキャストされるため、浮動小数点数であるかどうかを確認することはできません。
var isInt = function (n) { return n === (n | 0); };
これが仕事をしなかったケースがありませんでした。
!!(24%1) // false
!!(24.2%1) // true
この解決策は私のために働いた。
<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>
それほど複雑である必要はありません。整数の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) }
これはどう？
isFloat(num) {
return typeof num === "number" && !Number.isInteger(num);
}
それは本当にあなたが達成したいことによります。強く型付けされた言語を「エミュレート」したいのなら、試してはいけません。他の人が述べたように、すべての数字は同じ表現（同じタイプ）を持っています。
Claudiu のようなものを使うと：
isInteger( 1.0 ) - > true
これは常識的には問題ないように見えますが、Cのようなものではfalseになります
それは簡単です：
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であるときはいつでも、それはもうfloatではありません。整数です。あるいは、当時の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 failed"を返しますが、これはまさにbの数値が大きいためです。制限は変わるかもしれませんが、私は20桁が「誰にとっても十分であるべきだ」と思います。
ここでいくつか答えを試してみると、私はこの解決策を書いてしまいました。これは文字列内の数字に対しても機能します。
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);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');
}
このIS INTとFLOATの両方の最終コード
function isInt(n) {
if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
return true;
} else {
return false;
}
}
OR
function isInt(n) {
return typeof n == 'number' && Math.Round(n) % 1 == 0;
}
私は文字列を受け入れる関数を書いた
function isInt(x) {
return !isNaN(x) && eval(x).toString().length == parseInt(eval(x)).toString().length
}
function isFloat(x) {
return !isNaN(x) && !isInt(eval(x)) && x.toString().length > 0
}
ouptutsの例：
console.log(isFloat('0.2')) // true
console.log(isFloat(0.2)) // true
console.log(isFloat('.2')) // true
console.log(isFloat('-.2')) // true
console.log(isFloat(-'.2')) // true
console.log(isFloat(-.2)) // true
console.log(isFloat('u.2')) // false
console.log(isFloat('2')) // false
console.log(isFloat('0.2u')) // false
console.log(isInt('187')) // true
console.log(isInt(187)) // true
console.log(isInt('1.2')) // false
console.log(isInt('-2')) // true
console.log(isInt(-'1')) // true
console.log(isInt('10e1')) // true
console.log(isInt(10e1)) // true
整数の場合はこれを使います
function integer_or_null(value) {
if ((undefined === value) || (null === value)) {
return null;
}
if(value % 1 != 0) {
return null;
}
return value;
}
これは％answerほどパフォーマンスが良くないため、最初に文字列に変換する必要がなくなりますが、まだ投稿したことがある人はいないので、これでうまくいくはずの別のオプションがあります。
function isInteger(num) {
return num.toString().indexOf('.') === -1;
}
好奇心旺盛な人たちのために、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
try this one
function amountcheck()
{
var dpamt=$('#dpamt').val()/5000;
var ints=dpamt.toString();
var isint=ints.split('.');
if(isint[1]>0)
{
alert('float value');
return false;
}
else
{
alert('int value');
}
}
これが私のコードです。空の文字列でないことを確認し（そうでなければパスします）、それを数値形式に変換します。さて、あなたが '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;
};
YourJS は、-Infinityおよびfalseに対してInfinityを返すことを含む、すべての数値に対して機能する次の2つの関数を提供します。
function isFloat(x) {
return typeOf(x, 'Number') && !!(x % 1);
}
function isInt(x) {
return typeOf(x, 'Number') && x % 1 == 0;
}
typeOf()はYourJSの内部関数であるため、これらの定義を使用したい場合は、これらの関数のバージョンをここからダウンロードできます。 http://yourjs.com/snippets/build/34
Javaスクリプトでは、数字はすべてinternally 64 bit floating pointです。Javaのdoubleと同じです。 JavaScriptには異なる型はありません。すべてがnumber型で表されます。したがって、あなたはinstanceofチェックをすることができないでしょう。しかし、uが分数であるかどうかを調べるために与えられた上記の解を使うことができます。 Javaスクリプトの設計者は、単一の型を使用しているため、多数の型キャストエラーを回避できます。
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'を追加できます。
場合によっては、Numberオブジェクトでmod演算子（％）を直接使用できないことがあります。その場合は、この解決策を使用できます。
if(object instanceof Number ){
if( ((Number) object).doubleValue() % 1 == 0 ){
//your object is an integer
}
else{
//your object is a double
}
}
私はこの小さな関数が好きです。これは正と負の両方の整数に対して真を返します。
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"になるためです。どちらも数字ではないので、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]です。
これは私のものです：
function isInt(quale) {
var valore = $('#'+quale).val().toLowerCase();
if (isNaN(Number(String(valore))) || (valore.indexOf("e") > 0)) {
// Not int
} else {
// Is Int!
}
}
この：
function isFloat(quale) {
var valore = $('#'+quale).val();
valore = valore.replace(",", "");
if (isNaN(String(valore)) || (valore.indexOf("e") > 0)) {
// Not Float
} else {
// Float
}
}
Ad majora！
私はこれが最もエレガントな方法だと思います。
function isInteger(n) {
return n === (n^0);
}
数値でない場合はfalseを返すようにしても構いません。
以下の関数は、空の文字列、未定義、null、および最大値/最小値の範囲から保護します。 Javascriptエンジンは初日からこれらの関数を組み込んでいるはずです。 :)
楽しい！
function IsInteger(iVal) {
var iParsedVal; //our internal converted int value
iParsedVal = parseInt(iVal,10);
if (isNaN(iParsedVal) || Infinity == iParsedVal || -Infinity == iParsedVal) //sanity check - guard against empty strings and max/min values
return false;
else
return Number(iVal) === (iParsedVal | 0); //the 2nd operand group (intValue | 0), evaluates to true only if the intValue is an integer; so an int type will only return true
}
function IsFloat(fVal) {
var fParsedVal; //our internal converted float value
fParsedVal = parseFloat(fVal);
if (isNaN(fParsedVal) || Infinity == fParsedVal || -Infinity == fParsedVal) //sanity check - guard against empty strings and max/min values
return false;
else
return !!(fVal % 1); //true only if there is a fractional value after the mod op; the !! returns the opposite value of the op which reflects the function's return value
}
フローティング検証の条件：
if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0))
整数検証の条件：
if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0))
これが役立つことを願っています。
warfares 'answerに触発されて、私はこれを文字列入力を検証するために使用します。
function validLatLng(n) {
var isInt = function(n) { return parseInt(n) == n };
var isFloat = function(n) { return parseFloat(n) == n };
// For testing
console.log("validLatLng::n", n);
console.log("validLatLng::parseInt", parseInt(n));
console.log("validLatLng::parseFloat", parseFloat(n));
console.log("validLatLng::isInt", isInt(n));
console.log("validLatLng::isFloat", isFloat(n));
return isInt(n) || isFloat(n);
}
あなたはこれでコンソールでそれをテストすることができます：
// Invalid for my use case
validLatLng("") // or `null`, `undefined`, etc.
validLatLng("a")
validLatLng("a1100")
validLatLng("-100a")
validLatLng("a100.00")
validLatLng("-2a100.00123")
// VALID for my use case
validLatLng("100")
validLatLng("-100")
validLatLng("100.00")
validLatLng("-100.00123")
私がここで見たことのすべてに基づいて、私は私が必要とするものについてテストするために私自身の関数のセットを作成しました：
function NumberValidator() {
this.isFloat = function (n) {
return typeof(n)==="number" && n === +n && Math.round(n) !== n;
};
this.isInteger = function (n) {
return typeof(n)==="number" && n === +n && Math.round(n) === n;
};
this.isFloatOrInteger = function (n) {
return this.isFloat(n) || this.isInteger(n);
};
this.isNonZeroFloatOrInteger = function (n) {
return this.isFloatOrInteger(n) && n > 0;
};
this.isNonZeroInteger = function (n) {
return this.isInteger(n) && n > 0;
};
}
しかし、 shime の解決法はより短く、チェックも少ないので、もっと良い方法かもしれません。
入力値が整数か浮動小数点かをチェックし、それを行うために次のことを思いつく必要がありました。
function isInteger(x) {
var integer = parseInt(x, 10);
if (!isNaN(integer) && !isFloat(x)) {
return true;
}
return false;
}
function isFloat(x) {
var f = parseFloat(x);
var floor = Math.floor(f);
var fraction = f - floor;
if (fraction > 0) {
return true;
}
return false;
}
var cases = [
"1",
"1.00",
"1.01",
"0.05",
"ab1",
"ab1.1",
1,
1.00,
1.01,
0.05,
1e+5,
"",
true,
false,
null,
NaN,
undefined,
];
console.log("isInteger()");
for (var i = 0; i < cases.length; i++) {
console.log(cases[i], isInteger(cases[i]));
}
console.log("\nisFloat()");
for (var i = 0; i < cases.length; i++) {
console.log(cases[i], isFloat(cases[i]));
}