关于类型：检查JavaScript中的变量是数字还是字符串

Check whether variable is number or string in JavaScript

有人知道如何在javascript中检查变量是数字还是字符串吗？

如果处理的是文字符号，而不是构造函数，则可以使用typeof:。

1 2	typeof"Hello World"; // string typeof 123; // number

如果您通过一个构造函数(如var foo = new String("foo")创建数字和字符串)，您应该记住，typeof可能会为foo返回object。

检查类型的更简单的方法可能是使用在underline.js中找到的方法(此处可以找到带注释的源代码)。

1
2
3
4
5

var toString = Object.prototype.toString;

_.isString = function (obj) {
return toString.call(obj) == '[object String]';
}

这将为以下项返回一个布尔值true：

1 2	_.isString("Jonathan"); // true _.isString(new String("Jonathan")); // true

相关讨论

最好的方法是使用isnan+类型转换：

更新了All-In方法：

1	function isNumber(n) { return !isNaN(parseFloat(n)) && !isNaN(n - 0) }

使用regex的方法相同：

1
2
3
4
5
6
7
8
9
10
11
12

function isNumber(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n); }

------------------------

isNumber ('123'); // true
isNumber ('123abc'); // true
isNumber (5); // true
isNumber ('q345'); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber(' '); // false

相关讨论

我找到的最佳方法是检查字符串上的方法，即：

1
2
3
4
5

if (x.substring) {
// do string thing
} else{
// do other thing
}

或者，如果要对数字属性进行数字检查，

1
2
3
4
5

if (x.toFixed) {
// do number thing
} else {
// do other thing
}

这有点像"鸭子打字"，这取决于你选择哪种方式最有意义。我没有足够的业力来评论，但是对于盒装字符串和数字的typeof失败，即：

1 2	alert(typeof new String('Hello World')); alert(typeof new Number(5));

将警告"对象"。

相关讨论

检查该值是字符串文字还是字符串对象：

1
2
3

function isString(o) {
return typeof o =="string" || (typeof o =="object" && o.constructor === String);
}

单元测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

检查数字类似：

1
2
3

function isNumber(o) {
return typeof o =="number" || (typeof o =="object" && o.constructor === Number);
}

相关讨论

你在找isNaN()：

1
2
3
4
5
6
7
8

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()函数。

相关讨论

自ES2015以来，检查变量持有的有效号码是Number.isFinite(value)。

实例：

1
2
3
4
5
6
7
8
9

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

相关讨论

试试这个，

1
2
3
4
5
6
7
8
9
10
11

var regInteger = /^\d+$/;

function isInteger( str ) {
return regInteger.test( str );
}

if(isInteger("1a11")) {
console.log( 'Integer' );
} else {
console.log( 'Non Integer' );
}

相关讨论

1
2
3
4
5
6
7
8
9
10

//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

或者调整它以返回未知类型：

1
2
3
4
5
6

function realTypeOf(obj) {
return Object.prototype.toString.call(obj).slice(8, -1);
}

//usage
realTypeOf(999); // 'Number'

2012年5月12日更新：javascript的完整示例：更好的类型。

相关讨论

最好的方法是：

1
2
3

function isNumber(num) {
return (typeof num == 'string' || typeof num == 'number') && !isNaN(num - 0) && num !== '';
};

这满足以下测试用例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

assertEquals("ISNUMBER-True: 0", true, isNumber(0));
assertEquals("ISNUMBER-True: 1", true, isNumber(-1));
assertEquals("ISNUMBER-True: 2", true, isNumber(-500));
assertEquals("ISNUMBER-True: 3", true, isNumber(15000));
assertEquals("ISNUMBER-True: 4", true, isNumber(0.35));
assertEquals("ISNUMBER-True: 5", true, isNumber(-10.35));
assertEquals("ISNUMBER-True: 6", true, isNumber(2.534e25));
assertEquals("ISNUMBER-True: 7", true, isNumber('2.534e25'));
assertEquals("ISNUMBER-True: 8", true, isNumber('52334'));
assertEquals("ISNUMBER-True: 9", true, isNumber('-234'));

assertEquals("ISNUMBER-False: 0", false, isNumber(NaN));
assertEquals("ISNUMBER-False: 1", false, isNumber({}));
assertEquals("ISNUMBER-False: 2", false, isNumber([]));
assertEquals("ISNUMBER-False: 3", false, isNumber(''));
assertEquals("ISNUMBER-False: 4", false, isNumber('one'));
assertEquals("ISNUMBER-False: 5", false, isNumber(true));
assertEquals("ISNUMBER-False: 6", false, isNumber(false));
assertEquals("ISNUMBER-False: 7", false, isNumber());
assertEquals("ISNUMBER-False: 8", false, isNumber(undefined));
assertEquals("ISNUMBER-False: 9", false, isNumber(null));

这里有一种方法，它基于这样的思想：通过添加零或空字符串将输入强制为数字或字符串，然后进行类型化的相等比较。

1 2	function is_number(x) { return x === x+0; } function is_string(x) { return x === x+""; }

由于一些难以理解的原因，x===x+0的表现似乎比x===+x好。

有没有失败的情况？

以同样的方式：

1	function is_boolean(x) { return x === !!x; }

这似乎比x===true || x===false或typeof x==="boolean"稍快(比x===Boolean(x)快得多)。

还有

1	function is_regexp(x) { return x === RegExp(x); }

所有这些都取决于特定于每种类型的"标识"操作的存在，该操作可以应用于任何值，并可靠地生成所讨论类型的值。我想不出这样的约会手术。

对于南来说，有

1	function is_nan(x) { return x !== x;}

这基本上是underline的版本，现在的速度比isNaN()快四倍，但在underline源中的注释提到"NaN是唯一不等于自身的数字"，并添加了对.isNumber的检查。为什么？还有什么其他物体不等于它们自己？另外，下划线使用了x !== +x--但是这里的+有什么区别呢？

然后对于偏执狂：

1	function is_undefined(x) { return x===[][0]; }

相关讨论

你能把它除以1吗？

我假设问题是一个字符串输入，比如："123abg"

1
2
3
4
5
6
7
8
9
10
11
12
13

var Check ="123ABG"

if(Check == Check / 1)
{
alert("This IS a number
")
}

else
{
alert("This is NOT a number
")
}

就像我最近做的那样。

相关讨论

呃，就这样吧：

1
2
3

function IsString(obj) {
return obj !== undefined && obj != null && obj.toLowerCase !== undefined;
}

经过几个月后的进一步审查，这只能保证obj是定义了方法或属性名toLowerCase的对象。我为我的回答感到羞愧。请看投票最高的typeof1。

我认为将var转换为字符串会降低性能，至少在最新的浏览器中执行的这个测试显示了这一点。

所以如果你关心性能，我会用这个：

1	typeof str ==="string" \|\| str instanceof String

用于检查变量是否为字符串(即使使用var str = new String("foo")，str instanceof String也将返回true)。

至于检查它是否是一个本地的数字，我会选择：isNaN；函数。

或者只用isnan的倒转

如果(！)伊斯南(数据)用这个号码做点什么其他的它是一根绳子

是的-使用jquery-.isNumeric()对Buck来说更有趣。

jquery使用以下方法：

1
2
3

function isNumber(obj) {
return !isNaN( parseFloat( obj ) ) && isFinite( obj );
}

这个解决方案解决了这里提出的许多问题！

这是迄今为止我使用的最可靠的方法。我没有发明这个，也记不起它是在哪里发现的。但在其他技术失败的情况下，它也能发挥作用：

1
2
3
4
5
6
7
8
9

// 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/

正确性示例

1
2
3
4
5
6
7
8
9
10
11

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，我不知道你在哪里得到你的日期，但这是在benchmarkining阶：
我发现这真的很慢。"测试速度超过1百万iterations更糟，我发现它在本地的速度比半typeof法(0.788s VS 1.481s)在线浏览器。这是一个可接受的性能，在考虑一定的改进的结果。为什么你认为它是"真的很慢吗？"也许它是在ie6／7／8？"真的很慢，但都是在那些浏览器。
嗯，我有这样做，因为我已经说的标杆。放在一起一个新的小jsperf.com /检查一类数是100，和typeof更快，我缺少的是什么？
事实上，你是失踪的是3M公司的OPS / S是一个非问题是大多数代码当检测类型。我不是说"真的很慢的呼叫任何措施。我很喜欢这一点：VAR＝＋，K，新的开始日期()；for(i＝0；i＜1；i＋＋)｛k＝g(K = foo()；}；类型；123.5)=新的日期(+端(端)；console.log启动)；
在三角洲的交替是2倍：var i = +，K，启动新的日期()；for(i＝0；i＜1；i＋＋)｛getvartype(K = K = foo()；}；getvartype 123.5)；新的日期(+端)；console.log(启动端)；
这两个也比较。我到了减少随机字符串缓存优化的影响。我们要利用这getvartype 4383ms；replacing得到操作系统类型1与类型2是一2211ms ~。。。。。。。。。。。。。。。我不是要在这失去任何睡眠。代码：VAR＝I，K +，启动新的日期()；for(i＝0；i＜1；i＋＋)｛k = getvartype(foo’+(math.random字符串(0))getvartype)；K＝(100×math.random(0)；} end = +新Date()；console.log(启动端)；
这是公平的，一类是在认识到virtually OP和toString是非常慢的。但在阅读代码的世界，getvartype(费用)是相对于周围的小代码，上面的插图。如果我需要检查在代码块型的三倍，它的成本我门0.003ms(getvartype)或0.000ms(型)。这个速度差问题的正确性，极少；然而，也。
好吧，当然你是对的，在总体计划中，这可能没有什么区别。我的意思是"非常缓慢"的相对，而不是绝对，术语。但我对你关于"正确性"的观点很好奇；在这种情况下，typeof x==="number"是不正确的？
hi torazaboru：当您这样做时，正确性问题会产生：var num=new number()；console.log(typeof(num))；-这报告一个对象，而不是一个数字。数组、字符串等也有类似的结果。请参阅原始文章中列出的示例。就我个人而言，我确实在某些情况下使用typeof，但需要知道它的局限性：)
Torazaboru：请在stackoverflow.com/questions/17440517查看我的新答案。总之，有一些边缘情况，特别是在使用firefox dom元素时，需要特殊处理。
我想世界上用number()构造函数创建的数字可以用一只手的手指来计算。有人能首先为它提供一个用例吗？
一个dom元素是一个dom元素，而不是一个数字或字符串，那么它是如何与这个问题相关的呢？如果您引用的是伪数组，比如getElementsByTagName返回的伪数组，那么它们不是数组，我不希望某个类型检查系统告诉我它们是。
我指的是psuedo数组，例如document.stylesheets提供的数组。出于我的目的，我通常喜欢将这些报告为数组。可以说所有的javascript数组都是psuedo数组。这取决于你想在哪里画线。
事实上，typeof为数字、字符串、数组、布尔值和其他此类构造提供了不正确的结果。是的，很少使用数字，但大量使用数组。我的程序的主要目标是尽可能正确地识别所提供变量的使用意图。绝对速度很重要(例如3000次操作/毫秒很好)，但正确性比速度重要。

