在 JavaScript 中验证十进制数字 - IsNumeric()
-
09-06-2019 - |
题
在 JavaScript 中验证十进制数字最干净、最有效的方法是什么?
奖励积分:
- 明晰。解决方案应该干净、简单。
- 跨平台。
测试用例:
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
解决方案
@乔尔的回答 非常接近,但在以下情况下会失败:
// 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);
}
附: 为 NaN & 是有限的 由于强制转换为数字而产生令人困惑的行为。在 ES6 中, Number.isNaN & 数是有限的 将解决这些问题。使用它们时请记住这一点。
更新 : 这是 jQuery 现在的做法(2.2-稳定版):
isNumeric: function(obj) {
var realStringObj = obj && obj.toString();
return !jQuery.isArray(obj) && (realStringObj - parseFloat(realStringObj) + 1) >= 0;
}
更新 : 角4.3:
export function isNumeric(value: any): boolean {
return !isNaN(value - parseFloat(value));
}
其他提示
啊啊!不要听正则表达式的答案。正则表达式对此很讨厌,我说的不仅仅是性能。使用正则表达式很容易犯一些微妙的、不可能发现的错误。
如果你不能使用 isNaN()
, ,这应该效果更好:
function IsNumeric(input)
{
return (input - 0) == input && (''+input).trim().length > 0;
}
它的工作原理如下:
这 (input - 0)
表达式强制 JavaScript 对您的输入值进行类型强制;首先必须将其解释为用于减法运算的数字。如果转换为数字失败,表达式将导致 NaN
. 。这 数字 然后将结果与您传入的原始值进行比较。由于左侧现在是数字,因此再次使用类型强制。既然双方的输入都从相同的原始值强制转换为相同的类型,您可能会认为它们应该始终相同(始终为真)。然而,有一条特殊的规则说 NaN
永远不等于 NaN
, ,因此无法转换为数字的值(并且只有无法转换为数字的值)将导致 false。
对长度的检查是针对涉及空字符串的特殊情况。另请注意,它在 0x89f 测试中失败,但这是因为在许多环境中,这是定义数字文字的好方法。如果您想捕获特定场景,您可以添加额外的检查。更好的是,如果这是您不使用的原因 isNaN()
然后把你自己的函数包装起来 isNaN()
这也可以做额外的检查。
总之, 如果你想知道一个值是否可以转换为数字,请实际尝试将其转换为数字。
我回去做了一些研究 为什么 空白字符串没有预期的输出,我想我现在得到了:空字符串被强制转换为 0
而不是 NaN
. 。只需在长度检查之前修剪字符串即可处理这种情况。
针对新代码运行单元测试,它只在无穷大和布尔文字上失败,唯一应该出现问题的是如果您正在生成代码(实际上,谁会输入文字并检查它是否是数字?你应该 知道),这会生成一些奇怪的代码。
但是,再一次, 使用它的唯一原因是如果由于某种原因你必须避免 isNaN()。
这种方法似乎效果很好:
function IsNumeric(input){
var RE = /^-{0,1}\d*\.{0,1}\d+$/;
return (RE.test(input));
}
并测试它:
// alert(TestIsNumeric());
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;
}
我借用了那个正则表达式 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
雅虎!用户界面 使用这个:
isNumber: function(o) {
return typeof o === 'number' && isFinite(o);
}
function IsNumeric(num) {
return (num >=0 || num < 0);
}
这也适用于 0x23 类型的数字。
接受的答案未通过您的测试#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
或原型 Object.isArray
代替 Object.prototype.toString.call(n) !== '[object Array]'
我的第二个问题是负十六进制整数文字字符串(“-0xA”-> -10)不被计为数字。但是,正十六进制整数文字字符串(“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 函数的结果,那么希望这会有所帮助。
编辑: 正如所指出的 贝尔吉, ,还有其他可能的对象可以被视为数字,并且白名单比黑名单更好。考虑到这一点,我会添加标准。
我希望我的 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>
是的,内置的 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
是有效数字(十六进制)
无需 RegExp 即可完成,如下所示
function IsNumeric(data){
return parseFloat(data)==data;
}
我意识到原来的问题没有提到 jQuery,但如果你确实使用 jQuery,你可以这样做:
$.isNumeric(val)
简单的。
https://api.jquery.com/jQuery.isNumeric/ (从 jQuery 1.7 开始)
如果我没记错的话,这应该匹配任何有效的 JavaScript 数值,不包括常量(Infinity
, NaN
) 和符号运算符 +
/-
(因为就我而言,它们实际上并不是数字的一部分,它们是单独的运算符):
我需要这个用于分词器,其中将数字发送到 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
return (input - 0) == input && input.length > 0;
不适合我。当我发出警报并进行测试时, input.length
曾是 undefined
. 。我认为没有属性可以检查整数长度。所以我所做的是
var temp = '' + input;
return (input - 0) == input && temp.length > 0;
效果很好。
对我来说,这是最好的方法:
isNumber : function(v){
return typeof v === 'number' && isFinite(v);
}
我遇到的唯一问题是@CMS 回答 是排除 NaN
和无穷大,这些数字在许多情况下都是有用的。一种检查方法 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 与另一个优雅的非常接近 回答, ,但处理数字的十六进制和其他字符串表示形式。
整数值可以通过以下方式验证:
function isNumeric(value) {
var bool = isNaN(+value));
bool = bool || (value.indexOf('.') != -1);
bool = bool || (value.indexOf(",") != -1);
return !bool;
};
这种方式更加简单快捷!所有测试均已检查!
这是我使用的一个稍微改进的版本(可能是最快的方法),而不是精确的 jQuery 变体,我真的不知道他们为什么不使用这个:
function isNumeric(val) {
return !isNaN(+val) && isFinite(val);
}
jQuery 版本的缺点是,如果您传递一个带有前导数字和尾随字母的字符串,例如 "123abc"
这 parseFloat | parseInt
将提取数字分数并返回 123,但是,第二个守卫 isFinite
无论如何都会失败。与一元 +
操作员将死于第一个后卫,因为 +为这种混合动力车投掷了NAN :)有点表演,但我认为具有可靠的语义增长。
我想添加以下内容:
1. IsNumeric('0x89f') => true
2. IsNumeric('075') => true
正十六进制数字开头为 0x
负十六进制数开头为 -0x
。正八进制数开头为 0
和负八进制数开头 -0
。这个考虑了已经提到的大部分内容,但包括十六进制和八进制数、负科学数、无穷大并删除了十进制科学数 (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));
}
需要添加几个测试:
IsNumeric('01.05') => false
IsNumeric('1.') => false
IsNumeric('.') => false
我想出了这个:
function IsNumeric(input) {
return /^-?(0|[1-9]\d*|(?=\.))(\.\d+)?$/.test(input);
}
该解决方案涵盖:
- 开头有一个可选的负号
- 单个零,或不以 0 开头的一个或多个数字,或者只要后面有一个句点就什么都没有
- 句点后跟 1 个或多个数字
我的解决方案,
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 isNumeric(n)
{
var n2 = n;
n = parseFloat(n);
return (n!='NaN' && n2==n);
}
解释:
创建自身的副本,然后将数字转换为浮点数,然后将自身与原始数字进行比较,如果它仍然是数字(无论是整数还是浮点数),并且与原始数字匹配,则意味着它确实是一个数字。
它适用于数字字符串和普通数字。不适用于十六进制数字。
警告:使用风险自负,无任何保证。
没有任何答案返回 false
对于空字符串,修复该问题...
function is_numeric(n)
{
return (n != '' && !isNaN(parseFloat(n)) && isFinite(n));
}
检查变量是否包含有效数字,而不仅仅是一个看起来像一个数字的字符串,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
我正在使用更简单的解决方案:
function isNumber(num) {
return parseFloat(num).toString() == num
}
我意识到这个问题已经被回答过很多次了,但以下是一个不错的候选者,在某些情况下可能很有用。
应该注意的是,它假定“ .42”不是数字,而是“ 4.”。不是数字,因此应考虑到这一点。
function isDecimal(x) {
return '' + x === '' + +x;
}
function isInteger(x) {
return '' + x === '' + parseInt(x);
}
这 isDecimal
通过以下测试:
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');
}
这里的想法是每个数字或整数都有一个“规范”字符串表示形式,并且每个非规范表示形式都应该被拒绝。所以我们转换为一个数字然后返回,看看结果是否是原始字符串。
这些功能是否对您有用取决于用例。一个特点是 不同的字符串代表不同的数字 (如果两者都通过了 isNumber()
测试)。
这是相关的,例如对于数字作为对象属性名称。
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({ 数字:真的});
测试用例
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
您可以通过多种方式最小化此函数,还可以使用负值或自定义图表的自定义正则表达式来实现它:
$('.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 inNumeric(n){
return Number(n).toString() === n;
}
如果 n 是数字 Number(n)
将返回数值并且 toString()
会将其转回字符串。但如果 n 不是数字 Number(n)
将返回 NaN
所以它不会匹配原来的 n
我认为 parseFloat 函数可以完成这里的所有工作。下面的函数通过了此页面上的所有测试,包括 isNumeric(Infinity) == true
:
function isNumeric(n) {
return parseFloat(n) == n;
}
@CMS的回答: :您的代码片段在我的机器上使用 nodejs 的空白情况下失败了。所以我把它与@乔尔的回答 至以下内容:
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",
' '
];
这里一切都按预期进行。也许这有帮助。
可以找到完整的源代码 这里.