在JavaScript中检查变量是否为数字或字符串

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

690236 次浏览

小开

最佳答案

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

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

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

也许更简单的检查类型的方法是利用underscore.js中找到的方法(带注释的源代码可以在在这里中找到)，

var toString = Object.prototype.toString;


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

这将为以下对象返回一个布尔值true:

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

小开

试试这个,

<script>
var regInteger = /^-?\d+$/;


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


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

小开

你正在寻找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()函数。

小开

最好的方法是使用isNaN +类型转换:

更新的all-in方法:

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

使用regex也一样:

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

小开

我发现的最好的方法是检查字符串上的方法，即:

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

或者如果你想对number属性做一些检查，

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

这有点像“鸭子打字”，由你自己决定哪种方式最有意义。我没有足够的因果报应来评论，但typeof失败的盒装字符串和数字，即:

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

将提醒“对象”。

小开

//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:一种更好的类型的完整示例

小开

最好的方法是:

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

这满足以下测试用例:

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));

小开

呃，不如这样:

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

经过几个月后的进一步检查，这只能保证obj是一个定义了方法或属性名toLowerCase的对象。我为我的回答感到惭愧。请参阅票数最高的typeof。

小开

我发现的同时考虑正数和负数的最好方法是: # EYZ0: < / p >

function isNumber(elem) {
var str = elem.value;
var oneDecimal = false;
var oneChar = 0;
// make sure value hasn't cast to a number data type
str = str.toString( );
for (var i = 0; i < str.length; i++) {
oneChar = str.charAt(i).charCodeAt(0);
// OK for minus sign as first character
if (oneChar =  = 45) {
if (i =  = 0) {
continue;
} else {
alert("Only the first character may be a minus sign.");
return false;
}
}
// OK for one decimal point
if (oneChar =  = 46) {
if (!oneDecimal) {
oneDecimal = true;
continue;
} else {
alert("Only one decimal is allowed in a number.");
return false;
}
}
// characters outside of 0 through 9 not OK
if (oneChar < 48 || oneChar > 57) {
alert("Enter only numbers into the field.");
return false;
}
}
return true;

｝

小开

哦?使用正则表达式!：）

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


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

小开

能把它除以1吗?

我假设问题将是一个字符串输入，如:"123ABG"

var Check = "123ABG"


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


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

我最近就是这么做的。

小开

检查值是否为string字面值或string对象:

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);
}

小开

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

这是迄今为止我用过的最可靠的方法。这不是我发明的，也不记得我最初是在哪里找到它的。但它在其他技术失败的地方奏效:

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

小开

因为字符串'1234'和typeof将显示'string'，而相反的情况永远不会发生(typeof 123将永远是数字)，最好是使用一个简单的正则表达式/^\-?\d+$/.test(var)。或者更高级的匹配浮点数、整数和负数的/^[\-\+]?[\d]+\.?(\d+)?$/ .test的重要方面是，如果var不是字符串，它不会抛出异常，它的值可以是任何东西。< / p >

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

小开

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

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


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

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

小开

下面是一种基于通过添加零或空字符串将输入强制为数字或字符串的方法，然后进行类型化的相等比较。

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()快四倍，但下划线源代码中的注释提到“NaN是唯一不等于自己的数量”，并添加了_.isNumber检查。为什么?还有什么物体不与它们相等呢?同样，下划线使用x !== +x——但是这里的+有什么区别呢?

对于偏执狂来说:

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

或者这个

function is_undefined(x) { return x===void(0); }

小开

jQuery使用这个:

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

小开

简单地使用

myVar.constructor == String

或

myVar.constructor == Number

如果要处理定义为对象或字面量并保存的字符串，则不需要使用helper函数。

小开

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

如果你关心性能，我会用这个:

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

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

至于检查它是否是一个数字，我将使用本机:isNaN;函数。

小开

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

小开

仅供参考，如果你使用jQuery你有

$.isNumeric()

来处理这个问题。更多关于http://api.jquery.com/jQuery.isNumeric/的细节

小开

或者使用isNaN()的倒数:

if(!isNaN(data))
do something with the number
else
it is a string

是的，使用jQuery的$.isNumeric()更有趣。

小开

聚会很晚才来;然而，当我想一次性检查某些输入是字符串还是数字时，下面的方法总是很有效。

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

小开

创建了一个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'
如果你想要一个数字，比如5，和'5'

isNaN()较慢，但并没有慢很多。我对parseInt和parseFloat寄予厚望，但它们的速度慢得可怕。

小开

对于数字检测，以下文章来自Douglas Crockford的JavaScript: the Good Parts:

isFinite函数是确定一个值是否可以用作数字的最佳方法，因为它拒绝NaN和Infinity。不幸的是，isFinite将尝试将其操作数转换为一个数字，因此如果一个值实际上不是一个数字，那么它不是一个好的测试。你可能想要定义自己的isNumber函数:

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

小开

Typeof在大多数情况下都很适合我。您可以尝试使用if语句

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

x是任意变量名

小开

自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

小开

你觉得这个怎么样?

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

小开

类型检查

你可以使用typeof操作符检查变量的类型:

typeof variable

值检查

下面的代码对数字返回true，对其他任何值返回false:

!isNaN(+variable);

小开

异或操作可用于检测数字或字符串。 数字^ 0将始终以相同的数字作为输出，而字符串^ 0将以0作为输出

Example: 1) 2 ^ 0 = 2 2) '2' ^ 0 = 2 3) 'Str' ^ 0 = 0

小开

简单而彻底:

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'));

小开

注意typeof NaN是…# EYZ2

typeof NaN === 'number'; // true

小开

效率测试

我知道我该怎么用…

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

提交答案