有谁知道如何检查JavaScript中的变量是数字还是字符串?
#1楼
如果要处理文字符号而不是构造函数,则可以使用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
#2楼
尝试这个,
<script>
var regInteger = /^-?\d+$/;
function isInteger( str ) {
return regInteger.test( str );
}
if(isInteger("1a11")) {
console.log( 'Integer' );
} else {
console.log( 'Non Integer' );
}
</script>
#3楼
您正在寻找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()函数 。
#4楼
此解决方案解决了这里提出的许多问题!
到目前为止,这是我迄今为止使用的最可靠的方法。 我没有发明它,也无法回忆起最初发现它的地方。 但是它在其他技术失败的地方起作用:
// 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"
#5楼
最好的方法是使用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
#6楼
由于类型为'1234'且类型为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即可。
#7楼
@BitOfUniverse的答案很好,我想出了一种新方法:
function isNum(n) {
return !isNaN(n/0);
}
isNum('') // false
isNum(2) // true
isNum('2k') // false
isNum('2') //true
我知道0
不能被除数,但是这里的功能可以正常工作。
#8楼
这是一种基于以下想法的方法:通过添加零或空字符串将输入强制为数字或字符串,然后进行类型相等性比较。
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
稍快一些。 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()
但在下划线来源的评论提到,“南的是,不等于自己唯一的编号 ”,并增加了_.isNumber检查。 为什么? 还有哪些其他对象不等于自己? 另外,下划线使用x !== +x
但是这里的+
什么区别?
然后对于偏执狂:
function is_undefined(x) { return x===[][0]; }
或这个
function is_undefined(x) { return x===void(0); }
#9楼
jQuery使用以下代码:
function isNumber(obj) {
return !isNaN( parseFloat( obj ) ) && isFinite( obj );
}
#10楼
只需使用
myVar.constructor == String
要么
myVar.constructor == Number
如果要处理定义为对象或文字的字符串并进行保存,则不想使用辅助函数。
#11楼
我认为将var转换为字符串会降低性能,至少在最新的浏览器中执行的此测试表明如此。
因此,如果您关心性能,我会使用:
typeof str === "string" || str instanceof String
用于检查变量是否为字符串(即使您使用var str = new String("foo")
, str instanceof String
也会返回true)。
至于检查它是否是一个数字,我会去找当地人: isNaN
; 功能。
#12楼
function IsNumeric(num) {
return ((num >=0 || num < 0)&& (parseInt(num)==num) );
}
#13楼
仅供参考,如果您使用的是jQuery,
$.isNumeric()
处理这个。 有关http://api.jquery.com/jQuery.isNumeric/的更多详细信息
#14楼
或者只是使用isNaN()
的反isNaN()
:
if(!isNaN(data))
do something with the number
else
it is a string
是的,使用jQuery的$.isNumeric()
更加有趣。
#15楼
晚会很晚; 但是,当我想检查某些输入是字符串还是数字时,以下内容对我来说一直很有效。
return !!Object.prototype.toString.call(input).match(/\[object (String|Number)\]/);
#16楼
在检查变量是否为数字时创建了一个jsperf。 很有趣! typeof实际上具有性能用途。 除了数字以外,将typeof
用作其他任何东西,通常将其速度用作variable.constructor
typeof
函数,因为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
寄予了厚望,但是它们的运行速度非常慢。
#17楼
为了检测数字,以下来自JavaScript的段落:Douglas Crockford的The Good Parts是相关的:
isFinite函数是确定某个值是否可以用作数字的最佳方法,因为它拒绝NaN和Infinity。 不幸的是,isFinite会尝试将其操作数转换为数字,因此,如果值实际上不是数字,则不是一个很好的测试。 您可能需要定义自己的isNumber函数:
var isNumber = function isNumber(value) { return typeof value === 'number' &&
isFinite(value);
};
#18楼
在大多数情况下,typeof对我来说效果很好。 您可以尝试使用if语句
if(typeof x === 'string' || typeof x === 'number') {
console.log("Your statement");
}
其中x是您选择的任何变量名
#19楼
从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
#20楼
我发现最好的方法是检查字符串上的方法,即:
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));
将提醒“对象”。
#21楼
您对此有什么看法?
const numberOrString='10'
const isNumber = !isNaN(numberOrString*1)
#22楼
下面的代码对数字返回true,对其他任何东西返回false:
!isNaN(+variable);
#23楼
XOR操作可用于检测数字或字符串。 number ^ 0将始终给出数字作为输出,而字符串^ 0将始终给出0作为输出。
Example:
1) 2 ^ 0 = 2
2) '2' ^ 0 = 2
3) 'Str' ^ 0 = 0
#24楼
//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的完整示例:更好的typeof 。
#25楼
最佳方法是:
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));
#26楼
嗯,怎么样:
function IsString(obj) {
return obj !== undefined && obj != null && obj.toLowerCase !== undefined;
}
经过几个月的进一步审查后,这仅保证obj
是一个具有toLowerCase
定义的方法或属性名称的对象。 我为自己的回答感到ham愧。 请参阅得票最多typeof
之一。
#27楼
我发现的最好的方法也考虑了正数和负数,来自: O'Reilly Javascript和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;
}
#28楼
嗯? 只需使用正则表达式即可! :)
function isInteger(val) {
return val.match(/^[0-9]$/)
}
function isFloat(val) {
return val.match(/^[0-9]*/\.[0-9]+$/)
}
#29楼
您可以将其除以1吗?
我认为问题将是类似“ 123ABG”的字符串输入
var Check = "123ABG"
if(Check == Check / 1)
{
alert("This IS a number \n")
}
else
{
alert("This is NOT a number \n")
}
这是我最近做的一种方式。
#30楼
检查值是字符串文字还是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);
}