どの番号であることを見つけるためにfloat
かinteger
?
1.25 --> float
1 --> integer
0 --> integer
0.25 --> float
Infinity
あなたが懸念している限りとして、整数または非整数値は?ここでの答えは、このスコアにかなり均等に分配されます。
Infinity
、整数と見なすことはできません。
どの番号であることを見つけるためにfloat
かinteger
?
1.25 --> float
1 --> integer
0 --> integer
0.25 --> float
Infinity
あなたが懸念している限りとして、整数または非整数値は?ここでの答えは、このスコアにかなり均等に分配されます。
Infinity
、整数と見なすことはできません。
回答:
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で標準化されました。そのソリューションはこの回答でカバーされています。
true
、false
、null
、空の配列、多分それ以上の単一整数、整数を表す文字列を含む配列、およびを含む配列。
""
と1.0
isInt("");
&&のisInt(1.0);
両方のチェックに失敗するため、正解ではありません&& 両方の結果は、true
このデモを参照してくださいjsbin.com/elohuq/1/edit
function last (array) { return array[array.length - 1]; }
答えた場合、引数が最初に配列であるかどうかをチェックしないため、それは「ただ間違っている」か「SOの最悪の回答」ですか?はい、引数をチェックするのは良い習慣ですが、それは開発者の責任です。SOの回答は短く、できるだけ明確に質問に直接回答する必要があります。
これらの関数を試して、値が小数部のないプリミティブな数値であり、正確な整数として表現できるサイズの制限内にあるかどうかをテストします。
function isFloat(n) {
return n === +n && n !== (n|0);
}
function isInteger(n) {
return n === +n && n === (n|0);
}
n===+n
数値をチェックしたり、丸めたりするために)自分のものですn|0
が、組み込みの演算子を使用しています。ファンキー
parseFloat()
最初に呼び出します。
|
(OR)のようなビット演算子は、符号付き32ビット整数でのみ動作します。OPは、目標が符号付きint32値をチェックすることであるかどうかを述べていません。したがって、これは範囲外の数値では機能しません。間違っているものisInteger(5000000000)
を返しfalse
ます!
なぜこのようなものではないのですか?
var isInt = function(n) { return parseInt(n) === n };
と呼ばれるメソッドがあり、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;
};
12.0 ∈ ℤ
。
Number.isInteger
。ただし、の正しいポリフィルですNumber.isSafeInteger
。 Number.isInteger
数値が「安全な整数」であるかどうかをチェックしないでください。MDN:isIntegerおよびisSafeIntegerを参照してください。
単純な正規表現を使用できます。
function isInt(value) {
var er = /^-?[0-9]+$/;
return er.test(value);
}
または、必要に応じて、以下の関数も使用できます。それらはPHPJSプロジェクトによって開発されました。
is_int()
=>変数の型が整数かどうか、およびその内容が整数かどうかを確認します
is_float()
=>変数の型が浮動小数点かどうか、およびその内容が浮動小数点かどうかを確認します
ctype_digit()
=>変数の型が文字列であり、その内容が10進数のみであるかどうかを確認します
アップデート1
@ChrisBartleyコメントに感謝します!
/^[0-9]+$/.test(String(value))
/^[0-9]+$/.test(''+value)
return /^-?\d+$/.test(String(value));
値が数値であるか、数値に安全に変換できるかどうかをチェックする効率的な関数を次に示します。
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)が回避されることです。両方の解析関数は常に最初に文字列に変換してから、その文字列を解析しようとしますが、値がすでに数値である場合、これは無駄になります。
最適化のためのさらなるアイデアを提供してくれたここの他の投稿に感謝します!
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
1.2
。常に0.1 0.2 0.3で数値関数をテストします
function isInt(n)
{
return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
return n != "" && !isNaN(n) && Math.round(n) != n;
}
すべてのケースで機能します。
isInt('1')
戻りますtrue
(少なくとも私にとって)。奇妙なことに、これもまた戻っtrue
てきisInt([5])
ます。私にとっては問題ではありませんでしたが、あなたのためかもしれません。
他の人が述べたように、あなたはJSでダブルスしか持っていません。それでは、数値を整数としてどのように定義しますか?丸められた数がそれ自体と等しいかどうかを確認してください:
function isInteger(f) {
return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }
isFloat('abc')
戻り値true
isFloat(NaN) // true
これが私が整数に使用するものです:
Math.ceil(parseFloat(val)) === val
短くて素敵です:)いつでも動作します。これは、私が間違っていない場合、David Flanaganが提案するものです。
parseFloat
?
それほど複雑である必要はありません。整数の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) }
var isInt = function (n) { return n === (n | 0); };
これでうまくいかないケースはありませんでした。
2
はが整数であり23
、関数の2番目の引数と見なされるためです。JavaScriptでは、小数点は区切り記号としてドットを使用して記述されているため、そうする必要があります2.23
。
これは、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;
}
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');
}
それは次のように簡単です:
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桁で「だれでも十分なはずです」と思います。
Number.isInteger
仕組みと一致しています。
Number.isInteger
動作方法と一致しています。単一行のテストはn === (n | 0)
、別の回答に示されています。
この解決策は私にとってうまくいきました。
<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>
ここでいくつかの答えを試して、私はこの解決策を書きました。これは、文字列内の数値でも機能します。
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);
これらの好奇心が強い人のために、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
これが私のコードです。空の文字列(そうでない場合は渡されます)ではないことを確認してから、数値形式に変換します。ここで、「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;
};
正と負の両方の整数に対して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]です。
<nit-pick>
JavaScriptには異なる整数型と浮動小数点型はありません。JavaScriptのすべての数値は単なるNumber
です。</nit-pick>