क्या किसी को पता है कि मैं कैसे जांच सकता हूं कि एक चर एक संख्या या जावास्क्रिप्ट में एक स्ट्रिंग है?
जवाबों:
यदि आप शाब्दिक संकेतन के साथ काम कर रहे हैं, और निर्माणकर्ता नहीं हैं, तो आप टाइपोफ़ का उपयोग कर सकते हैं :
typeof "Hello World"; // string
typeof 123; // numberयदि आप एक कंस्ट्रक्टर के माध्यम से संख्या और तार बना रहे हैं, जैसे कि var foo = new String("foo"), आपको यह ध्यान रखना चाहिए कि typeofकिसके objectलिए वापसी हो सकती है foo।
शायद प्रकार की जांच करने का एक अधिक मूर्खतापूर्ण तरीका अंडरस्कोर में पाया विधि का उपयोग करना होगा। जेएस (एनोटेट स्रोत यहां पाया जा सकता है ),
var toString = Object.prototype.toString;
_.isString = function (obj) {
return toString.call(obj) == '[object String]';
}यह trueनिम्नलिखित के लिए एक बूलियन लौटाता है :
_.isString("Jonathan"); // true
_.isString(new String("Jonathan")); // truevar myString = new String("stuff I like"); isString(myString)यह गलत है। इसके अलावा, मैं बिल्कुल निश्चित नहीं हूं कि बैकग्रॉइंड रूपांतरण कितनी देर तक रहता है, मुझे पता है कि जब मैं "हाय" कहता हूं। गति, "हाय" एक वस्तु में परिवर्तित हो जाती है, तो सुनिश्चित नहीं है कि यह कितनी जल्दी वापस फिर से परिवर्तित हो जाता है या यदि यह कभी बाध्य होता है। चर के लिए।
ऐसा करने का सबसे अच्छा तरीका है 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(' '); // falsenull0 मजबूर और के लिए सच रिटर्न हैisNumber(null);
function is_number(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n);}
सबसे अच्छा तरीका मैंने पाया है कि या तो स्ट्रिंग पर एक विधि की जाँच करें, अर्थात:
if (x.substring) {
// do string thing
} else{
// do other thing
}या यदि आप एक नंबर संपत्ति के लिए नंबर की जांच के साथ कुछ करना चाहते हैं,
if (x.toFixed) {
// do number thing
} else {
// do other thing
}यह "बतख टाइपिंग" की तरह है, यह आपके लिए है कि कौन सा तरीका सबसे अधिक समझ में आता है। मेरे पास टिप्पणी करने के लिए पर्याप्त कर्म नहीं हैं, लेकिन बॉक्सिंग स्ट्रिंग्स और संख्याओं के लिए टाइपोफ़ विफल रहता है, अर्थात:
alert(typeof new String('Hello World'));
alert(typeof new Number(5));"ऑब्जेक्ट" को अलर्ट करेगा।
typeofक्योंकि यह हमेशा एक स्ट्रिंग के लिए परीक्षण कर सकता है, चाहे वह आदिम या स्ट्रिंग वस्तु हो। आपको बस एक विधि के लिए परीक्षण करना होगा जो आपके इच्छित प्रकार के लिए अद्वितीय है।
{substring:"hello"}। मैं अपने उद्देश्यों के लिए जानता हूं कि मैंने केवल यह परीक्षण किया कि मुझे किस प्रकार के ऑपरेशन की आवश्यकता थी (मापांक) उस प्रकार के लिए जो मुझे जांचने के लिए आवश्यक था (स्ट्रिंग्स पर मापांक अपरिभाषित रिटर्न के लिए) तो इसके प्रकार के बजाय इसके लिए जाँच की।
आप देख रहे हैं 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 में जावास्क्रिप्ट .NaN () फ़ंक्शन है ।
isNaNरिटर्न falseके लिए null(लेकिन trueके लिए undefined)।
जांचें कि क्या मान एक स्ट्रिंग शाब्दिक या स्ट्रिंग ऑब्जेक्ट है:
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);
}function is (type, value) { return value["constructor"] === type; }:?
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 अपडेट: जावास्क्रिप्ट पर पूर्ण उदाहरण : एक बेहतर टाइपोफ ।
realTypeOf: realTypeOf(NaN) -> "Number"जो समान व्यवहार पर typeofसहमत है लेकिन अभी भी आदर्श से दूर है।
यहां शून्य या नल स्ट्रिंग को जोड़कर किसी संख्या या स्ट्रिंग को इनपुट के लिए बाध्य करने के विचार के आधार पर एक दृष्टिकोण है, और फिर टाइप की गई समानता की तुलना करें।
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]; }या यह
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()करना हिरन के लिए अधिक मजेदार है।
isNaN('123')असत्य देता है, हालांकि तर्क एक संख्यात्मक स्ट्रिंग है और संख्यात्मक प्रकार नहीं है
मुझे लगता है कि संस्करण को स्ट्रिंग में परिवर्तित करने से प्रदर्शन कम हो जाता है, कम से कम नवीनतम ब्राउज़रों में किए गए इस परीक्षण से पता चलता है।
इसलिए अगर आप प्रदर्शन के बारे में परवाह करते हैं, तो मैं इसका उपयोग करूंगा:
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"typeofक्रोम पर मूल विधि (0.788s बनाम 1.481s) की आधी गति से भी बदतर नहीं है । यह निश्चित रूप से बेहतर परिणामों को देखते हुए स्वीकार्य प्रदर्शन है। आपको क्या लगता है कि यह "वास्तव में धीमा है?" शायद यह है - IE6 / 7/8 में? लेकिन उन ब्राउज़रों में सब कुछ "वास्तव में धीमा" है।
typeof100x तेज है, मैं क्या याद कर रहा हूं?
Jsut एक FYI करें, यदि आप jQuery का उपयोग कर रहे हैं
$.isNumeric() इसे संभालने के लिए। Http://api.jquery.com/jQuery.isNumeric/ पर अधिक जानकारी
टाइपोफ़ ज्यादातर मामलों में मेरे लिए बहुत अच्छा काम करता है। आप एक if स्टेटमेंट का उपयोग करके देख सकते हैं
if(typeof x === 'string' || typeof x === 'number') {
console.log("Your statement");
}जहाँ x आपकी पसंद का कोई भी परिवर्तनशील नाम है
सबसे अच्छा तरीका मैंने पाया जो सकारात्मक और नकारात्मक संख्याओं के बारे में सोचता है: ओ रेली जावास्क्रिप्ट और DHTML कुकबुक :
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' के रूप में एक स्ट्रिंग 'स्ट्रिंग' दिखाएगा, और व्युत्क्रम कभी भी नहीं हो सकता है (टाइपो 123 हमेशा नंबर होगा), सबसे अच्छा एक सरल रेगेक्स का उपयोग करना है /^\-?\d+$/.test(var)। या फ़्लोट्स, पूर्णांक और ऋणात्मक संख्याओं के मेल के लिए अधिक उन्नत, /^[\-\+]?[\d]+\.?(\d+)?$/
इसका महत्वपूर्ण पक्ष .testयह है कि यह अपवाद नहीं छोड़ता है यदि संस्करण एक स्ट्रिंग नहीं है, तो मूल्य कुछ भी हो सकता है।
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ऑपरेटर का उपयोग करके चर के प्रकार की जांच कर सकते हैं :
typeof variableनीचे दिया गया कोड संख्याओं के लिए सही है और किसी भी चीज़ के लिए गलत है:
!isNaN(+variable);typeofऑपरेटर का उपयोग कर सकते हैं ! @ जस्टामार्टिन
numberलेकिन अगर मैं '123' या 'एबीसी' या किसी अन्य उद्धृत शाब्दिक पास करता हूं, तो यह एक स्ट्रिंग है, और इससे कोई फर्क नहीं पड़ता कि इसे एक संख्या में पार्स किया जा सकता है या नहीं।
XOR ऑपरेशन का उपयोग संख्या या स्ट्रिंग का पता लगाने के लिए किया जा सकता है। नंबर ^ 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'));पार्टी में बहुत देर से; हालाँकि, निम्नलिखित ने हमेशा मेरे लिए अच्छा काम किया है जब मैं यह जांचना चाहता हूं कि कुछ इनपुट या तो एक स्ट्रिंग है या एक शॉट में एक संख्या है।
return !!Object.prototype.toString.call(input).match(/\[object (String|Number)\]/);यदि एक चर एक संख्या है, तो जाँच पर एक jsperf बनाया गया। काफी दिलचस्प! टाइपोफ़ में वास्तव में प्रदर्शन का उपयोग होता है। typeofसंख्याओं के अलावा किसी अन्य चीज के लिए उपयोग करना , आम तौर पर 1/3 की गति को एक के रूप में जाता हैvariable.constructor क्योंकि जावास्क्रिप्ट में अधिकांश डेटा प्रकार ऑब्जेक्ट हैं; नंबर नहीं हैं!
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हालांकि, वे बुरी तरह से धीमे थे।
संख्याओं का पता लगाने के लिए, जावास्क्रिप्ट से निम्नलिखित मार्ग: डगलस क्रॉकफोर्ड द्वारा अच्छे हिस्से प्रासंगिक हैं:
TheFinite फ़ंक्शन यह निर्धारित करने का सबसे अच्छा तरीका है कि क्या मूल्य को एक संख्या के रूप में उपयोग किया जा सकता है क्योंकि यह NaN और इन्फिनिटी को अस्वीकार करता है। दुर्भाग्य से, isFinite अपने ऑपरेंड को एक संख्या में बदलने का प्रयास करेगा, इसलिए यह एक अच्छा परीक्षण नहीं है यदि कोई मूल्य वास्तव में एक संख्या नहीं है। आप अपने स्वयं के कार्य को परिभाषित करना चाहते हैं।
var isNumber = function isNumber(value) { return typeof value === 'number' &&
isFinite(value);
};