在大多数情况下，这种类型对我来说都很好。您可以尝试使用if语句

1
2
3

if(typeof x === 'string' || typeof x === 'number') {
console.log("Your statement");
}

其中x是您选择的任何变量名

相关讨论

jsut an fyi，如果您使用jquery，

1	$.isNumeric()

处理这件事。有关更多详细信息，请访问http://api.jquery.com/jquery.isnumeric/

我发现，考虑正负数的最佳方法是：O'Reilly JavaScript和DHTML食谱：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

}

埃尔？只需使用正则表达式！：)

1
2
3
4
5
6
7

function isInteger(val) {
return val.match(/^[0-9]$/)
}

function isFloat(val) {
return val.match(/^[0-9]*/\.[0-9]+$/)
}

@BitofUniverse的答案很好，我想出了一个新方法：

1
2
3
4
5
6
7
8

function isNum(n) {
return !isNaN(n/0);
}

isNum('') // false
isNum(2) // true
isNum('2k') // false
isNum('2') //true

我知道0不能是被除数，但这里的函数工作得很好。

由于typeof为"1234"的字符串将显示"string"，而反转永远不会发生(typeof 123始终是数字)，因此最好使用简单的regex /^\-?\d+$/.test(var)。或者更高级的匹配浮点数、整数和负数的方法，/^[\-\+]?[\d]+\.?(\d+)?$/。.test的重要方面是，如果var不是字符串，它不会抛出异常，值可以是任何东西。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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就可以了。

您只需使用：

1	!isNaN(+variable);

简单使用

1	myVar.constructor == String

或

1	myVar.constructor == Number

如果要处理定义为对象或文本的字符串并保存，则不希望使用助手函数。

1
2
3

function IsNumeric(num) {
return ((num >=0 || num < 0)&& (parseInt(num)==num) );
}

参加聚会很晚；但是，当我想检查某个输入是否是一个字符串或一个数字时，下面的内容总是对我很好。

1	return !!Object.prototype.toString.call(input).match(/\[object (String\|Number)\]/);

在检查变量是否为数字时创建了JSPERF。很有趣！typeof实际上有一个性能用途。使用typeof处理数字以外的任何数据，通常速度是variable.constructor的1/3，因为javascript中的大多数数据类型都是对象；数字不是！

http://jsferf.com/jemiloii-fastest-method-to-check-if-type-is-a-number

如果你想要一个数字，比如5，而不是"5"，那么typeof variable === 'number'是最快的。如果你想要一个数字，比如5和"5"，typeof parseFloat(variable) === 'number'最快

isNaN()的速度较慢，但没有那么慢。我对parseInt和parseFloat抱有很高的希望，但他们的速度慢得可怕。

为了检测数字，下面一段来自javascript：Douglas Crockford的好部分是相关的：

The isFinite function is the best way of determining whether a value can be used as a number because it rejects NaN and Infinity . Unfortunately, isFinite will attempt to convert its operand to a number, so it is not a good test if a value is not actually a number. You may want to define your own isNumber function:

1
2
3

var isNumber = function isNumber(value) { return typeof value === 'number' &&
isFinite(value);
};

你觉得这个怎么样？

1 2	const numberOrString='10' const isNumber = !isNaN(numberOrString*1)