JavaScript で 10 進数を検証する最もクリーンで効果的な方法は何ですか?
ボーナスポイント:
テストケース:
01. IsNumeric('-1') => true
02. IsNumeric('-1.5') => true
03. IsNumeric('0') => true
04. IsNumeric('0.42') => true
05. IsNumeric('.42') => true
06. IsNumeric('99,999') => false
07. IsNumeric('0x89f') => false
08. IsNumeric('#abcdef') => false
09. IsNumeric('1.2.3') => false
10. IsNumeric('') => false
11. IsNumeric('blah') => false
@Joelの答えはかなり近いですが、次の場合は失敗します。
// Whitespace strings:
IsNumeric(' ') == true;
IsNumeric('\t\t') == true;
IsNumeric('\n\r') == true;
// Number literals:
IsNumeric(-1) == false;
IsNumeric(0) == false;
IsNumeric(1.1) == false;
IsNumeric(8e5) == false;
少し前に、IsNumeric関数を実装する必要がありました。変数に数値が含まれているかどうかを確認するには、その型に関係なくString、数値（指数表記なども考慮する必要があります）、Numberオブジェクト、事実上、その関数に何でも渡すことができ、型の強制を処理して、型を仮定することはできませんでした（たとえば、と見なすべきではありません+true == 1;）。true"numeric"
多数の関数実装に対して行われたこの一連の+30単体テストを共有する価値があると思います。また、すべてのテストに合格したものを共有します。
function isNumeric(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
PS isNaNとisFiniteは、数値への強制変換のために混乱を招く動作をします。ES6では、Number.isNaNとNumber.isFiniteがこれらの問題を修正します。それらを使用するときはそれを覚えておいてください。
更新： jQueryの現在の動作は次のとおりです（2.2-stable）：
isNumeric: function(obj) {
var realStringObj = obj && obj.toString();
return !jQuery.isArray(obj) && (realStringObj - parseFloat(realStringObj) + 1) >= 0;
}
アップデート： Angular 4.3：
export function isNumeric(value: any): boolean {
return !isNaN(value - parseFloat(value));
}
ああ！正規表現の答えを聞かないでください。RegEx はこれにうんざりしており、パフォーマンスだけを話しているわけではありません。微妙な表現をするのはとても簡単で、正規表現の間違いを見つけることは不可能です。
を使用できない場合isNaN()、これははるかにうまく機能するはずです:
function IsNumeric(input)
{
return (input - 0) == input && (''+input).trim().length > 0;
}
仕組みは次のとおりです。
この(input - 0)式は、JavaScript に入力値の型強制を強制します。最初に、減算操作の数値として解釈する必要があります。数値への変換が失敗した場合、式の結果は になりNaNます。この数値結果は、渡された元の値と比較されます。左側が数値であるため、型強制が再び使用されます。両側からの入力が同じ元の値から同じ型に強制されたので、それらは常に同じ (常に true) であるべきだと考えるでしょう。NaNただし、 がと等しくならないという特別なルールがあるNaNため、数値に変換できない値 (および数値に変換できない値のみ) は false になります。
長さのチェックは、空の文字列を含む特殊なケース用です。また、0x89f テストで落ちることに注意してください。これは、多くの環境では数値リテラルを定義するのに問題がないためです。その特定のシナリオをキャッチしたい場合は、追加のチェックを追加できます。さらに良いことに、それが使用しない理由である場合は、追加のチェックも実行できるisNaN()独自の関数をラップするだけです。isNaN()
要約すると、値を数値に変換できるかどうかを知りたい場合は、実際に数値に変換してみてください。
私は戻って、空白文字列が期待される出力を持たない理由について0いくつかの調査を行いましたNaN. 長さチェックの前に文字列をトリミングするだけで、このケースを処理できます。
新しいコードに対して単体テストを実行すると、無限大とブール値のリテラルでのみ失敗します。問題になるのは、コードを生成している場合だけです (実際、誰がリテラルを入力して数値かどうかを確認しますか?あなたは知っているべきです）、そしてそれは生成する奇妙なコードになるでしょう.
しかし、繰り返しになりますが、これを使用する唯一の理由は、何らかの理由で isNaN() を避ける必要がある場合です。
この方法はうまくいくようです：
function IsNumeric(input){
var RE = /^-{0,1}\d*\.{0,1}\d+$/;
return (RE.test(input));
}
一行で：
const IsNumeric = (num) => /^-{0,1}\d*\.{0,1}\d+$/.test(num);
そしてそれをテストするには：
const IsNumeric = (num) => /^-{0,1}\d*\.{0,1}\d+$/.test(num);
function TestIsNumeric(){
var results = ''
results += (IsNumeric('-1')?"Pass":"Fail") + ": IsNumeric('-1') => true\n";
results += (IsNumeric('-1.5')?"Pass":"Fail") + ": IsNumeric('-1.5') => true\n";
results += (IsNumeric('0')?"Pass":"Fail") + ": IsNumeric('0') => true\n";
results += (IsNumeric('0.42')?"Pass":"Fail") + ": IsNumeric('0.42') => true\n";
results += (IsNumeric('.42')?"Pass":"Fail") + ": IsNumeric('.42') => true\n";
results += (!IsNumeric('99,999')?"Pass":"Fail") + ": IsNumeric('99,999') => false\n";
results += (!IsNumeric('0x89f')?"Pass":"Fail") + ": IsNumeric('0x89f') => false\n";
results += (!IsNumeric('#abcdef')?"Pass":"Fail") + ": IsNumeric('#abcdef') => false\n";
results += (!IsNumeric('1.2.3')?"Pass":"Fail") + ": IsNumeric('1.2.3') => false\n";
results += (!IsNumeric('')?"Pass":"Fail") + ": IsNumeric('') => false\n";
results += (!IsNumeric('blah')?"Pass":"Fail") + ": IsNumeric('blah') => false\n";
return results;
}
console.log(TestIsNumeric());.as-console-wrapper { max-height: 100% !important; top: 0; }その正規表現をhttp://www.codetoad.com/javascript/isnumeric.aspから借りました。説明：
/^ match beginning of string
-{0,1} optional negative sign
\d* optional digits
\.{0,1} optional decimal point
\d+ at least one digit
$/ match end of string
Yahoo! UIはこれを使用します：
isNumber: function(o) {
return typeof o === 'number' && isFinite(o);
}
受け入れられた回答はテスト #7 に失敗しました。それは、気が変わったためだと思います。これは、私が問題を抱えていた受け入れられた回答への回答です。
一部のプロジェクトでは、一部のデータを検証し、それが数学演算で使用できる JavaScript の数値であることをできる限り確認する必要がありました。
jQuery、および他のいくつかの JavaScript ライブラリには、通常はisNumeric. 答えとして広く受け入れられているstackoverflowに関する投稿もあります。これは、前述のライブラリが使用しているのと同じ一般的なルーチンです。
function isNumber(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
まず、上記のコードは、引数が長さ 1 の配列であり、その単一の要素が上記のロジックによって数値と見なされる型である場合に true を返します。私の意見では、配列の場合は数値ではありません。
この問題を軽減するために、ロジックから配列を割引するチェックを追加しました
function isNumber(n) {
return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n);
}
もちろん、代わりにArray.isArray、jquery $.isArray、prototypeを使用することもできます。Object.isArrayObject.prototype.toString.call(n) !== '[object Array]'
私の 2 番目の問題は、負の 16 進数の整数リテラル文字列 ("-0xA" -> -10) が数値としてカウントされていないことでした。ただし、正の 16 進整数リテラル文字列 ("0xA" -> 10) は数値として扱われていました。どちらも有効な数値である必要がありました。
次に、これを考慮してロジックを修正しました。
function isNumber(n) {
return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
}
関数が呼び出されるたびに正規表現が作成されることが心配な場合は、次のようにクロージャー内で書き直すことができます。
var isNumber = (function () {
var rx = /^-/;
return function (n) {
return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(rx, ''));
};
}());
次に、CMSの+30 個のテスト ケースを取得し、jsfiddleでのテストを複製して、追加のテスト ケースと上記のソリューションを追加しました。
広く受け入れられている/使用されている回答に取って代わるものではないかもしれませんが、これが isNumeric 関数の結果として期待されるものである場合は、これが役立つことを願っています.
編集: Bergiが指摘したように、数値と見なされる可能性のあるオブジェクトは他にもあり、ブラックリストよりもホワイトリストに登録することをお勧めします。これを念頭に置いて、私は基準に追加します。
isNumeric 関数で数値または文字列のみを考慮したい
これを念頭に置いて、使用する方が良いでしょう
function isNumber(n) {
return (Object.prototype.toString.call(n) === '[object Number]' || Object.prototype.toString.call(n) === '[object String]') &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
}
ソリューションをテストする
var testHelper = function() {
var testSuite = function() {
test("Integer Literals", function() {
ok(isNumber("-10"), "Negative integer string");
ok(isNumber("0"), "Zero string");
ok(isNumber("5"), "Positive integer string");
ok(isNumber(-16), "Negative integer number");
ok(isNumber(0), "Zero integer number");
ok(isNumber(32), "Positive integer number");
ok(isNumber("040"), "Octal integer literal string");
ok(isNumber(0144), "Octal integer literal");
ok(isNumber("-040"), "Negative Octal integer literal string");
ok(isNumber(-0144), "Negative Octal integer literal");
ok(isNumber("0xFF"), "Hexadecimal integer literal string");
ok(isNumber(0xFFF), "Hexadecimal integer literal");
ok(isNumber("-0xFF"), "Negative Hexadecimal integer literal string");
ok(isNumber(-0xFFF), "Negative Hexadecimal integer literal");
});
test("Foating-Point Literals", function() {
ok(isNumber("-1.6"), "Negative floating point string");
ok(isNumber("4.536"), "Positive floating point string");
ok(isNumber(-2.6), "Negative floating point number");
ok(isNumber(3.1415), "Positive floating point number");
ok(isNumber(8e5), "Exponential notation");
ok(isNumber("123e-2"), "Exponential notation string");
});
test("Non-Numeric values", function() {
equals(isNumber(""), false, "Empty string");
equals(isNumber(" "), false, "Whitespace characters string");
equals(isNumber("\t\t"), false, "Tab characters string");
equals(isNumber("abcdefghijklm1234567890"), false, "Alphanumeric character string");
equals(isNumber("xabcdefx"), false, "Non-numeric character string");
equals(isNumber(true), false, "Boolean true literal");
equals(isNumber(false), false, "Boolean false literal");
equals(isNumber("bcfed5.2"), false, "Number with preceding non-numeric characters");
equals(isNumber("7.2acdgs"), false, "Number with trailling non-numeric characters");
equals(isNumber(undefined), false, "Undefined value");
equals(isNumber(null), false, "Null value");
equals(isNumber(NaN), false, "NaN value");
equals(isNumber(Infinity), false, "Infinity primitive");
equals(isNumber(Number.POSITIVE_INFINITY), false, "Positive Infinity");
equals(isNumber(Number.NEGATIVE_INFINITY), false, "Negative Infinity");
equals(isNumber(new Date(2009, 1, 1)), false, "Date object");
equals(isNumber(new Object()), false, "Empty object");
equals(isNumber(function() {}), false, "Instance of a function");
equals(isNumber([]), false, "Empty Array");
equals(isNumber(["-10"]), false, "Array Negative integer string");
equals(isNumber(["0"]), false, "Array Zero string");
equals(isNumber(["5"]), false, "Array Positive integer string");
equals(isNumber([-16]), false, "Array Negative integer number");
equals(isNumber([0]), false, "Array Zero integer number");
equals(isNumber([32]), false, "Array Positive integer number");
equals(isNumber(["040"]), false, "Array Octal integer literal string");
equals(isNumber([0144]), false, "Array Octal integer literal");
equals(isNumber(["-040"]), false, "Array Negative Octal integer literal string");
equals(isNumber([-0144]), false, "Array Negative Octal integer literal");
equals(isNumber(["0xFF"]), false, "Array Hexadecimal integer literal string");
equals(isNumber([0xFFF]), false, "Array Hexadecimal integer literal");
equals(isNumber(["-0xFF"]), false, "Array Negative Hexadecimal integer literal string");
equals(isNumber([-0xFFF]), false, "Array Negative Hexadecimal integer literal");
equals(isNumber([1, 2]), false, "Array with more than 1 Positive interger number");
equals(isNumber([-1, -2]), false, "Array with more than 1 Negative interger number");
});
}
var functionsToTest = [
function(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
},
function(n) {
return !isNaN(n) && !isNaN(parseFloat(n));
},
function(n) {
return !isNaN((n));
},
function(n) {
return !isNaN(parseFloat(n));
},
function(n) {
return typeof(n) != "boolean" && !isNaN(n);
},
function(n) {
return parseFloat(n) === Number(n);
},
function(n) {
return parseInt(n) === Number(n);
},
function(n) {
return !isNaN(Number(String(n)));
},
function(n) {
return !isNaN(+('' + n));
},
function(n) {
return (+n) == n;
},
function(n) {
return n && /^-?\d+(\.\d+)?$/.test(n + '');
},
function(n) {
return isFinite(Number(String(n)));
},
function(n) {
return isFinite(String(n));
},
function(n) {
return !isNaN(n) && !isNaN(parseFloat(n)) && isFinite(n);
},
function(n) {
return parseFloat(n) == n;
},
function(n) {
return (n - 0) == n && n.length > 0;
},
function(n) {
return typeof n === 'number' && isFinite(n);
},
function(n) {
return !Array.isArray(n) && !isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
}
];
// Examines the functionsToTest array, extracts the return statement of each function
// and fills the toTest select element.
var fillToTestSelect = function() {
for (var i = 0; i < functionsToTest.length; i++) {
var f = functionsToTest[i].toString();
var option = /[\s\S]*return ([\s\S]*);/.exec(f)[1];
$("#toTest").append('<option value="' + i + '">' + (i + 1) + '. ' + option + '</option>');
}
}
var performTest = function(functionNumber) {
reset(); // Reset previous test
$("#tests").html(""); //Clean test results
isNumber = functionsToTest[functionNumber]; // Override the isNumber global function with the one to test
testSuite(); // Run the test
// Get test results
var totalFail = 0;
var totalPass = 0;
$("b.fail").each(function() {
totalFail += Number($(this).html());
});
$("b.pass").each(function() {
totalPass += Number($(this).html());
});
$("#testresult").html(totalFail + " of " + (totalFail + totalPass) + " test failed.");
$("#banner").attr("class", "").addClass(totalFail > 0 ? "fail" : "pass");
}
return {
performTest: performTest,
fillToTestSelect: fillToTestSelect,
testSuite: testSuite
};
}();
$(document).ready(function() {
testHelper.fillToTestSelect();
testHelper.performTest(0);
$("#toTest").change(function() {
testHelper.performTest($(this).children(":selected").val());
});
});<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js" type="text/javascript"></script>
<script src="https://rawgit.com/Xotic750/testrunner-old/master/testrunner.js" type="text/javascript"></script>
<link href="https://rawgit.com/Xotic750/testrunner-old/master/testrunner.css" rel="stylesheet" type="text/css">
<h1>isNumber Test Cases</h1>
<h2 id="banner" class="pass"></h2>
<h2 id="userAgent">Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.95 Safari/537.11</h2>
<div id="currentFunction"></div>
<div id="selectFunction">
<label for="toTest" style="font-weight:bold; font-size:Large;">Select function to test:</label>
<select id="toTest" name="toTest">
</select>
</div>
<div id="testCode"></div>
<ol id="tests">
<li class="pass">
<strong>Integer Literals <b style="color:black;">(0, 10, 10)</b></strong>
<ol style="display: none;">
<li class="pass">Negative integer string</li>
<li class="pass">Zero string</li>
<li class="pass">Positive integer string</li>
<li class="pass">Negative integer number</li>
<li class="pass">Zero integer number</li>
<li class="pass">Positive integer number</li>
<li class="pass">Octal integer literal string</li>
<li class="pass">Octal integer literal</li>
<li class="pass">Hexadecimal integer literal string</li>
<li class="pass">Hexadecimal integer literal</li>
</ol>
</li>
<li class="pass">
<strong>Foating-Point Literals <b style="color:black;">(0, 6, 6)</b></strong>
<ol style="display: none;">
<li class="pass">Negative floating point string</li>
<li class="pass">Positive floating point string</li>
<li class="pass">Negative floating point number</li>
<li class="pass">Positive floating point number</li>
<li class="pass">Exponential notation</li>
<li class="pass">Exponential notation string</li>
</ol>
</li>
<li class="pass">
<strong>Non-Numeric values <b style="color:black;">(0, 18, 18)</b></strong>
<ol style="display: none;">
<li class="pass">Empty string: false</li>
<li class="pass">Whitespace characters string: false</li>
<li class="pass">Tab characters string: false</li>
<li class="pass">Alphanumeric character string: false</li>
<li class="pass">Non-numeric character string: false</li>
<li class="pass">Boolean true literal: false</li>
<li class="pass">Boolean false literal: false</li>
<li class="pass">Number with preceding non-numeric characters: false</li>
<li class="pass">Number with trailling non-numeric characters: false</li>
<li class="pass">Undefined value: false</li>
<li class="pass">Null value: false</li>
<li class="pass">NaN value: false</li>
<li class="pass">Infinity primitive: false</li>
<li class="pass">Positive Infinity: false</li>
<li class="pass">Negative Infinity: false</li>
<li class="pass">Date object: false</li>
<li class="pass">Empty object: false</li>
<li class="pass">Instance of a function: false</li>
</ol>
</li>
</ol>
<div id="main">
This page contains tests for a set of isNumber functions. To see them, take a look at the source.
</div>
<div>
<p class="result">Tests completed in 0 milliseconds.
<br>0 tests of 0 failed.</p>
</div>function IsNumeric(num) {
return (num >=0 || num < 0);
}
これは 0x23 型の数値でも機能します。
ええ、ビルトインはisNaN(object)その場で解釈されるのではなく、ビルトインされてコンパイルされるので、どの正規表現の解析よりもはるかに高速になります。
結果はあなたが探しているものとは多少異なりますが（試してみてください）：
// IS NUMERIC
document.write(!isNaN('-1') + "<br />"); // true
document.write(!isNaN('-1.5') + "<br />"); // true
document.write(!isNaN('0') + "<br />"); // true
document.write(!isNaN('0.42') + "<br />"); // true
document.write(!isNaN('.42') + "<br />"); // true
document.write(!isNaN('99,999') + "<br />"); // false
document.write(!isNaN('0x89f') + "<br />"); // true
document.write(!isNaN('#abcdef') + "<br />"); // false
document.write(!isNaN('1.2.3') + "<br />"); // false
document.write(!isNaN('') + "<br />"); // true
document.write(!isNaN('blah') + "<br />"); // false
関数を使用しますisNaN。テストすれば!isNaN(yourstringhere)、これらの状況のいずれでも問題なく機能すると思います。
jQuery 1.7以降、次を使用できますjQuery.isNumeric()：
$.isNumeric('-1'); // true
$.isNumeric('-1.5'); // true
$.isNumeric('0'); // true
$.isNumeric('0.42'); // true
$.isNumeric('.42'); // true
$.isNumeric('0x89f'); // true (valid hexa number)
$.isNumeric('99,999'); // false
$.isNumeric('#abcdef'); // false
$.isNumeric('1.2.3'); // false
$.isNumeric(''); // false
$.isNumeric('blah'); // false
あなたが言ったこととは異なり0x89f、有効な数字（16進数）であることに注意してください
これは、RegExpなしで実行できます。
function IsNumeric(data){
return parseFloat(data)==data;
}
return (input - 0) == input && input.length > 0;
私にはうまくいきませんでした。アラートを入れてテストしたところinput.length、undefined. 整数の長さをチェックするプロパティはないと思います。だから私がしたことは
var temp = '' + input;
return (input - 0) == input && temp.length > 0;
うまくいきました。
私が間違っていなければ、これは定数（Infinity、NaN）と符号演算子+/を除いて、有効なJavaScript数値と一致するはずです-（私が知る限り、これらは実際には数値の一部ではないため、別々の演算子です）：
これは、評価のためにJavaScriptに数値を送信するオプションがなかったトークナイザーに必要でした...これは間違いなく可能な限り最短の正規表現ではありませんが、JavaScriptの数値構文のより細かい微妙な点をすべて捉えていると思います。
/^(?:(?:(?:[1-9]\d*|\d)\.\d*|(?:[1-9]\d*|\d)?\.\d+|(?:[1-9]\d*|\d))
(?:[e]\d+)?|0[0-7]+|0x[0-9a-f]+)$/i
有効な番号は次のとおりです。
- 0
- 00
- 01
- 10
- 0e1
- 0e01
- .0
- 0.
- .0e1
- 0.e1
- 0.e00
- 0xf
- 0Xf
無効な番号は
- 00e1
- 01e1
- 00.0
- 00x0
- .
- .e0
@CMSの回答NaNで私が抱えていた唯一の問題は、多くの状況で役立つ数値である無限大の除外です。をチェックする 1 つの方法NaNは、それ自体と等しくない数値をチェックすることですNaN != NaN。したがって、実際に対処したいテストは3つあります...
function isNumber(n) {
n = parseFloat(n);
return !isNaN(n) || n != n;
}
function isFiniteNumber(n) {
n = parseFloat(n);
return !isNaN(n) && isFinite(n);
}
function isComparableNumber(n) {
n = parseFloat(n);
return (n >=0 || n < 0);
}
isFiniteNumber('NaN')
false
isFiniteNumber('OxFF')
true
isNumber('NaN')
true
isNumber(1/0-1/0)
true
isComparableNumber('NaN')
false
isComparableNumber('Infinity')
true
私の isComparableNumber は、別のエレガントな回答にかなり近いですが、16 進数やその他の数値の文字列表現を処理します。
私にとって、これが最良の方法です：
isNumber : function(v){
return typeof v === 'number' && isFinite(v);
}
以下を追加したいと思います。
1. IsNumeric('0x89f') => true
2. IsNumeric('075') => true
正の16進数はで始まり0x、負の16進数はで始まり-0xます。正のoct番号はで始まり0、負のoct番号はで始まり-0ます。これは、すでに述べたもののほとんどを考慮に入れていますが、16進数と8進数、負の科学、無限大を含み、10進数の科学を削除しています（4e3.2無効です）。
function IsNumeric(input){
var RE = /^-?(0|INF|(0[1-7][0-7]*)|(0x[0-9a-fA-F]+)|((0|[1-9][0-9]*|(?=[\.,]))([\.,][0-9]+)?([eE]-?\d+)?))$/;
return (RE.test(input));
}
ここでは parseFloat 関数がすべての作業を実行できると思います。以下の関数は、以下を含むこのページのすべてのテストに合格しますisNumeric(Infinity) == true。
function isNumeric(n) {
return parseFloat(n) == n;
}
追加するいくつかのテスト:
IsNumeric('01.05') => false
IsNumeric('1.') => false
IsNumeric('.') => false
私はこれを思いつきました：
function IsNumeric(input) {
return /^-?(0|[1-9]\d*|(?=\.))(\.\d+)?$/.test(input);
}
ソリューションは以下をカバーします。
整数値は次の方法で検証できます。
function isNumeric(value) {
var bool = isNaN(+value));
bool = bool || (value.indexOf('.') != -1);
bool = bool || (value.indexOf(",") != -1);
return !bool;
};
この方法は簡単で速いです！すべてのテストがチェックされます！
数値のように見える文字列だけでなく、変数に有効な数値が含まれているかどうかを確認するには、
Number.isFinite(value)使用できます。
これは ES2015以降の言語の一部です
例:
Number.isFinite(Infinity) // false
Number.isFinite(NaN) // false
Number.isFinite(-Infinity) // false
Number.isFinite(0) // true
Number.isFinite(2e64) // true
Number.isFinite('0') // false
Number.isFinite(null) // false
これは、正確なjQueryのバリアントの代わりに使用する少し改善されたバージョン（おそらく最速の方法）です。なぜ彼らがこれを使用しないのか本当にわかりません：
function isNumeric(val) {
return !isNaN(+val) && isFinite(val);
}
jQuery のバージョンの欠点は、先頭の数値と末尾の文字を含む文字列を渡すと、数値"123abc"のparseFloat | parseInt端数が抽出されて 123 が返されますが、とにかく 2 番目のガードisFiniteが失敗することです。単項演算+子を使用すると、 + がそのようなハイブリッドに対して NaN をスローするため、最初のガードで停止します :) 少しのパフォーマンスですが、確実なセマンティック ゲインが得られると思います。
私の解決策、
function isNumeric(input) {
var number = /^\-{0,1}(?:[0-9]+){0,1}(?:\.[0-9]+){0,1}$/i;
var regex = RegExp(number);
return regex.test(input) && input.length>0;
}
それはあらゆる状況で機能するように見えますが、私は間違っているかもしれません。
function inNumeric(n){
return Number(n).toString() === n;
}
n が数値の場合、数値Number(n)を返し、toString()それを文字列に戻します。ただし、 n が数値でない場合Number(n)は返さNaNれるため、元のものと一致しませんn
私はより簡単なソリューションを使用しています：
function isNumber(num) {
return parseFloat(num).toString() == num
}
空の文字列に対して返さfalseれる回答はありません。そのための修正です...
function is_numeric(n)
{
return (n != '' && !isNaN(parseFloat(n)) && isFinite(n));
}
これはうまくいくはずです。ここで提供されている関数の一部には欠陥がありますが、ここにある他のどの関数よりも高速である必要があります。
function isNumeric(n)
{
var n2 = n;
n = parseFloat(n);
return (n!='NaN' && n2==n);
}
説明:
それ自体のコピーを作成し、数値を float に変換し、元の数値 (integer または float) がまだ数値である場合は、元の数値と比較し、元の数値と一致します。つまり、実際に数値です。
数値文字列だけでなく、単純な数値でも機能します。16 進数では機能しません。
警告: 自己責任で使用してください。保証はありません。
I realize this has been answered many times, but the following is a decent candidate which can be useful in some scenarios.
it should be noted that it assumes that '.42' is NOT a number, and '4.' is NOT a number, so this should be taken into account.
function isDecimal(x) {
return '' + x === '' + +x;
}
function isInteger(x) {
return '' + x === '' + parseInt(x);
}
The isDecimal passes the following test:
function testIsNumber(f) {
return f('-1') && f('-1.5') && f('0') && f('0.42')
&& !f('.42') && !f('99,999') && !f('0x89f')
&& !f('#abcdef') && !f('1.2.3') && !f('') && !f('blah');
}
The idea here is that every number or integer has one "canonical" string representation, and every non-canonical representation should be rejected. So we cast to a number and back, and see if the result is the original string.
Whether these functions are useful for you depends on the use case. One feature is that distinct strings represent distinct numbers (if both pass the isNumber() test).
This is relevant e.g. for numbers as object property names.
var obj = {};
obj['4'] = 'canonical 4';
obj['04'] = 'alias of 4';
obj[4]; // prints 'canonical 4' to the console.
knockoutJs Inbuild ライブラリ検証関数
それを拡張することにより、フィールドが検証されます
1) 数
self.number = ko.observable(numberValue).extend({ 数値: 真}) ;
テストケース
numberValue = '0.0' --> true
numberValue = '0' --> true
numberValue = '25' --> true
numberValue = '-1' --> true
numberValue = '-3.5' --> true
numberValue = '11.112' --> true
numberValue = '0x89f' --> false
numberValue = '' --> false
numberValue = 'sfsd' --> false
numberValue = 'dg##$' --> false
2) 数字
self.number = ko.observable(numberValue).extend({ 桁: true}) ;
テストケース
numberValue = '0' --> true
numberValue = '25' --> true
numberValue = '0.0' --> false
numberValue = '-1' --> false
numberValue = '-3.5' --> false
numberValue = '11.112' --> false
numberValue = '0x89f' --> false
numberValue = '' --> false
numberValue = 'sfsd' --> false
numberValue = 'dg##$' --> false
3) 最小および最大
self.number = ko.observable(numberValue).extend({ 最小: 5}).extend({ 最大: 10}) ;
このフィールドは 5 から 10 の間の値のみを受け入れます
テストケース
numberValue = '5' --> true
numberValue = '6' --> true
numberValue = '6.5' --> true
numberValue = '9' --> true
numberValue = '11' --> false
numberValue = '0' --> false
numberValue = '' --> false
特殊な 10 進数 y のセットを検証する必要がある場合は、次の単純な JavaScript を使用できます。
http://codesheet.org/codesheet/x1kI7hAD
<input type="text" name="date" value="" pattern="[0-9]){1,2}(\.){1}([0-9]){2}" maxlength="6" placeholder="od npr.: 16.06" onchange="date(this);" />
Javascript:
function date(inputField) {
var isValid = /^([0-9]){1,2}(\.){1}([0-9]){2}$/.test(inputField.value);
if (isValid) {
inputField.style.backgroundColor = '#bfa';
} else {
inputField.style.backgroundColor = '#fba';
}
return isValid;
}
この関数はさまざまな方法で最小化でき、負の値またはカスタム チャート用のカスタム正規表現を使用して実装することもできます。
$('.number').on('input',function(){
var n=$(this).val().replace(/ /g,'').replace(/\D/g,'');
if (!$.isNumeric(n))
$(this).val(n.slice(0, -1))
else
$(this).val(n)
});
function isNumber(n) {
return (n===n+''||n===n-0) && n*0==0 && /\S/.test(n);
}
説明:
(n===n-0||n===n+'')n が数値か文字列かを検証します(配列、ブール値、日付、null などを破棄します)。で置き換えることができます(n===n-0||n===n+''):n!==undefined && n!==null && (n.constructor===Number||n.constructor===String)大幅に高速ですが、簡潔ではありません。
n*0==0n が有限数であるかどうかを検証isFinite(n)します。負の 16 進数を表す文字列をチェックする必要がある場合はn*0==0、n.toString().replace(/^\s*-/,'')*0==0.
もちろん多少の費用がかかりますので、必要なければ使わないでください。
/\S/.test(n)空白のみを含む空の文字列または文字列を破棄します(この場合は正を返すため必要isFinite(n) or n*0==0falseです) 。の代わりに を.test(n)使用することで の呼び出し回数を減らすことができます。または、次のようなわずかに高速ですが簡潔ではないテストを使用することもできます。(n!=0||/0/.test(n))/\S/.test(n)(n!=0||(n+'').indexOf('0')>=0)
https://github.com/arasatasaygin/is.jsのような型チェック ライブラリを使用するか、そこからチェック スニペットを抽出することができます ( https://github.com/arasatasaygin/is.js/blob/master/is .js#L131 ):
is.nan = function(value) { // NaN is number :)
return value !== value;
};
// is a given value number?
is.number = function(value) {
return !is.nan(value) && Object.prototype.toString.call(value) === '[object Number]';
};
一般に、(関数呼び出しのエントリ ポイントで) パラメータ タイプを検証する必要がある場合は、JSDOC 準拠のコントラクト ( https://www.npmjs.com/package/bycontract )を使用できます。
/**
* This is JSDOC syntax
* @param {number|string} sum
* @param {Object.<string, string>} payload
* @param {function} cb
*/
function foo( sum, payload, cb ) {
// Test if the contract is respected at entry point
byContract( arguments, [ "number|string", "Object.<string, string>", "function" ] );
}
// Test it
foo( 100, { foo: "foo" }, function(){}); // ok
foo( 100, { foo: 100 }, function(){}); // exception
@CMS の回答: nodejs を使用している私のマシンでは、空白のケースでスニペットが失敗しました。だから私はそれを @joelの次の答えと組み合わせました：
is_float = function(v) {
return !isNaN(v) && isFinite(v) &&
(typeof(v) == 'number' || v.replace(/^\s+|\s+$/g, '').length > 0);
}
フロートであるケースで単体テストを行いました：
var t = [
0,
1.2123,
'0',
'2123.4',
-1,
'-1',
-123.423,
'-123.432',
07,
0xad,
'07',
'0xad'
];
フロートではないケース (空の空白とオブジェクト/配列を含む):
var t = [
'hallo',
[],
{},
'jklsd0',
'',
"\t",
"\n",
' '
];
ここではすべてが期待どおりに機能します。たぶんこれが役立ちます。
このための完全なソース コードは、ここにあります。
私は簡単な解決策を見つけました。おそらく最善ではありませんが、うまく機能しています:)
次に、文字列を Int に解析し、現在 int 型になっている新しい変数の長さのサイズが元の文字列変数の長さと同じかどうかを確認します。論理的にサイズが同じ場合、文字列が完全に int に解析され、文字列が数値のみで「作成」されている場合にのみ可能であることを意味します。
var val=1+$(e).val()+'';
var n=parseInt(val)+'';
if(val.length == n.length )alert('Is int');
そのコードを簡単に関数に入れ、アラートの代わりに return true if int を使用できます。文字列でドットまたはコンマを使用している場合、int に解析しているため、まだ false であることを確認していることを忘れないでください。
注: e.val に 1+ を追加して、開始ゼロが削除されないようにします。
function isNumeric(n) {
var isNumber = true;
$.each(n.replace(/ /g,'').toString(), function(i, v){
if(v!=',' && v!='.' && v!='-'){
if(isNaN(v)){
isNumber = false;
return false;
}
}
});
return isNumber;
}
isNumeric(-3,4567.89); // true <br>
isNumeric(3,4567.89); // true <br>
isNumeric("-3,4567.89"); // true <br>
isNumeric(3d,4567.89); // false
この方法を使用して、変数が数値であることを確認します。
v * 1 == v
@Zoltan Lengyel 'other locales' コメント (4 月 26 日 2:14) @CMS Dec answer (2 '09 at 5:36):
次のテストをお勧めしますtypeof (n) === 'string'。
function isNumber(n) {
if (typeof (n) === 'string') {
n = n.replace(/,/, ".");
}
return !isNaN(parseFloat(n)) && isFinite(n);
}
これにより、Zoltans の推奨事項が拡張され、 のような「ローカライズされた数値」だけでなく、 のよう isNumber('12,50')な「純粋な」数値もテストできるようになりisNumber(2011)ます。
さて、私は自分で作ったこれを使っています...
これまでのところ機能しています：
function checkNumber(value) {
if ( value % 1 == 0 )
return true;
else
return false;
}
何か問題がありましたら、教えてください。
数字は何も残らず 1 で割り切れるはずなので、モジュールを使用するだけでよいと考えました。文字列を数字に分割しようとしても、結果はそうではありません。そう。
ここでは、このページから「良いもの」を集めて、自分で評価できるように簡単なテスト パターンにまとめました。
初心者向けconsole.logの組み込み関数 (最新のすべてのブラウザーで使用可能) を使用すると、結果を HTML ページに出力するのではなく、JavaScript コンソールに出力できます (探してみると見つかります)。
var isNumeric = function(val){
// --------------------------
// Recommended
// --------------------------
// jQuery - works rather well
// See CMS's unit test also: http://dl.getdropbox.com/u/35146/js/tests/isNumber.html
return !isNaN(parseFloat(val)) && isFinite(val);
// Aquatic - good and fast, fails the "0x89f" test, but that test is questionable.
//return parseFloat(val)==val;
// --------------------------
// Other quirky options
// --------------------------
// Fails on "", null, newline, tab negative.
//return !isNaN(val);
// user532188 - fails on "0x89f"
//var n2 = val;
//val = parseFloat(val);
//return (val!='NaN' && n2==val);
// Rafael - fails on negative + decimal numbers, may be good for isInt()?
// return ( val % 1 == 0 ) ? true : false;
// pottedmeat - good, but fails on stringy numbers, which may be a good thing for some folks?
//return /^-?(0|[1-9]\d*|(?=\.))(\.\d+)?$/.test(val);
// Haren - passes all
// borrowed from http://www.codetoad.com/javascript/isnumeric.asp
//var RE = /^-{0,1}\d*\.{0,1}\d+$/;
//return RE.test(val);
// YUI - good for strict adherance to number type. Doesn't let stringy numbers through.
//return typeof val === 'number' && isFinite(val);
// user189277 - fails on "" and "\n"
//return ( val >=0 || val < 0);
}
var tests = [0, 1, "0", 0x0, 0x000, "0000", "0x89f", 8e5, 0x23, -0, 0.0, "1.0", 1.0, -1.5, 0.42, '075', "01", '-01', "0.", ".0", "a", "a2", true, false, "#000", '1.2.3', '#abcdef', '', "", "\n", "\t", '-', null, undefined];
for (var i=0; i<tests.length; i++){
console.log( "test " + i + ": " + tests[i] + " \t " + isNumeric(tests[i]) );
}
以下も同様に機能する可能性があります。
function isNumeric(v) {
return v.length > 0 && !isNaN(v) && v.search(/[A-Z]|[#]/ig) == -1;
};