【发布时间】：2020-07-24 17:41:27
【问题描述】：
有谁知道如何在 JavaScript 中检查变量是数字还是字符串？
【问题讨论】：
标签： javascript types
【发布时间】：2020-07-24 17:41:27
【问题描述】：
效率测试
我知道我将使用哪种方式...
function isNumber(n) { return !isNaN(parseFloat(n)) && !isNaN(n - 0) }
function isNumberRE(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n); }
function test(fn, timerLabel) {
console.time(timerLabel)
for (i = 0; i < 1000000; i++) {
const num = Math.random() * 100
const isNum = fn(num)
}
console.timeEnd(timerLabel)
}
test(isNumber, "Normal way")
test(isNumberRE, "RegEx way")Normal way: 25.103271484375 ms
RegEx way: 334.791015625 ms
【讨论】：
注意typeof NaN 是... 'number'
typeof NaN === 'number'; // true
【讨论】：
简单彻底：
function isNumber(x) {
return parseFloat(x) == x
};
测试用例：
console.log('***TRUE CASES***');
console.log(isNumber(0));
console.log(isNumber(-1));
console.log(isNumber(-500));
console.log(isNumber(15000));
console.log(isNumber(0.35));
console.log(isNumber(-10.35));
console.log(isNumber(2.534e25));
console.log(isNumber('2.534e25'));
console.log(isNumber('52334'));
console.log(isNumber('-234'));
console.log(isNumber(Infinity));
console.log(isNumber(-Infinity));
console.log(isNumber('Infinity'));
console.log(isNumber('-Infinity'));
console.log('***FALSE CASES***');
console.log(isNumber(NaN));
console.log(isNumber({}));
console.log(isNumber([]));
console.log(isNumber(''));
console.log(isNumber('one'));
console.log(isNumber(true));
console.log(isNumber(false));
console.log(isNumber());
console.log(isNumber(undefined));
console.log(isNumber(null));
console.log(isNumber('-234aa'));
【讨论】：
-
这个答案有帮助，虽然它并没有真正回答原来的问题:)
-
等等，这不是错了吗？
const myVar = "5"; // Set it to a string. isNumber(myVar); // True, but it should be false since this variable is a string not a number. -
@DonP 是的，正如你和罗伊指出的那样，我的回答没有回答最初的问题。我在这里发布它是因为它似乎是一个有用的发现，并且是这里许多答案的更短/更好的版本，这些答案与确定一个值是否[已经是常规数字还是可以转换为一个的字符串]有关.
自 ES2015 起检查变量是否正确的方法
持有有效号码是Number.isFinite(value)
例子：
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
【讨论】：
-
这在 Internet Explorer 上不支持。 developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
-
不适用于字符串，这是原始问题。
-
这个答案很好，很简单！
-
这给出了问题的部分答案 - 但它是非常好的部分答案 - 三角形向上
类型检查
您可以使用typeof运算符检查变量的类型：
typeof variable
值检查
下面的代码对数字返回 true，对其他任何东西返回 false：
!isNaN(+variable);
【讨论】：
-
var 变量 = '123'; console.log(!isNaN(+变量));尽管它是字符串而不是数字类型，但给出 true
-
因为'123'是一个数字！如果您想知道变量的类型，您可以轻松使用
typeof运算符！ @JustAMartin -
是的，但最初的问题是区分任何字符串类型的变量和数字类型的变量。 '123` 仍然是一个字符串。如果我通过 123，答案应该是
number，但如果我通过 '123' 或 'abc' 或任何其他带引号的文字，它是一个字符串，它是否可以解析为数字并不重要。
最好的方法是使用isNaN + 类型转换：
更新全押方式：
function isNumber(n) { return !isNaN(parseFloat(n)) && !isNaN(n - 0) }
同样使用正则表达式：
function isNumber(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n); }
------------------------
isNumber('123'); // true
isNumber('123abc'); // false
isNumber(5); // true
isNumber('q345'); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber(' '); // false
【讨论】：
-
如果您想计算解析为有效数字的字符串，这看起来是一个不错的解决方案。
-
仅供参考：
null被强制为 0 并为isNumber(null);返回 true -
function is_number(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n);}有什么问题 -
对于诸如“123abc”之类的字符串也会失败。
-
@ash 谢谢，我已经更新了解决方案来涵盖这种情况。
或者只使用isNaN()的反转：
if(!isNaN(data))
do something with the number
else
it is a string
是的，使用 jQuery 的 $.isNumeric() 更划算。
【讨论】：
-
isNaN('123')给出错误，尽管参数是数字字符串而不是数字类型
XOR 操作可用于检测数字或字符串。 number ^ 0 将始终给出数字作为输出，字符串 ^ 0 将给出 0 作为输出。
Example:
1) 2 ^ 0 = 2
2) '2' ^ 0 = 2
3) 'Str' ^ 0 = 0
【讨论】：
试试这个，
<script>
var regInteger = /^-?\d+$/;
function isInteger( str ) {
return regInteger.test( str );
}
if(isInteger("1a11")) {
console.log( 'Integer' );
} else {
console.log( 'Non Integer' );
}
</script>
【讨论】：
-
尝试“-2”。它返回 false。
-
您为什么保留（或不编辑）无效的答案？ ...请注意，负数也可以是整数。
这是一种基于通过添加零或空字符串将输入强制转换为数字或字符串，然后进行类型相等比较的方法。
function is_number(x) { return x === x+0; }
function is_string(x) { return x === x+""; }
出于某种深不可测的原因，x===x+0 似乎比x===+x 表现更好。
有没有失败的情况？
同理：
function is_boolean(x) { return x === !!x; }
这似乎比x===true || x===false 或typeof x==="boolean" 稍快（并且比x===Boolean(x) 快得多）。
还有
function is_regexp(x) { return x === RegExp(x); }
所有这些都取决于是否存在特定于每种类型的“身份”操作，该操作可以应用于任何值并可靠地生成所讨论类型的值。我想不出这样的日期操作。
对于 NaN，有
function is_nan(x) { return x !== x;}
这基本上是下划线的版本，目前比isNaN() 快四倍，但下划线来源中的 cmets 提到“NaN 是唯一不等于自身的 数字 " 并添加检查 _.isNumber。为什么？还有哪些其他对象不等于它们自己？此外，下划线使用x !== +x--但这里的+ 有什么不同呢？
那么对于偏执狂：
function is_undefined(x) { return x===[][0]; }
或者这个
function is_undefined(x) { return x===void(0); }
【讨论】：
-
x !== +x 首先尝试将 x 转换为数字。
你正在寻找isNaN():
console.log(!isNaN(123));
console.log(!isNaN(-1.23));
console.log(!isNaN(5-2));
console.log(!isNaN(0));
console.log(!isNaN("0"));
console.log(!isNaN("2"));
console.log(!isNaN("Hello"));
console.log(!isNaN("2005/12/12"));请参阅 MDN 上的 JavaScript isNaN() Function。
【讨论】：
-
我觉得奇怪的是他们会为方法名称选择逆运算。调用 isNumber() 似乎更直观。
-
它实际上不是'isNumber'的逆运算。 NaN 是 javascript 中数字的特殊值。 isNaN 将提供给它的所有内容转换为数字并检查结果是否为 NaN。对于像“25”这样的字符串，你会得到不正确的结果。
-
我刚刚用 "25" 进行了测试，结果返回 false - 正如我所期望的那样。
-
NaN 是 IEEE 754 二进制浮点算术标准中的一个特殊值，而不仅仅是 JavaScript 的东西。 （好吧，准确地说：“IEEE 标准的 9007199254740990（即 (2^53)-2）个不同的“非数字”值在 ECMAScript 中表示为单个特殊的 NaN 值。” )
-
请记住，
isNaN为null返回false（但true为undefined）。
你觉得这个怎么样？
const numberOrString='10'
const isNumber = !isNaN(numberOrString*1)
【讨论】：
呃，怎么样：
function IsString(obj) {
return obj !== undefined && obj != null && obj.toLowerCase !== undefined;
}
经过几个月后的进一步审查，这只能保证obj 是一个定义了方法或属性名称toLowerCase 的对象。我为我的回答感到羞耻。请看票数最高的typeof 一个。
【讨论】：
在大多数情况下，typeof 对我来说效果很好。您可以尝试使用 if 语句
if(typeof x === 'string' || typeof x === 'number') {
console.log("Your statement");
}
其中 x 是您选择的任何变量名称
【讨论】：
-
这个答案比最受好评的答案添加了什么？
-
简洁明了？
对于检测数字，JavaScript 中的以下段落：Douglas Crockford 的 The Good Parts 是相关的：
isFinite 函数是确定一个值是否可以用作数字的最佳方法，因为它拒绝 NaN 和 Infinity 。不幸的是，isFinite 将尝试将其操作数转换为数字，因此如果值实际上不是数字，这不是一个好的测试。您可能想定义自己的 isNumber 函数：
var isNumber = function isNumber(value) { return typeof value === 'number' &&
isFinite(value);
};
【讨论】：
在检查变量是否为数字时创建了一个 jsperf。很有趣！ typeof 实际上有性能用途。将typeof 用于除数字以外的任何内容，速度通常是variable.constructor 的1/3，因为javascript 中的大多数数据类型都是对象；数字不是！
http://jsperf.com/jemiloii-fastest-method-to-check-if-type-is-a-number
typeof variable === 'number'|最快的 |如果你想要一个数字，比如 5，而不是 '5'typeof parseFloat(variable) === 'number'|最快的 |如果你想要一个数字，比如 5 和 '5'
isNaN() 较慢，但并没有那么慢。我对parseInt 和parseFloat 寄予厚望，但它们的速度慢得可怕。
【讨论】：
晚会很晚；但是，当我想一次性检查某个输入是字符串还是数字时，以下方法对我来说一直很有效。
return !!Object.prototype.toString.call(input).match(/\[object (String|Number)\]/);
【讨论】：
【讨论】：
function IsNumeric(num) {
return ((num >=0 || num < 0)&& (parseInt(num)==num) );
}
【讨论】：
我认为将 var 转换为字符串会降低性能，至少在最新浏览器中执行的 test 显示如此。
所以如果你关心性能，我会，我会用这个：
typeof str === "string" || str instanceof String
用于检查变量是否为字符串（即使您使用var str = new String("foo")，str instanceof String 也会返回 true）。
至于检查它是否是一个数字，我会选择原生：isNaN;功能。
【讨论】：
简单地使用
myVar.constructor == String
或
myVar.constructor == Number
如果你想处理定义为对象或文字的字符串并保存你不想使用辅助函数。
【讨论】：
jQuery 使用这个：
function isNumber(obj) {
return !isNaN( parseFloat( obj ) ) && isFinite( obj );
}
【讨论】：
如果您处理的是文字符号而不是构造函数，则可以使用typeof:。
typeof "Hello World"; // string
typeof 123; // number
如果您通过构造函数（例如var foo = new String("foo")）创建数字和字符串，您应该记住typeof 可能会为foo 返回object。
也许更简单的检查类型的方法是使用underscore.js中的方法（注释源可以找到here），
var toString = Object.prototype.toString;
_.isString = function (obj) {
return toString.call(obj) == '[object String]';
}
这将为以下内容返回一个布尔值 true：
_.isString("Jonathan"); // true
_.isString(new String("Jonathan")); // true
【讨论】：
-
分别表示“字符串”和“数字”
-
这是不正确的！字符串有两种可能的表示形式。 alert(typeof new String()) 将输出“对象”。更糟糕的是，为了优化目的，javascript 偶尔会在幕后的两种表示之间来回转换
-
@George 根据 OP，只会测试现有变量。
-
当然，但是假设我有函数 isString(str) { return typeof str === 'string' } 一些 Java 转换可以使用我的方法，就像
var myString = new String("stuff I like"); isString(myString)这样返回 false。另外，我不确定背景转换持续了多长时间，我知道当我调用“hi”.length 时，“hi”被转换为一个对象，不确定它多久会再次转换回来或者是否曾经绑定到变量。 -
是的，但是你想使用 String 对象吗？
此解决方案解决了此处提出的许多问题！
这是迄今为止我使用过的最可靠的方法。这不是我发明的，也不记得我最初是在哪里找到它的。但它适用于其他技术失败的地方：
// Begin public utility /getVarType/
// Returns 'Function', 'Object', 'Array',
// 'String', 'Number', 'Boolean', or 'Undefined'
getVarType = function ( data ){
if (undefined === data ){ return 'Undefined'; }
if (data === null ){ return 'Null'; }
return {}.toString.call(data).slice(8, -1);
};
// End public utility /getVarType/
正确性示例
var str = new String();
console.warn( getVarType(str) ); // Reports "String"
console.warn( typeof str ); // Reports "object"
var num = new Number();
console.warn( getVarType(num) ); // Reports "Number"
console.warn( typeof num ); // Reports "object"
var list = [];
console.warn( getVarType( list ) ); // Reports "Array"
console.warn( typeof list ); // Reports "object"
【讨论】：
-
Tarazaburo，我不知道你从哪里得到你的数据，但需要进行一些基准测试：
-
我不觉得这“真的很慢”。测试速度超过 100 万次迭代，我发现它并不比 Chrome 上原生
typeof方法（0.788s vs 1.481s）的一半速度差。考虑到改进的结果，这当然是可以接受的性能。为什么你认为它“真的很慢”？也许是 - 在 IE6/7/8 中？但在那些浏览器中，一切“真的很慢”。 -
好吧，我这么说是因为我已经完成了基准测试。在jsperf.com/check-typeof-number-again 组装一个新的小家伙，
typeof的速度提高了 100 倍，我错过了什么？ -
您错过了这样一个事实，即在检查类型时，3m ops/s 对于大多数代码来说不是问题。无论如何，我都不会称其为“非常慢”。我的基准是这样的： var i,k, start=+new Date(); for ( i = 0; i
-
与备用的 delta 为 2-3x: var i,k, start=+new Date(); for ( i = 0; i
@BitOfUniverse 的回答不错，我想出一个新办法：
function isNum(n) {
return !isNaN(n/0);
}
isNum('') // false
isNum(2) // true
isNum('2k') // false
isNum('2') //true
我知道0 不能被分红，但这里的功能完美。
【讨论】：
由于带有 typeof 的字符串为 '1234' 将显示 'string'，并且不会发生相反的情况（typeof 123 将始终是数字），最好使用简单的正则表达式 /^\-?\d+$/.test(var)。或者更高级的匹配浮点数、整数和负数，/^[\-\+]?[\d]+\.?(\d+)?$/
.test 的重要方面是，如果 var 不是字符串，它不会抛出异常，值可以是任何值。
var val, regex = /^[\-\+]?[\d]+\.?(\d+)?$/;
regex.test(val) // false
val = '1234';
regex.test(val) // true
val = '-213';
regex.test(val) // true
val = '-213.2312';
regex.test(val) // true
val = '+213.2312';
regex.test(val) // true
val = 123;
regex.test(val) // true
val = new Number(123);
regex.test(val) // true
val = new String('123');
regex.test(val) // true
val = '1234e';
regex.test(val) // false
val = {};
regex.test(val) // false
val = false;
regex.test(val) // false
regex.test(undefined) // false
regex.test(null) // false
regex.test(window) // false
regex.test(document) // false
如果你正在寻找真正的类型，那么 typeof 就可以了。
【讨论】：
//testing data types accurately in JavaScript (opposed to "typeof")
//from http://bonsaiden.github.com/JavaScript-Garden/
function is(type, obj) {
var clas = Object.prototype.toString.call(obj).slice(8, -1);
return obj !== undefined && obj !== null && clas === type;
}
//basic usage
is('String', 'test'); // true
is('Array', true); // false
或者修改它以返回未知类型：
function realTypeOf(obj) {
return Object.prototype.toString.call(obj).slice(8, -1);
}
//usage
realTypeOf(999); // 'Number'
2012 年 5 月 12 日更新： 完整示例在Javascript: A Better typeof。
【讨论】：
-
关于
realTypeOf仍有改进空间：realTypeOf(NaN) -> "Number"与typeof同意的行为相同，但仍远非理想。
检查值是字符串文字还是字符串对象：
function isString(o) {
return typeof o == "string" || (typeof o == "object" && o.constructor === String);
}
单元测试：
function assertTrue(value, message) {
if (!value) {
alert("Assertion error: " + message);
}
}
function assertFalse(value, message)
{
assertTrue(!value, message);
}
assertTrue(isString("string literal"), "number literal");
assertTrue(isString(new String("String object")), "String object");
assertFalse(isString(1), "number literal");
assertFalse(isString(true), "boolean literal");
assertFalse(isString({}), "object");
检查一个数字是类似的：
function isNumber(o) {
return typeof o == "number" || (typeof o == "object" && o.constructor === Number);
}
【讨论】：
-
(o.constructor === String) 本身似乎就足够了，即使对于字符串文字也是如此。
-
如果 o === null 会导致异常
-
我喜欢这个解决方案。为了避免 null 情况下的异常，请使用 o["constructor"] 而不是 o.constructor
-
@VishalKumar 所以这就是你的全部需求：
function is (type, value) { return value["constructor"] === type; }?
你能把它除以 1 吗？
我认为问题可能是一个字符串输入，例如：“123ABG”
var Check = "123ABG"
if(Check == Check / 1)
{
alert("This IS a number \n")
}
else
{
alert("This is NOT a number \n")
}
只是我最近做的一种方式。
【讨论】：
-
如果它是一串数字，我认为他不希望它返回 true。也许使用 ===
错了？只需使用正则表达式！ :)
function isInteger(val) {
return val.match(/^[0-9]$/)
}
function isFloat(val) {
return val.match(/^[0-9]*/\.[0-9]+$/)
}
【讨论】：