Kiểm tra xem biến là số hay chuỗi trong JavaScript

Có ai biết làm thế nào tôi có thể kiểm tra xem một biến là một số hoặc một chuỗi trong JavaScript không?

Nếu bạn đang xử lý ký hiệu theo nghĩa đen và không phải là nhà xây dựng, bạn có thể sử dụng typeof :.

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

Nếu bạn đang tạo số và chuỗi thông qua một nhà xây dựng, chẳng hạn như var foo = new String("foo"), bạn nên ghi nhớ rằng typeofcó thể trở lại objectcho foo.

Có lẽ một phương pháp kiểm tra loại dễ kiểm soát hơn sẽ là sử dụng phương thức được tìm thấy trong underscore.js (nguồn chú thích có thể được tìm thấy ở đây ),

var toString = Object.prototype.toString;

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

Điều này trả về một boolean truecho sau:

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

Cách tốt nhất để làm điều đó là sử dụng isNaNkiểu đúc +:

Cập nhật phương pháp tất cả trong:

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

Sử dụng regex tương tự:

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

Cách tốt nhất mà tôi đã tìm thấy là kiểm tra một phương thức trên chuỗi, tức là:

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

hoặc nếu bạn muốn làm gì đó với số kiểm tra cho một thuộc tính số,

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

Điều này giống như "gõ vịt", tùy thuộc vào bạn, cách nào có ý nghĩa nhất. Tôi không có đủ nghiệp lực để bình luận, nhưng typeof thất bại cho các chuỗi và số được đóng hộp, tức là:

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

sẽ cảnh báo "đối tượng".

Bạn đang tìm kiếm 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"));

Xem Hàm JavaScript isNaN () tại MDN.

Kiểm tra xem giá trị là một chuỗi ký tự hoặc đối tượng Chuỗi:

function isString(o) {
    return typeof o == "string" || (typeof o == "object" && o.constructor === String);
}

Bài kiểm tra đơn vị:

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

Kiểm tra một số tương tự:

function isNumber(o) {
    return typeof o == "number" || (typeof o == "object" && o.constructor === Number);
}

Kể từ ES2015, cách chính xác để kiểm tra xem một biến có giữ số hợp lệ không Number.isFinite(value)

Ví dụ:

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

Thử cái này,

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

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

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

Cách tốt nhất để làm điều này:

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

Điều này thỏa mãn các trường hợp thử nghiệm sau:

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

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

Hoặc điều chỉnh nó để trả về một kiểu không xác định:

function realTypeOf(obj) {
    return Object.prototype.toString.call(obj).slice(8, -1);
}

//usage
realTypeOf(999); // 'Number'

Ngày 12 tháng 5 năm 2012 Cập nhật: Ví dụ đầy đủ tại Javascript: Loại tốt hơn .

Đây là một cách tiếp cận dựa trên ý tưởng ép đầu vào vào một số hoặc chuỗi bằng cách thêm chuỗi 0 hoặc chuỗi rỗng, sau đó thực hiện so sánh bằng nhau được gõ.

function is_number(x) { return x === x+0;  }
function is_string(x) { return x === x+""; }

Đối với một số lý do không thể hiểu được, x===x+0dường như thực hiện tốt hơn x===+x.

Có trường hợp nào thất bại?

Trong cùng một tĩnh mạch:

function is_boolean(x) { return x === !!x; }

Điều này dường như nhanh hơn một chút x===true || x===falsehoặc typeof x==="boolean"(và nhanh hơn nhiều x===Boolean(x)).

Rồi cũng có

function is_regexp(x)  { return x === RegExp(x); }

Tất cả những điều này phụ thuộc vào sự tồn tại của một hoạt động "nhận dạng" cụ thể cho từng loại có thể được áp dụng cho bất kỳ giá trị nào và tạo ra một giá trị của loại được đề cập một cách đáng tin cậy. Tôi không thể nghĩ về một hoạt động như vậy cho ngày.

Đối với NaN, có

function is_nan(x) { return x !== x;}

Đây về cơ bản là phiên bản của gạch dưới và vì nó nhanh hơn khoảng bốn lần isNaN(), nhưng các ý kiến ​​trong nguồn gạch dưới đề cập rằng "NaN là số duy nhất không bằng chính nó" và thêm một kiểm tra cho _.isNumber. Tại sao? Những đối tượng khác sẽ không bằng chính họ? Ngoài ra, gạch dưới sử dụng - x !== +xnhưng sự khác biệt có thể +ở đây là gì?

Sau đó cho hoang tưởng:

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

hoặc cái này

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

Bạn chỉ có thể chia nó cho 1?

Tôi giả sử vấn đề sẽ là một chuỗi đầu vào như: "123ABG"

var Check = "123ABG"

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

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

Chỉ là một cách tôi đã làm nó gần đây.

ừ, thế còn

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

Sau khi xem xét thêm nhiều tháng sau đó, bảo đảm này chỉ objlà một đối tượng có tên phương thức hoặc thuộc tính toLowerCaseđược xác định. Tôi xấu hổ về câu trả lời của tôi. Xin vui lòng xem typeofmột trong những bình chọn hàng đầu .

Hoặc chỉ sử dụng đảo ngược của isNaN():

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

Và vâng, sử dụng jQuery $.isNumeric()là thú vị hơn cho buck.

Tôi nghĩ rằng việc chuyển đổi var thành một chuỗi làm giảm hiệu suất, ít nhất thử nghiệm này được thực hiện trong các trình duyệt mới nhất cho thấy như vậy.

Vì vậy, nếu bạn quan tâm đến hiệu suất, tôi sẽ, tôi sẽ sử dụng điều này:

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

để kiểm tra xem biến có phải là một chuỗi không (ngay cả khi bạn sử dụng var str = new String("foo"), str instanceof Stringsẽ trả về true).

Để kiểm tra xem đó có phải là số tôi sẽ dùng cho người bản địa không : isNaN; chức năng.

jQuery sử dụng điều này:

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

Giải pháp này giải quyết nhiều vấn đề được nêu ra ở đây!

Đây là phương pháp đáng tin cậy nhất mà tôi đã sử dụng cho đến nay. Tôi đã không phát minh ra điều này, và không thể nhớ lại nơi tôi đã tìm thấy nó ban đầu. Nhưng nó hoạt động khi các kỹ thuật khác thất bại:

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

Ví dụ về tính đúng đắn

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"

Nếu là một FYI, nếu bạn đang sử dụng jQuery, bạn có

$.isNumeric() 

để xử lý việc này. Thêm chi tiết về http://api.jquery.com/jQuery.isNumeric/

typeof hoạt động rất tốt cho tôi trong hầu hết các trường hợp. Bạn có thể thử sử dụng câu lệnh if

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

Trong đó x là bất kỳ tên biến nào bạn chọn

cách tốt nhất tôi tìm thấy cũng nghĩ về số dương và số âm là từ: O'Reilly Javascript và 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;

}

Ơ? Chỉ cần sử dụng các biểu thức thông thường! :)

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

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

vì một chuỗi là '1234' với typeof sẽ hiển thị 'chuỗi' và điều ngược lại không bao giờ xảy ra (kiểu 123 sẽ luôn là số), tốt nhất là sử dụng biểu thức chính quy đơn giản /^\-?\d+$/.test(var). Hoặc nâng cao hơn để khớp với số float, số nguyên và số âm, /^[\-\+]?[\d]+\.?(\d+)?$/ Mặt quan trọng của .testnó là KHÔNG ném ngoại lệ nếu var không phải là một chuỗi, giá trị có thể là bất cứ thứ gì.

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 

Nếu bạn đang tìm kiếm loại thực, thì một mình typeof sẽ làm.

Câu trả lời của @ BitOfUniverse là tốt và tôi nghĩ ra một cách mới:

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

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

Tôi biết 0không thể chia cổ tức, nhưng ở đây chức năng hoạt động hoàn hảo.

Kiểm tra loại

Bạn có thể kiểm tra loại biến bằng cách sử dụng typeoftoán tử:

typeof variable

Kiểm tra giá trị

Mã dưới đây trả về true cho các số và false cho bất kỳ thứ gì khác:

!isNaN(+variable);

Hoạt động XOR có thể được sử dụng để phát hiện số hoặc chuỗi. số ^ 0 sẽ luôn cho số là đầu ra và chuỗi ^ 0 sẽ cho 0 là đầu ra.

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

Đơn giản và kỹ lưỡng:

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

Các trường hợp thử nghiệm:

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

Đơn giản chỉ cần sử dụng

myVar.constructor == String

hoặc là

myVar.constructor == Number

nếu bạn muốn xử lý các chuỗi được xác định là đối tượng hoặc bằng chữ và tiết kiệm, bạn không muốn sử dụng chức năng trợ giúp.

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

Đến bữa tiệc rất muộn; tuy nhiên, những điều sau đây luôn hoạt động tốt với tôi khi tôi muốn kiểm tra xem một số đầu vào là một chuỗi hay một số trong một lần chụp.

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

Tạo một jsperf khi kiểm tra nếu một biến là một số. Khá thú vị! typeof thực sự có một hiệu suất sử dụng. Sử dụng typeofcho bất cứ thứ gì ngoài số, thường có tốc độ bằng 1/3 variable.constructorvì phần lớn các loại dữ liệu trong javascript là Đối tượng; con số thì không!

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

typeof variable === 'number'| nhanh nhất | nếu bạn muốn một số, chẳng hạn như 5, chứ không phải '5'
typeof parseFloat(variable) === 'number'| nhanh nhất | nếu bạn muốn một số, chẳng hạn như 5 và '5'

isNaN()chậm hơn, nhưng không chậm hơn nhiều Tôi đã hy vọng rất cao parseIntvà parseFloat, tuy nhiên chúng chậm kinh khủng.

Để phát hiện các con số, đoạn văn sau từ JavaScript: Các bộ phận tốt của Douglas Crockford có liên quan:

Hàm isFinite là cách tốt nhất để xác định xem một giá trị có thể được sử dụng làm số hay không vì nó từ chối NaN và Infinity. Thật không may, isFinite sẽ cố gắng chuyển đổi toán hạng của nó thành một số, vì vậy đây không phải là một thử nghiệm tốt nếu một giá trị không thực sự là một số. Bạn có thể muốn xác định hàm isNumber của riêng mình:

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