स्ट्रिंग्स को संख्याओं में परिवर्तित करते समय कैसे parseInt()और Number()अलग तरीके से व्यवहार करते हैं?
स्ट्रिंग्स को संख्याओं में परिवर्तित करते समय कैसे parseInt()और Number()अलग तरीके से व्यवहार करते हैं?
जवाबों:
ठीक है, वे शब्दार्थ रूप से भिन्न हैं , Numberनिर्माणकर्ता जिसे फ़ंक्शन कहा जाता है वह टाइप रूपांतरणparseInt करता है और पार्सिंग करता है , जैसे:
// parsing:
parseInt("20px"); // 20
parseInt("10100", 2); // 20
parseInt("2e1"); // 2
// type conversion
Number("20px"); // NaN
Number("2e1"); // 20, exponential notation
ध्यान रखें कि यदि parseIntस्ट्रिंग पर एक अग्रणी शून्य का पता लगाता है, तो यह अष्टाधारी आधार में संख्या को पार्स कर देगा, यह मानक के नए संस्करण ECMAScript 5 पर बदल गया है, लेकिन ब्राउज़र कार्यान्वयन में इसे प्राप्त करने में एक लंबा समय लगेगा (यह ईसीएमएस्क्रिप्ट 3 के साथ एक असंगति), parseIntअनुगामी पात्रों की भी अनदेखी करेगा जो वर्तमान में उपयोग किए गए आधार के किसी भी अंक के साथ मेल नहीं खाते हैं।
Numberनिर्माता octals पता नहीं लगा पाया:
Number("010"); // 10
parseInt("010"); // 8, implicit octal
parseInt("010", 10); // 10, decimal radix used
लेकिन यह हेक्साडेसिमल नोटेशन में संख्याओं को संभाल सकता है, जैसे parseInt:
Number("0xF"); // 15
parseInt("0xF"); //15
इसके अलावा, न्यूमेरिक प्रकार के रूपांतरण को करने के लिए एक व्यापक रूप से इस्तेमाल किया जाने वाला निर्माण, यूनिरी +ऑपरेटर (पी। 72) है , यह Numberएक फ़ंक्शन के रूप में कंस्ट्रक्टर का उपयोग करने के बराबर है :
+"2e1"; // 20
+"0xF"; // 15
+"010"; // 10
Number()ओक्स और बाइनरी जैसे ऑक्टल्स के साथ बहुत कुछ करता है:Number('0o10') == 8
typeof parseInt("123") => number
typeof Number("123") => number
typeof new Number("123") => object (Number primitive wrapper object)
पहले दो आपको बेहतर प्रदर्शन देंगे क्योंकि यह एक वस्तु के बजाय एक आदिम रिटर्न देता है।
new Number()के लिए अलग है Number()। typeof Number("123") => number
new Number("1") != new Number("1")। कभी भी उपयोग न करेंnew Number । कभी नहीं कभी नहीं। Number("1")दूसरी ओर, पूरी तरह से उचित है।
let x = new Number("2"); let y = new Number("2");और फिर बाद में जो भी कारण के लिए एक समानता की जांच करता हूं, if (x == y) { doSomething(); }तार्किक रूप doSomethingसे बुलाया जाना चाहिए। लेकिन यह अभ्यस्त है। इसके अलावा, यदि आप केवल एक ही नंबर पार्स करने के लिए थे let x = new Number("2");तो x === 2गलत होगा। यह एक स्पष्ट कारण है कि आपको क्यों नहीं उपयोग करना चाहिएnew Number
यदि आप प्रदर्शन की तलाश कर रहे हैं, तो शायद सबसे अच्छे परिणाम आपको बिटवाइज़ राइट शिफ्ट के साथ मिलेंगे "10">>0। इसके अलावा गुणा ( "10" * 1) या नहीं ( ~~"10")। उनमें से सभी बहुत तेज हैं Numberऔर parseInt। वे भी "सुविधा" नंबर तर्क के लिए 0 लौट रहे हैं। यहाँ प्रदर्शन परीक्षण हैं ।
Numberऔर parseIntअभी भी बाकी की तुलना में 99% धीमी है। मेरे अलावा वे नेत्रहीन भी कम आकर्षक हैं :-)
parseIntया Numberअधिक बेहतर हैं। यदि आप प्रति सेकंड लाखों रूपांतरणों के साथ N64 एमुलेटर का प्रोग्रामिंग कर रहे हैं, तो आप उन तरकीबों पर विचार कर सकते हैं।
(2**31).toString() >> 0करने के लिए अतिप्रवाह जाएगा -2147483648। >>>इसके बजाय आप उपयोग कर सकते हैं >>कि जावास्क्रिप्ट ने ओपेरा को एक अहस्ताक्षरित 32-बिट पूर्णांक के रूप में माना है , लेकिन फिर इससे बड़ी संख्या 2**32 - 1भी अतिप्रवाह होगी।
मैंने पाया कि प्रदर्शन के दो लिंक को परिवर्तित stringकरने के कई तरीकों के बीच तुलना करते हैं int।
parseInt(str,10)
parseFloat(str)
str << 0
+str
str*1
str-0
Number(str)
parseInt():
NaNजा सकता है।parseInt()फ़ंक्शन एक गैर संख्यात्मक मान का सामना करता है, तो यह इनपुट स्ट्रिंग के बाकी हिस्सों को काट देगा और केवल भाग को गैर संख्यात्मक मान तक पार करेगा।undefinedया 0 है, तो JS निम्नलिखित मान लेगा:
ES5निर्दिष्ट करता है कि 10 का उपयोग तब किया जाना चाहिए। हालाँकि, यह सभी ब्राउज़रों द्वारा समर्थित नहीं है, इसलिए हमेशा मूलांक निर्दिष्ट करें यदि आपके नंबर 0 से शुरू हो सकते हैं।Number():
Number()निर्माता एक संख्या में किसी भी तर्क इनपुट बदल सकते हैं। अगर Number()कंस्ट्रक्टर इनपुट को एक नंबर में नहीं बदल NaNसकता है , तो उसे वापस कर दिया जाएगा।Number()निर्माता भी हेक्साडेसिमल संख्या संभाल कर सकते हैं, वे के साथ शुरू कर दिया है 0x।console.log(parseInt('0xF', 16)); // 15
// z is no number, it will only evaluate 0xF, therefore 15 is logged
console.log(parseInt('0xFz123', 16));
// because the radix is 10, A is considered a letter not a number (like in Hexadecimal)
// Therefore, A will be cut off the string and 10 is logged
console.log(parseInt('10A', 10)); // 10
// first character isnot a number, therefore parseInt will return NaN
console.log(parseInt('a1213', 10));
console.log('\n');
// start with 0X, therefore Number will interpret it as a hexadecimal value
console.log(Number('0x11'));
// Cannot be converted to a number, NaN will be returned, notice that
// the number constructor will not cut off a non number part like parseInt does
console.log(Number('123A'));
// scientific notation is allowed
console.log(Number('152e-1')); // 15.21मैं हमेशा parseInt का उपयोग करता हूं, लेकिन अग्रणी शून्य से सावधान रहें जो इसे अष्ट मोड में मजबूर कर देगा ।
parseInt(value, radix)कि आप उस तरह से एक मूलांक की आपूर्ति करें जिससे आपके पास आकस्मिक अष्टक मोड रूपांतरण आदि न हों
0, यहां तक कि गैर कठोर मोड में। लेकिन इसे ठीक कर दिया गया है और अब अग्रणी शून्य को केवल अनदेखा कर दिया गया है, इसलिए parseInt("070")यह बन जाएगा 70।
parseInt()।
parseInt() -> निर्दिष्ट रेडिक्स को एक संख्या देता है।
Number()-> यदि वह ऐसा करने में विफल रहता है तो निर्दिष्ट मूल्य को उसके संख्यात्मक समकक्ष या NaN में परिवर्तित करता है।
इसलिए कुछ गैर-संख्यात्मक मान को संख्या में परिवर्तित करने के लिए हमें हमेशा नंबर () फ़ंक्शन का उपयोग करना चाहिए।
जैसे।
Number("")//0
parseInt("")//NaN
Number("123")//123
parseInt("123")//123
Number("123ac") //NaN,as it is a non numeric string
parsInt("123ac") //123,it parse decimal number outof string
Number(true)//1
parseInt(true) //NaNparseInt()फ़ंक्शंस के लिए विभिन्न कोने मामले हैं क्योंकि यह रूपांतरण रूपांतरण करता है, इसलिए हमें तालमेल उद्देश्यों के लिए पार्सइंट () फ़ंक्शन का उपयोग करने से बचना चाहिए।
अब, मौसम की जांच करने के लिए प्रदान किया गया मूल्य न्यूमेरिक है या नहीं, हमें मूल isNaN()फ़ंक्शन का उपयोग करना चाहिए
parseInt एक पूर्णांक संख्या में परिवर्तित होता है, अर्थात, यह दशमलव को स्ट्रिप करता है। संख्या पूर्णांक में परिवर्तित नहीं होती है।
जब तक आपको हेक्स या ऑक्टल की आवश्यकता नहीं है, तब तक पार्सेइंट से दूर रहने और नंबर और मैथ.ऑर्ग का उपयोग करने का एक अच्छा विचार है। दोनों तार का उपयोग कर सकते हैं। इससे दूर क्यों रहें?
parseInt(0.001, 10)
0
parseInt(-0.0000000001, 10)
-1
parseInt(0.0000000001, 10)
1
parseInt(4000000000000000000000, 10)
4यह पूरी तरह से कसाई वास्तव में बड़ी या वास्तव में छोटी संख्या है। अजीब तरह से यह सामान्य रूप से काम करता है अगर ये इनपुट एक स्ट्रिंग हैं।
parseInt("-0.0000000001", 10)
0
parseInt("0.0000000001", 10)
0
parseInt("4000000000000000000000", 10)
4e+21इसके साथ बग्स का पता लगाने के लिए कड़ी मेहनत करने और अन्य गोटेक लोगों का उल्लेख करने के बजाय, मैं सिर्फ पार्सेइंट से बचूंगा जब तक कि आपको बेस 10 के अलावा कुछ और पार्स करने की आवश्यकता न हो। समान प्रकार के बग्स के बिना parseInt का उपयोग किया जा सकता है।
यदि आप वास्तव में चाहते हैं या इसके कुछ अन्य गुणों के लिए parseInt का उपयोग करने की आवश्यकता है, तो इसका उपयोग कभी भी फ़्लोट को किलों में बदलने के लिए न करें।