Question

有谁知道如何在JavaScript中检查变量是数字还是字符串？

Answer 1

如果您正在处理文字符号而不是构造函数，则可以使用typeof :.

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

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

或许更简单的检查类型的方法是使用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

Answer 2

最好的方法是使用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'); // true  
isNumber (5); // true  
isNumber ('q345'); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber('   '); // false

Answer 3

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

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

或者如果您想对数字属性的数字检查执行某些操作，

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

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

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

会提醒“对象”。

Answer 4

检查值是字符串文字还是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);
}

Answer 5

您正在寻找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。

Answer 6

自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

Answer 7

试试这个，

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

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

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

Answer 8

最好的方法：

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

Answer 9

//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上的完整示例。

Answer 10

你能把它除以1吗？

我认为问题是字符串输入，如：“123ABG”

var Check = "123ABG"

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

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

我最近这样做了。

Answer 11

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

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

Answer 12

呃，怎么样：

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

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

Answer 13

或者只使用isNaN的反转

如果

（！isNaN（数据））用数字做点什么其他它是一个字符串

是的 - 使用jQuery - $ .isNumeric（）更有趣。

Answer 14

我认为将var转换为字符串会降低性能，至少在最新浏览器中执行此test会显示出来。

所以，如果你关心表现，我会，我会用它：

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

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

至于检查它是否是一个数字，我会选择本地人：isNaN;功能

Answer 15

jQuery使用它：

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

Answer 16

在大多数情况下，

typeof对我来说效果很好。您可以尝试使用if语句

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

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

Answer 17

只是一个FYI，如果您使用的是jQuery，那么

$.isNumeric()

来处理这个问题。有关http://api.jquery.com/jQuery.isNumeric/

的更多详情

Answer 18

此解决方案解决了此处提出的许多问题！

这是迄今为止我用过的最可靠的方法。我没有发明这个，也记不起我最初发现它的地方。但它适用于其他技术失败的地方：

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

Answer 19

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

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

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

我知道0不能被分红，但这里的功能完美无缺。

Answer 20

因为带有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

如果您正在寻找真实的类型，那么就可以单独输入。

Answer 21

Errr？只需使用正则表达式！：）

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

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

Answer 22

我发现的最佳方式也是正面和负面的数字来自： O'Reilly Javascript and DHTML Cookbook：

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;

}

Answer 23

请注意typeof NaN是... 'number'

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

Answer 24

只需使用

myVar.constructor == String

或

myVar.constructor == Number

如果你想处理定义为对象或文字的字符串并保存你不想使用辅助函数。

Answer 25

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

Answer 26

聚会很晚;但是，当我想检查一些输入是一个字符串还是一次性的数字时，以下对我来说总是运作良好。

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

Answer 27

在检查变量是否为数字时创建了一个jsperf。很有趣！ typeof实际上有性能用途。使用typeof除了数字之外的其他任何东西，由于javascript中的大多数数据类型都是对象，因此速度通常为variable.constructor的1/3。数字不是！

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

typeof variable === 'number' |最快的如果你想要一个数字，比如5，而不是＆＃39; 5＆＃39;
typeof parseFloat(variable) === 'number' |最快的如果你想要一个数字，比如5和＆＃39; 5＆＃39;

isNaN()速度较慢，但速度并不慢。我对parseInt和parseFloat寄予厚望，但它们的速度非常慢。

Answer 28

为了检测数字，来自JavaScript的以下段落：道格拉斯克罗克福德的好部分是相关的：

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

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

Answer 29

您对此有何看法？

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

Answer 30

您可以使用：

!isNaN(+variable);

Answer 31

XOR操作可用于检测数字或字符串。 数字^ 0将始终将数字作为输出，而字符串^ 0将始终将0作为输出。

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

Answer 32

这似乎很好：

function isNumber(x) {
  return parseFloat(x) == x
};

console.log('trues');
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('falses');
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'));

（我在这里从另一个答案中提取了大多数测试用例。）

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

32 个答案: