檢查JavaScript中變量是數字還是字符串

Question

有誰知道如何檢查 JavaScript 中的變量是數字還是字符串？

Answer 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

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

自 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 6

檢查該值是字符串文字還是字符串對象：

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 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: A Better typeof中的完整示例。

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稍微快一點。 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 11

簡單而徹底：

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

Answer 12

我認為將 var 轉換為字符串會降低性能，至少在最新瀏覽器中執行的這個測試表明了這一點。

所以如果你關心性能，我會，我會用這個：

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

用於檢查變量是否為字符串（即使您使用var str = new String("foo") ， str instanceof String也會返回 true）。

至於檢查它是否是一個數字，我會選擇本機： isNaN ; 功能。

Answer 13

或者只是使用isNaN()的反轉：

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

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

Answer 14

你能把它除以1嗎？

我認為問題將是一個字符串輸入，例如：“123ABG”

var Check = "123ABG"

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

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

只是我最近做的一種方式。

Answer 15

呃，怎么樣：

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

經過幾個月后的進一步審查，這只能保證obj是一個定義了方法或屬性名稱toLowerCase的對象。 我為我的回答感到羞恥。 請查看投票typeof的類型之一。

Answer 16

jQuery 使用這個：

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

Answer 17

這個解決方案解決了這里提出的許多問題！

這是迄今為止我使用過的最可靠的方法。 這不是我發明的，也不記得我最初是在哪里找到它的。 但它適用於其他技術失敗的地方：

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

僅供參考，如果您使用的是 jQuery，您有

$.isNumeric() 

來處理這個。 有關http://api.jquery.com/jQuery.isNumeric/的更多詳細信息

Answer 19

注意typeof NaN是... 'number'

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

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 

如果您正在尋找真正的類型，那么 typeof 就可以了。

Answer 21

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

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

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

我知道0不能被股息，但這里的功能完美。

Answer 22

在大多數情況下，typeof 對我來說效果很好。 您可以嘗試使用 if 語句

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

其中 x 是您選擇的任何變量名稱

Answer 23

類型檢查

您可以使用typeof運算符檢查變量的類型：

typeof variable

值檢查

下面的代碼對數字返回 true，對其他任何東西返回 false：

!isNaN(+variable);

Answer 24

我發現的同時考慮正數和負數的最佳方法來自： 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 25

錯了？ 只需使用正則表達式！ :)

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

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

Answer 26

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

Answer 27

XOR 操作可用於檢測數字或字符串。 number ^ 0 將始終給出與輸出相同的數字，而 string ^ 0 將給出 0 作為輸出。

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

Answer 28

只需使用

myVar.constructor == String

或者

myVar.constructor == Number

如果您想處理定義為對象或文字的字符串並保存您不想使用輔助函數。

Answer 29

聚會很晚； 但是，當我想一次性檢查某個輸入是字符串還是數字時，以下內容對我來說一直很有效。

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

Answer 30

在檢查變量是否為數字時創建了一個 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'
typeof parseFloat(variable) === 'number' | 最快的 | 如果你想要一個數字，比如 5 和 '5'

isNaN()較慢，但並沒有那么慢。 我對parseInt和parseFloat寄予厚望，但是它們的速度非常慢。

Answer 31

為了檢測數字，以下來自JavaScript的段落：Douglas Crockford的The Good Parts是相關的：

isFinite函數是確定某個值是否可以用作數字的最佳方法，因為它拒絕NaN和Infinity。 不幸的是，isFinite會嘗試將其操作數轉換為數字，因此，如果值實際上不是數字，則不是一個很好的測試。 您可能需要定義自己的isNumber函數：

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

Answer 32

您對此有什么看法？

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

Answer 33

效率測試<\/h1>

我知道我將使用哪種方式...

Answer 34

和其他人一樣，我沉迷於強類型（盡管我喜歡 JS）

在我的代碼中，我碰巧需要區分數字和字符串，以執行兩種截然不同的操作。

而不是高談闊論的日志：

 let int = 123, str = '123'; console.log( int.constructor===Number, str.constructor===String ); // true true console.log( typeof int === 'number', typeof str === 'number'); // true false console.log (Number(int)===int, Number(str)===str ) // true false // or: console.log (String(int)===int, String(str)===str ) // false true // the shortest: console.log( +int===int, +str===str ); // true false

因此，我主要使用，尤其是在三元測試中。

let res = (+X===X) ? stuff_to_do_with_a_Number(X) : stuff_to_do_with_a_String(X);

當然，這必須小心處理。