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

Question

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

Answer 1

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

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

如果您正在创建通过构造数字和字符串,比如var foo = new String("foo"),你应该记住,typeof可能会返回object了foo.

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

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

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

Answer 5

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

从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

例子:

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

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

Answer 9

最好的方法:

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 10

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

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

Answer 11

你能把它除以1吗？

我假设问题是字符串输入,如:"123ABG"

var Check = "123ABG"

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

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

这是我最近做的一种方式.

Answer 12

呃,怎么样:

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

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

Answer 13

当心那typeof NaN是...'number'

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

Answer 14

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

所以如果你关心性能,我会,我会用它:

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

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

至于检查,如果它是一个数字我会去的原生:isNaN; 功能.

Answer 15

或者只使用isNaN的反转

如果(!isNaN(data))用数字做某事,那么它就是一个字符串

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

Answer 16

jQuery使用以下代码：

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

Answer 17

简单而彻底：

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