ตรวจสอบว่าตัวแปรเป็นตัวเลขหรือสตริงใน JavaScript

ไม่มีใครรู้ว่าฉันจะตรวจสอบว่าตัวแปรเป็นตัวเลขหรือสตริงใน JavaScript ได้อย่างไร

หากคุณกำลังจัดการกับสัญกรณ์ตามตัวอักษรและไม่ใช่ตัวสร้างคุณสามารถใช้typeof :

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

หากคุณกำลังสร้างตัวเลขและสตริงผ่านคอนสตรัคเช่นvar foo = new String("foo")คุณควรเก็บไว้ในใจว่าtypeofอาจจะกลับมาสำหรับobjectfoo

บางทีวิธีการตรวจสอบที่เข้าใจผิดได้มากกว่าคือการใช้วิธีที่พบใน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

วิธีที่ดีที่สุดในการใช้isNaN+ หล่อแบบ:

อัปเดตวิธีการทั้งหมด:

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

เช่นเดียวกับการใช้ regex:

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

วิธีที่ดีที่สุดที่ฉันได้พบคือการตรวจสอบวิธีการในสตริงเช่น:

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

จะแจ้งเตือน "วัตถุ"

คุณกำลังมองหา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"));

ดูJavaScript isNaN () ฟังก์ชั่นที่ MDN

ตรวจสอบว่าค่าเป็นตัวอักษรสตริงหรือวัตถุสตริง:

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

ตั้งแต่ 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

ลองนี้

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

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

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

วิธีที่ดีที่สุดในการทำเช่นนี้:

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

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

12 พฤษภาคม 2012 ปรับปรุง: ตัวอย่างเต็มรูปแบบที่Javascript: ดีกว่า typeof

นี่คือวิธีการตามแนวคิดของการบีบบังคับอินพุตให้กับตัวเลขหรือสตริงโดยการเพิ่มศูนย์หรือสตริงว่างแล้วทำการเปรียบเทียบความเท่าเทียมกันที่พิมพ์

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

ด้วยเหตุผลบางกินลึกดูเหมือนว่าจะทำงานได้ดีกว่าx===x+0x===+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); }

ทั้งหมดนี้ขึ้นอยู่กับการมีอยู่ของการดำเนินงาน "ตัวตน" โดยเฉพาะกับแต่ละประเภทซึ่งสามารถนำไปใช้กับค่าใด ๆ และสร้างคุณค่าของประเภทที่เป็นปัญหาได้อย่างน่าเชื่อถือ ฉันไม่สามารถนึกถึงการดำเนินการดังกล่าวสำหรับวันที่

สำหรับน่านมี

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

คุณสามารถหารด้วย 1 ได้ไหม

ฉันคิดว่าปัญหาจะเป็นอินพุตสตริงเช่น: "123ABG"

var Check = "123ABG"

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

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

เพียงวิธีที่ฉันทำเมื่อเร็ว ๆ นี้

เอ่อแค่:

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

หลังจากตรวจสอบอีกหลายเดือนต่อมาการรับประกันobjนี้เป็นเพียงวัตถุที่มีวิธีการหรือชื่อคุณสมบัติที่toLowerCaseกำหนด ฉันละอายใจกับคำตอบของฉัน โปรดดูtypeofหนึ่งที่ได้รับการโหวตสูงสุด

หรือเพียงแค่ใช้การกลับด้านของisNaN():

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

และใช่แล้วการใช้ jQuery $.isNumeric()นั้นสนุกกว่าสำหรับเจ้าชู้

ฉันคิดว่าการแปลง var เป็นสตริงจะทำให้ประสิทธิภาพลดลงอย่างน้อยการทดสอบนี้ที่ดำเนินการในเบราว์เซอร์ล่าสุดจะแสดงขึ้นมา

ดังนั้นหากคุณสนใจเรื่องการแสดงฉันจะใช้สิ่งนี้:

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

สำหรับการตรวจสอบว่าตัวแปรเป็นสตริง (แม้ว่าคุณจะใช้var str = new String("foo"), str instanceof Stringจะกลับมาจริง)

สำหรับการตรวจสอบว่าเป็นจำนวนฉันจะไปหาคนพื้นเมือง: isNaN; ฟังก์ชัน

jQuery ใช้สิ่งนี้:

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

วิธีการแก้ไขนี้แก้ปัญหาต่าง ๆ ที่เกิดขึ้นที่นี่

นี่เป็นวิธีที่น่าเชื่อถือที่สุดที่ฉันเคยใช้ ฉันไม่ได้ประดิษฐ์สิ่งนี้และจำไม่ได้ว่าฉันเจอมันที่ไหน แต่มันใช้งานได้เมื่อเทคนิคอื่นล้มเหลว:

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

ลองใช้ FYI ถ้าคุณใช้ jQuery

$.isNumeric() 

เพื่อจัดการกับสิ่งนี้ รายละเอียดเพิ่มเติมเกี่ยวกับhttp://api.jquery.com/jQuery.isNumeric/

typeof ทำงานได้ดีมากสำหรับฉันในกรณีส่วนใหญ่ คุณสามารถลองใช้คำสั่ง if

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

โดยที่ x คือชื่อตัวแปรใด ๆ ที่คุณเลือก

วิธีที่ดีที่สุดที่ฉันพบซึ่งคิดว่าจำนวนบวกและลบมาจาก: 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;

}

errr? เพียงใช้นิพจน์ทั่วไป! :)

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

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

ตั้งแต่สตริงเป็น '1234' กับ typeof จะแสดง 'สตริง' และผกผันไม่เคยเกิดขึ้น (typeof 123 จะเป็นตัวเลข) ที่ดีที่สุดคือการใช้ /^\-?\d+$/.test(var)regex หรือขั้นสูงกว่าในการจับคู่ลอยจำนวนเต็มและจำนวนลบ/^[\-\+]?[\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 

หากคุณกำลังมองหาประเภทที่แท้จริงประเภทของคนเดียวจะทำ

@ คำตอบของ BitOfUniverse เป็นสิ่งที่ดีและฉันคิดวิธีใหม่:

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

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

ฉันรู้ว่า0ไม่สามารถจ่ายเงินปันผลได้ แต่ที่นี่ฟังก์ชั่นทำงานได้อย่างสมบูรณ์แบบ

การตรวจสอบประเภท

คุณสามารถตรวจสอบประเภทของตัวแปรได้โดยใช้typeofโอเปอเรเตอร์:

typeof variable

การตรวจสอบค่า

โค้ดด้านล่างจะคืนค่าจริงสำหรับตัวเลขและเท็จสำหรับสิ่งอื่น:

!isNaN(+variable);

การดำเนินการ XOR สามารถใช้ในการตรวจสอบจำนวนหรือสตริง number ^ 0 จะให้ตัวเลขเป็นเอาต์พุตเสมอและสตริง ^ 0 จะให้ 0 เป็นผลลัพธ์

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

ง่ายและทั่วถึง:

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

เพียงใช้

myVar.constructor == String

หรือ

myVar.constructor == Number

หากคุณต้องการจัดการสตริงที่กำหนดเป็นวัตถุหรือตัวอักษรและบันทึกคุณไม่ต้องการใช้ฟังก์ชันตัวช่วย

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

สายมากไปงานเลี้ยง; อย่างไรก็ตามสิ่งต่อไปนี้ใช้ได้ดีสำหรับฉันเสมอเมื่อฉันต้องการตรวจสอบว่าอินพุตบางส่วนเป็นสตริงหรือตัวเลขในช็อตเดียว

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

สร้าง jsperf บนการตรวจสอบว่าตัวแปรเป็นตัวเลขหรือไม่ น่าสนใจทีเดียว! typeof มีการใช้งานจริง การใช้typeofเพื่อสิ่งอื่นที่ไม่ใช่ตัวเลขโดยทั่วไปความเร็วจะเพิ่มขึ้น 1 / 3rd variable.constructorเนื่องจากชนิดข้อมูลส่วนใหญ่ใน 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พวกเขาก็ช้าลงอย่างน่ากลัว

สำหรับการตรวจจับตัวเลขข้อความต่อไปนี้จาก JavaScript: The Good Parts by Douglas Crockford มีความเกี่ยวข้อง:

ฟังก์ชั่น isFinite เป็นวิธีที่ดีที่สุดในการพิจารณาว่าสามารถใช้ค่าเป็นตัวเลขได้หรือไม่เพราะมันปฏิเสธ NaN และ Infinity น่าเสียดายที่ isFinite จะพยายามแปลงตัวถูกดำเนินการเป็นตัวเลขดังนั้นจึงไม่ใช่การทดสอบที่ดีถ้าค่าไม่ใช่ตัวเลขจริง คุณอาจต้องการกำหนดฟังก์ชั่น isNumber ของคุณเอง:

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