0.1 * 0.2;
> 0.020000000000000004
0.3 - 0.1
> 0.19999999999999998
व्यावहारिक उद्देश्यों के लिए, यह अशुद्धि कोई मायने नहीं रखती, हमारे मामले में हम क्विंटिलियन भागों में त्रुटि के बारे में बात कर रहे हैं, हालाँकि, यह कुछ लोगों को निराश कर सकता है। मुद्राओं, प्रतिशतों या फ़ाइल आकारों को दर्शाने वाली संख्याओं के साथ काम करते समय हमें कुछ अजीब परिणाम भी मिल सकते हैं। इन अशुद्धियों को ठीक करने के लिए, हमें केवल परिणामों को पूर्णांकित करने में सक्षम होने की आवश्यकता है, और यह दशमलव परिशुद्धता निर्धारित करने के लिए पर्याप्त है।
संख्याओं को पूर्णांकित करना है प्रायोगिक उपयोग, हम किसी सीमा के भीतर किसी संख्या में हेरफेर कर सकते हैं, उदाहरण के लिए हम केवल दशमलव भाग के साथ काम करने के बजाय मान को निकटतम पूर्ण संख्या में पूर्णांकित करना चाहते हैं।
दशमलव संख्याओं को पूर्णांकित करना काटने के लिए दशमलव संख्या, toFixed या toPrecision विधि का उपयोग करें। वे दोनों एक ही तर्क लेते हैं, जो क्रमशः निर्धारित करता है कि कितने हैं महत्वपूर्ण लोग(अर्थात संख्या में प्रयुक्त अंकों की कुल संख्या) या दशमलव स्थानों (दशमलव बिंदु के बाद की संख्या) में परिणाम शामिल होना चाहिए:ToFixed() और toPrecision() दोनों विधियाँ परिणाम का एक स्ट्रिंग प्रतिनिधित्व लौटाती हैं, संख्या नहीं। इसका मतलब यह है कि जब एक गोलाकार मान को randNum के साथ जोड़ा जाता है, तो यह संख्याओं के योग के बजाय स्ट्रिंग्स का एक संयोजन उत्पन्न करेगा:
मान लीजिए randNum = 6.25; चलो गोलाकार = randNum.toFixed(); // "6" कंसोल.लॉग(रैंडनम + राउंडेड); > "6.256"
यदि आप चाहते हैं कि परिणाम एक संख्यात्मक डेटा प्रकार हो, तो आपको parseFloat का उपयोग करने की आवश्यकता होगी:
मान लीजिए randNum = 6.25; चलो गोलाकार = parseFloat(randNum.toFixed(1)); कंसोल.लॉग(गोल); > 6.3
कृपया ध्यान दें कि दुर्लभ मामलों को छोड़कर 5 के मान को पूर्णांकित किया जाता है।
ToFixed() और toPrecision() विधियाँ उपयोगी हैं क्योंकि वे न केवल भिन्नात्मक भाग को काट सकते हैं, बल्कि दशमलव स्थानों को भी जोड़ सकते हैं, जो मुद्रा के साथ काम करते समय सुविधाजनक है:
मान लीजिए WholeNum = 1 मान लीजिएdolCents = WholeNum.toFixed(2); कंसोल.लॉग(डॉलरसेंट्स); > "1.00"
ध्यान दें कि यदि पूर्णांकों की संख्या परिशुद्धता से अधिक है तो toPrecision वैज्ञानिक संकेतन में परिणाम उत्पन्न करेगा:
मान लीजिए संख्या = 123.435 num.toPrecision(2); > "1.2e+2"
दशमलव के साथ पूर्णांकन त्रुटियों से कैसे बचें कुछ मामलों में, toFixed और toPrecision मान को 5 से नीचे और ऊपर पूर्णांकित करें:मान लीजिए numTest = 1.005; numTest.toFixed(2); > "1.00"
उपरोक्त गणना का परिणाम 1.01 होना चाहिए था, 1 नहीं। यदि आप एक समान त्रुटि से बचना चाहते हैं, तो हम जैक एल मूर द्वारा प्रस्तावित समाधान का उपयोग कर सकते हैं, जो गणना के लिए घातीय संख्याओं का उपयोग करता है:
फ़ंक्शन राउंड(मान, दशमलव) (वापसी संख्या(गणित.राउंड(मान+"ई"+दशमलव)+"ई-"+दशमलव); )
अब:
दौर(1.005,2); > 1.01
यदि आप ऊपर दिखाए गए से अधिक मजबूत समाधान चाहते हैं, तो आप एमडीएन पर जा सकते हैं।
0.1 + 0.2 === 0.3 > असत्य
वैध तुलना प्राप्त करने के लिए हम अपने फ़ंक्शन में Math.EPSILON का उपयोग करते हैं:
फ़ंक्शन epsEq(x, y) (वापसी Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y));
}
फ़ंक्शन दो तर्क लेता है: पहला वर्तमान गणना है, दूसरा अपेक्षित परिणाम है। यह दोनों की तुलना लौटाता है:
EpsEq(0.1 + 0.2, 0.3) > सत्य
सभी आधुनिक ब्राउज़र पहले से ही ES6 गणित फ़ंक्शंस का समर्थन करते हैं, लेकिन यदि आप IE 11 जैसे ब्राउज़र में समर्थन चाहते हैं, तो पॉलीफ़िल का उपयोग करें।
फ़ंक्शन छोटा किया गया (संख्या) (वापसी Math.trunc(num * 100) / 100; ) छोटा किया गया (3.1416) > 3.14
यदि आप विधि को दशमलव स्थानों की किसी भी संख्या में अनुकूलित करना चाहते हैं, तो आप बिटवाइज़ डबल नेगेशन का उपयोग कर सकते हैं:
फ़ंक्शन छोटा कर दिया गया है (संख्या, दशमलव स्थान) ( numPowerConverter = Math.pow(10, दशमलव स्थान); वापसी ~~(num * numPowerConverter)/numPowerConverter; )
अब:
मान लीजिए randInt = 35.874993; काट दिया गया(randInt,3); >35.874
निकटतम संख्या तक पूर्णांक बनाना किसी दशमलव संख्या को निकटतम संख्या में ऊपर या नीचे, जो भी हम निकटतम हो, पूर्णांकित करने के लिए Math.round() का उपयोग करें:गणित.राउंड(4.3) > 4 गणित.राउंड(4.5) >5
कृपया ध्यान दें कि "आधा मान", 0.5 को गणित के नियमों के अनुसार पूर्णांकित किया जाता है।
मठ.तल(42.23); >42 मठ.तल(36.93); >36
कृपया ध्यान दें कि पूर्णांकन ऋणात्मक संख्याओं सहित सभी संख्याओं के लिए काम करता है। अनंत संख्या में मंजिलों वाली एक गगनचुंबी इमारत की कल्पना करें, जिसमें निचले स्तर पर फर्श (नकारात्मक संख्याओं का प्रतिनिधित्व) भी शामिल है। यदि आप 2 और 3 के बीच सबसे निचले स्तर पर लिफ्ट में हैं (जो -2.5 का मान दर्शाता है), Math.floor आपको -3 पर ले जाएगा:
मठ.तल(-2.5); > -3
लेकिन यदि आप इस स्थिति से बचना चाहते हैं, तो Math.trunc का उपयोग करें, जो सभी आधुनिक ब्राउज़रों में समर्थित है (IE/Edge को छोड़कर):
गणित.ट्रंक(-41.43); >-41
एमडीएन पर आपको एक पॉलीफिल मिलेगा जो ब्राउज़र और आईई/एज में Math.trunc के लिए समर्थन प्रदान करेगा।
Math.ceil(42.23); >43 Math.ceil(36.93); >37 Math.ceil(-36.93); >-36
आवश्यक संख्या तक ऊपर/नीचे पूर्णांक बनाना यदि हम 5 के निकटतम गुणज तक पूर्णांक बनाना चाहते हैं, तो सबसे आसान तरीका एक फ़ंक्शन बनाना है जो संख्या को 5 से विभाजित करता है, इसे पूर्णांक बनाता है, और फिर इसे उसी राशि से गुणा करता है:फ़ंक्शन राउंडटू5(संख्या) (वापसी गणित.राउंड(संख्या/5)*5; )
अब:
राउंडटू5(11); >10
यदि आप अपने मान के गुणजों में पूर्णांक बनाना चाहते हैं, तो हम एक अधिक सामान्य फ़ंक्शन का उपयोग करते हैं, प्रारंभिक मान और गुणज को पास करते हुए:
फ़ंक्शन राउंडटूमल्टीपल(संख्या, एकाधिक) (वापसी Math.round(num/multiple)*multiple; )
अब:
माना प्रारंभिक संख्या = 11; मान लीजिए एकाधिक = 10; राउंडटूमल्टीपल (प्रारंभिक संख्या, एकाधिक); >10;
किसी श्रेणी में किसी संख्या को निश्चित करना ऐसे कई मामले हैं जहां हम किसी सीमा के भीतर मौजूद x का मान प्राप्त करना चाहते हैं। उदाहरण के लिए, हमें 1 और 100 के बीच मान की आवश्यकता हो सकती है, लेकिन हमें 123 का मान मिला। इसे ठीक करने के लिए, हम न्यूनतम (संख्याओं के सेट में से सबसे छोटा लौटाता है) और अधिकतम (किसी भी सेट में सबसे बड़ा लौटाता है) का उपयोग कर सकते हैं। संख्याओं का) हमारे उदाहरण में, सीमा 1 से 100 तक है:चलो lowBound = 1; मान लीजिए हाईबाउंड = 100; मान लीजिए numInput = 123; लेट क्लैंप्ड = मैथ.मैक्स(लोबाउंड, मैथ.मिन(numInput, हाईबाउंड)); कंसोल.लॉग(क्लैम्प्ड); > 100;
फिर से, हम डैनियल एक्स मूर द्वारा प्रस्तावित समाधान का उपयोग करके ऑपरेशन का पुन: उपयोग कर सकते हैं और पूरी चीज़ को एक फ़ंक्शन में लपेट सकते हैं:
नंबर.प्रोटोटाइप.क्लैंप = फ़ंक्शन (न्यूनतम, अधिकतम) (वापसी Math.min(Math.max(यह, न्यूनतम), अधिकतम); );
अब:
NumInput.clamp(लोबाउंड, हाईबाउंड); > 100;
गॉसियन राउंडिंग गॉसियन राउंडिंग, जिसे बैंकर राउंडिंग के रूप में भी जाना जाता है, में निकटतम सम संख्या तक राउंडिंग शामिल है। यह पूर्णांकन विधि सांख्यिकीय त्रुटि के बिना काम करती है। सर्वोत्तम निर्णयटिम डाउन द्वारा सुझाव दिया गया था:फ़ंक्शन गॉसराउंड(संख्या, दशमलव स्थान) ( मान लें कि d = दशमलव स्थान || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.floor (एन), एफ = एन - आई, ई = 1ई-8, आर = (एफ > 0.5 - ई && एफ< 0.5 + e) ?
((i % 2 == 0) ? i: i + 1) : Math.round(n);
return d ? r / m: r;
}
अब:
गॉसराउंड(2.5) > 2 गॉसराउंड(3.5) > 4 गॉसराउंड(2.57,1) > 2.6
सीएसएस में दशमलव:
चूँकि जावास्क्रिप्ट का उपयोग अक्सर HTML तत्वों के लिए स्थितीय मानचित्रण बनाने के लिए किया जाता है, आप सोच रहे होंगे कि यदि हम अपने तत्वों के लिए दशमलव मान उत्पन्न करें तो क्या होगा:
#बॉक्स (चौड़ाई: 63.667731993px; )
अच्छी खबर यह है कि आधुनिक ब्राउज़र प्रतिशत या पिक्सेल इकाइयों सहित ब्लॉक मॉडल में दशमलव मानों का सम्मान करेंगे।
फल दें = ["बटरनट स्क्वैश", "खुबानी", "खरबूजा"]; फल.सॉर्ट(); > "खुबानी", "बटरनट स्क्वैश", "खरबूजा"]
हालाँकि, जैसे ही कोई एक तत्व अपरकेस होता है, हम एक समस्या में पड़ जाते हैं:
फल दें = ["बटरनट स्क्वैश", "खुबानी", "कैंटालोप"]; फल.सॉर्ट(); > "कैंटालूप", "खुबानी", "बटरनट स्क्वैश"]
ऐसा इसलिए है, क्योंकि डिफ़ॉल्ट रूप से, सॉर्टर यूनिकोड में दर्शाए गए पहले वर्ण की तुलना करता है। यूनिकोड है अद्वितीय कोडकिसी भी प्रतीक के लिए, मंच की परवाह किए बिना, कार्यक्रम की परवाह किए बिना, भाषा की परवाह किए बिना। उदाहरण के लिए, यदि आप कोड तालिका को देखें, तो वर्ण "a" का मान U+0061 (हेक्साडेसिमल 0x61 में) है, जबकि वर्ण "C" का कोड U+0043 (0x43) है, जो यूनिकोड में पहले आता है तालिका में वर्ण "ए" से अधिक।
एक सरणी को सॉर्ट करने के लिए जिसमें मिश्रित केस के पहले अक्षर हो सकते हैं, हमें या तो सभी तत्वों को अस्थायी रूप से लोअर केस में परिवर्तित करना होगा, या कुछ तर्कों के साथ localeCompare() विधि का उपयोग करके हमारे सॉर्ट ऑर्डर को परिभाषित करना होगा। एक नियम के रूप में, ऐसे मामले के लिए, बार-बार उपयोग के लिए तुरंत एक फ़ंक्शन बनाना बेहतर होता है:
फ़ंक्शन अल्फ़ासॉर्ट (arr) ( arr.sort (फ़ंक्शन (ए, बी) ( रिटर्न a.localeCompare (बी, "एन", ("संवेदनशीलता": "बेस")); )); ) फल दें = ["बटरनट स्क्वैश ", "खुबानी", "कैंटालूप"]; अल्फ़ासॉर्ट(फल) >
यदि आप चाहते हैं कि सरणी उल्टे वर्णमाला क्रम में क्रमबद्ध हो, तो बस फ़ंक्शन में ए और बी की स्थिति को स्वैप करें:
फ़ंक्शन अल्फ़ासॉर्ट (arr) ( arr.sort (फ़ंक्शन (ए, बी) ( रिटर्न b.localeCompare (ए, "एन", ("संवेदनशीलता": "बेस")); )); ) फल दें = ["बटरनट स्क्वैश ", "खुबानी", "कैंटालूप"]; अल्फ़ासॉर्ट(फल) > ["कैंटालूप", "बटरनट स्क्वैश", "खुबानी"]
यहां यह ध्यान देने योग्य है कि localeCompare का उपयोग तर्कों के साथ किया जाता है, हमें यह भी याद रखना होगा कि यह IE11+ द्वारा समर्थित है, IE के पुराने संस्करणों के लिए, हम इसे तर्कों के बिना और लोअरकेस में उपयोग कर सकते हैं:
फ़ंक्शन केस सॉर्ट (arr) ( arr.sort (फ़ंक्शन (ए, बी) ( रिटर्न a.toLowerCase().localeCompare(b.toLowerCase()); )); ) फल दें = ["बटरनट स्क्वैश", "खुबानी", "खरबूजा"]; केससॉर्ट (फल) > ["खुबानी", "बटरनट स्क्वैश", "कैंटालूप"]
संख्यात्मक छँटाई यह सब उस उदाहरण पर लागू नहीं होता है जिसके बारे में हमने गेम रिकॉर्ड की सरणी के बारे में ऊपर बात की थी। कुछ संख्यात्मक सरणियों के साथ, सॉर्टिंग ठीक काम करती है, लेकिन कुछ बिंदु पर परिणाम अप्रत्याशित हो सकता है:मान लीजिए हाईस्कोर्स = ; हाईस्कोर्स.सॉर्ट(); >
बात यह है कि सॉर्ट () विधि एक लेक्सिकोग्राफ़िक तुलना करती है: जिसका अर्थ है कि संख्याओं को एक स्ट्रिंग में परिवर्तित किया जाएगा और तुलना फिर से यूनिकोड तालिका में वर्णों के क्रम में उस स्ट्रिंग के पहले अक्षर से मिलान करके की जाएगी। . इसलिए, हमें फिर से अपने सॉर्ट क्रम को परिभाषित करने की आवश्यकता है:
मान लीजिए हाईस्कोर्स = ; हाईस्कोर्स.सॉर्ट(फ़ंक्शन(ए,बी) (रिटर्न ए - बी; )); >
फिर से, संख्याओं को उल्टे क्रम में क्रमबद्ध करने के लिए, फ़ंक्शन में a और b की स्थिति को स्वैप करें।
मान लीजिए स्कोर = [( "नाम": "डैनियल", "स्कोर": 21768 ), ( "नाम": "माइकल", "स्कोर": 33579 ), ( "नाम": "एलिसन", "स्कोर": 38395 ) ];
ES6+ में, आप एरो फ़ंक्शंस का उपयोग कर सकते हैं:
स्कोर.सॉर्ट((ए, बी) => बी.स्कोर - ए.स्कोर));
पुराने ब्राउज़रों के लिए जिनके पास यह समर्थन नहीं है:
स्कोर्स.सॉर्ट(फ़ंक्शन(ए, बी) ( रिटर्न ए.स्कोर - बी.स्कोर ));
जैसा कि आप देख सकते हैं, जावास्क्रिप्ट में सॉर्ट करना एक अस्पष्ट बात है, मुझे उम्मीद है कि ये उदाहरण किसी तरह जीवन को आसान बना देंगे।
में जावास्क्रिप्ट शक्तिफ़ंक्शन को Math.pow() के रूप में दर्शाया गया है, नए ES7 मानक में एक नया घातांक ऑपरेटर - "* *" पेश किया गया था।
घात तक बढ़ाना किसी संख्या को nवीं घात तक बढ़ाने के लिए, Math.pow() फ़ंक्शन का उपयोग करें, जहां पहला तर्क वह संख्या है जिसे घात तक बढ़ाया जाएगा, दूसरा तर्क घातांक है:Math.pow(3,2) > 9
अंकन के इस रूप का अर्थ है 3 वर्ग, या 3 × 3, जो परिणाम 9 की ओर ले जाता है। बेशक, एक और उदाहरण दिया जा सकता है:
Math.pow(5,3); > 125
यानी 5 घन, या 5 × 5 × 5, 125 के बराबर है।
ईसीएमएस्क्रिप्ट 7 जावास्क्रिप्ट का अगला संस्करण है, सिद्धांत रूप में, हम नए प्रस्तावित घातांक ऑपरेटर का उपयोग कर सकते हैं - * *, नोटेशन का यह रूप अधिक वर्णनात्मक हो सकता है:
3 ** 2
> 9
पर इस पलइस ऑपरेटर के लिए समर्थन काफी सीमित है, इसलिए इसके उपयोग की अनुशंसा नहीं की जाती है।
पावर फ़ंक्शन विभिन्न स्थितियों में उपयोगी हो सकता है। एक घंटे में सेकंड की संख्या की गणना करने का एक सरल उदाहरण: Math.pow (60,2)।
वर्ग और घनमूल Math.sqrt() और Math.cbrt() Math.pow() के विपरीत हैं। जैसा कि हमें याद है, a का वर्गमूल वह संख्या है जो वर्ग करने पर a देता है।Math.sqrt(9) >3
वहीं, a का घनमूल एक संख्या है जो घन तक बढ़ाने पर a देता है।
गणित.cbrt(125) > 5
Math.cbrt() को हाल ही में जावास्क्रिप्ट विनिर्देश में पेश किया गया था, और इसलिए यह केवल आधुनिक ब्राउज़रों में समर्थित है: क्रोम 38+, फ़ायरफ़ॉक्स और ओपेरा 25+, और सफारी 7.1+। आप उस पर गौर करेंगे इंटरनेट एक्सप्लोररइस सूची में नहीं है, लेकिन आपको एमडीएन पर एक पॉलीफ़िल मिलेगा।
Math.pow(1.25, 2); > 1.5625 गणित.सीबीआरटी(56.57) > 3.8387991760286138
कृपया ध्यान दें कि उपयोग करते समय यह काफी अच्छी तरह से काम करता है नकारात्मक मानतर्क:
Math.pow(-5,2) > 25 Math.pow(10,-2) > 0.01
हालाँकि, यह वर्गमूल के लिए काम नहीं करेगा:
Math.sqrt(-9) > NaN
गणितीय विश्लेषण से हम जानते हैं कि एक काल्पनिक संख्या ऋणात्मक संख्याओं के वर्गमूल को संदर्भित करती है। और यह हमें जटिल संख्याओं के साथ काम करने की एक और तकनीक की ओर ले जा सकता है, लेकिन यह एक अलग कहानी है।
आप संख्याओं के वर्ग और घनमूल ज्ञात करने के लिए Math.pow() में भिन्नों का उपयोग कर सकते हैं। वर्गमूल 0.5 के घातांक का उपयोग करता है:
Math.pow(5, 0.5); // = Math.sqrt(5) = 5 ** (1/2) > 2.23606797749979
हालाँकि, फ़्लोटिंग पॉइंट की अनिश्चितताओं के कारण, आप सही परिणाम का सटीक अनुमान नहीं लगा सकते:
Math.pow(2.23606797749979,2) > 5.0000000001
ऐसी स्थितियों में, आपको संख्या से चिह्नों को काटने या किसी मान तक पूर्णांकित करने का सहारा लेना होगा।
कुछ लोग, अज्ञात कारणों से, जावास्क्रिप्ट में Math.pow() फ़ंक्शन को Math.exp() के साथ भ्रमित कर देते हैं, जो सामान्य रूप से संख्याओं के लिए घातीय फ़ंक्शन है। ध्यान दें: में अंग्रेजी भाषा"प्रतिपादक" का अनुवाद "प्रतिपादक" के रूप में किया जाता है, इसलिए यह अंग्रेजी बोलने वालों पर लागू होने की अधिक संभावना है, हालांकि प्रतिपादक के लिए वैकल्पिक नाम हैं, जैसे सूचकांक, शक्ति।
गणितीय स्थिरांक जावास्क्रिप्ट में गणित के साथ काम करना कई अंतर्निहित स्थिरांकों द्वारा आसान बना दिया गया है। ये स्थिरांक गणित वस्तु के गुण हैं। यह ध्यान देने योग्य है कि स्थिरांक अपरकेस में लिखे गए हैं, कैमलकेस नोटेशन में नहीं। Math.abs, parseInt, parseFloat जावास्क्रिप्ट में संख्याओं के साथ काम करना जितना लगता है उससे कहीं अधिक जटिल हो सकता है। प्राप्त मूल्य हमेशा अपेक्षित सीमा के भीतर नहीं आते हैं; कभी-कभी परिणाम वह नहीं हो सकता जिसकी हमें उम्मीद थी। Math.abs() Math.abs() विधि किसी संख्या का पूर्ण मान लौटाती है, जो हमें किसी संख्या के मापांक के लिए एक समान गणितीय फ़ंक्शन की याद दिलाती है।मान लीजिए newVal = -57.64; Math.abs(newVal); >57.64
Math.abs(0) हमेशा शून्य लौटाता है, लेकिन अगर हम -Math.abs(NUM) फ़ंक्शन के सामने ऋण चिह्न लगाते हैं तो हमें हमेशा एक नकारात्मक मान मिलेगा।
गणित.abs(0); >-0
parseInt() हम जानते हैं कि जावास्क्रिप्ट समझता है कि "15" एक स्ट्रिंग है, संख्या नहीं, और, उदाहरण के लिए, जब जावास्क्रिप्ट का उपयोग करके सीएसएस गुणों को पार्स किया जाता है, या किसी अप्रस्तुत सरणी से कोई मान प्राप्त किया जाता है, तो हमारे परिणाम अप्रत्याशित हो सकते हैं। हमें इनपुट के रूप में "17px" के रूप में प्रदर्शित एक स्ट्रिंग प्राप्त हो सकती है, और यह हमारे लिए असामान्य नहीं है। सवाल यह है कि इस स्ट्रिंग को वास्तविक मान में कैसे बदला जाए और आगे की गणना में इसका उपयोग कैसे किया जाए।सिंटैक्स: पार्सइंट (स्ट्रिंग, रेडिक्स);
ParseInt फ़ंक्शन इसे दिए गए पहले तर्क को एक स्ट्रिंग प्रकार में परिवर्तित करता है, इसकी व्याख्या करता है, और एक पूर्णांक या NaN मान लौटाता है। परिणाम (यदि NaN नहीं है) एक पूर्णांक है और पहला तर्क (स्ट्रिंग) है, जिसे निर्दिष्ट मूलांक में एक संख्या के रूप में माना जाता है। उदाहरण के लिए, आधार 10 दशमलव से रूपांतरण दर्शाता है, 8 अष्टाधारी से, 16 हेक्साडेसिमल से, इत्यादि। यदि आधार 10 से बड़ा है, तो 9 से बड़ी संख्याओं को दर्शाने के लिए अक्षरों का उपयोग किया जाता है। उदाहरण के लिए, हेक्साडेसिमल संख्याओं (आधार 16) के लिए, अक्षर A से F तक का उपयोग किया जाता है।
आइए सीएसएस गुणों के साथ काम करने का एक उदाहरण देखें, जहां, अपेक्षाकृत रूप से, हम निम्नलिखित मूल्य प्राप्त कर सकते हैं:
मान लीजिए elem = document.body; लेट सेंटरपॉइंट = window.getComputedStyle(elem).transformOrigin; > "454पीएक्स 2087.19पीएक्स"
हम मानों को रिक्त स्थान द्वारा विभाजित कर सकते हैं:
चलो केन्द्रों =centerPoint.split(" "); > ["454पीएक्स", "2087.19पीएक्स"]
हालाँकि, प्रत्येक तत्व अभी भी एक स्ट्रिंग है, हम अपने फ़ंक्शन का उपयोग करके इससे छुटकारा पा सकते हैं:
मान लीजिएcenterX =parseInt(केंद्र, 10); >454 लेट सेंटरवाई = पार्सइंट(सेंटर, 10); >2087
जैसा कि आप देख सकते हैं, दूसरे तर्क के साथ हम उस संख्या प्रणाली को इंगित करते हैं जिसमें संख्या परिवर्तित की जाएगी; यह पैरामीटर वैकल्पिक है, लेकिन यदि आप नहीं जानते कि कौन सी स्ट्रिंग इनपुट के रूप में प्राप्त होगी तो इसका उपयोग करने की अनुशंसा की जाती है।
सिंटैक्स: पार्सफ्लोट(स्ट्रिंग)
मान लीजिए एफपी = "33.33333%"; कंसोल.लॉग(parseFloat(FP)); >33.33333
ध्यान दें कि पार्सफ्लोट सिंटैक्स में कोई दूसरा तर्क नहीं है।
हम समझते हैं कि parseInt() और parseFloat() अत्यंत हैं उपयोगी विशेषताएँ, यह ध्यान रखना महत्वपूर्ण है कि अभी भी कुछ त्रुटियां शामिल हैं, इसलिए अपेक्षित मूल्यों की सीमा की जांच करना और अंततः यह सुनिश्चित करने के लिए परिणाम का विश्लेषण करना आवश्यक है कि प्राप्त मूल्य सही हैं।
गुमनाम रूप से भेजें
Math.round() फ़ंक्शन निकटतम पूर्णांक तक पूर्णांकित संख्या का मान लौटाता है।
इस इंटरैक्टिव उदाहरण का स्रोत GitHub रिपॉजिटरी में संग्रहीत है। यदि आप इंटरैक्टिव उदाहरण प्रोजेक्ट में योगदान देना चाहते हैं, तो कृपया https://github.com/mdn/interactive-examples को क्लोन करें और हमें एक पुल अनुरोध भेजें।
सिंटैक्स Math.round(x) पैरामीटर्स x एक संख्या। प्रतिलाभ की मात्रादी गई संख्या का मान निकटतम पूर्णांक तक पूर्णांकित किया गया।
विवरणयदि तर्क का भिन्नात्मक भाग 0.5 से अधिक है, तो तर्क को अगले उच्च निरपेक्ष मान के साथ पूर्णांक में पूर्णांकित किया जाता है। यदि यह 0.5 से कम है, तो तर्क को निम्न निरपेक्ष मान वाले पूर्णांक में पूर्णांकित किया जाता है। यदि भिन्नात्मक भाग बिल्कुल 0.5 है, तो तर्क को +∞ की दिशा में अगले पूर्णांक तक पूर्णांकित किया जाता है। ध्यान दें कि यह कई भाषाओं के "राउंड() फ़ंक्शंस से भिन्न है, जो अक्सर इस मामले को अगले पूर्णांक तक पूर्णांकित करते हैं शून्य से दूर, इसके बजाय बिल्कुल 0.5 के आंशिक भाग के साथ नकारात्मक संख्याओं के मामले में एक अलग परिणाम दे रहा है।
क्योंकि राउंड() मैथ की एक स्थिर विधि है, आप इसे हमेशा अपने द्वारा बनाए गए मैथ ऑब्जेक्ट की विधि के बजाय Math.round() के रूप में उपयोग करते हैं (मैथ का कोई कंस्ट्रक्टर नहीं है)।
उदाहरण गणित.राउंड(20.49); // 20 गणित.राउंड(20.5); // 21 गणित.राउंड(42); //42 गणित.राउंड(-20.5); // -20 गणित.राउंड(-20.51); // -21 प्रदर्शनात्मक कार्यान्वयननीचे कोड का एक स्निपेट है जो कार्यात्मक रूप से गणित.राउंड के बराबर है, सिवाय इसके कि नीचे दिए गए कोड का स्निपेट Math.round से धीमा है। नीचे दिए गए कोड के स्निपेट का उद्देश्य यह प्रदर्शित करना है कि Math.round कैसे काम करता है।
फ़ंक्शन वेनिला_राउंड(x) ( var y = Math.abs(x) + 0.5; // ताकि 1/2 से कम राउंड नीचे आएं; अधिक राउंड अप रिटर्न Math.floor(x+0.5) )
उपरोक्त मापांक ऑपरेटर को x का दशमलव भाग मिलता है। इसके अलावा, उपरोक्त कोड स्निपेट को किसी संख्या पर एक निश्चित परिशुद्धता के लिए गोल करने के लिए संशोधित किया जा सकता है:
फ़ंक्शन राउंड_टू_प्रिसिजन(x, प्रिसिजन) ( var y = +x + (परिशुद्धता === अपरिभाषित? 0.5: परिशुद्धता/2); रिटर्न y - (y % (सटीकता === अपरिभाषित? 1: +सटीकता)); )
राउंड_टू_प्रेसिजन(11, 2); // आउटपुट 12 राउंड_टू_प्रिसिजन(11, 3); // आउटपुट 12 राउंड_टू_प्रिसिजन(11, 4); // आउटपुट 12 राउंड_टू_प्रिसिजन(11, 5); // आउटपुट 10 राउंड_टू_प्रिसिजन(11, 6); // आउटपुट 12 राउंड_टू_प्रिसिजन(11, 7); // आउटपुट 14 राउंड_टू_प्रिसिजन(11, 8); // आउटपुट 8 राउंड_टू_प्रिसिजन(3.7, 0.5); // आउटपुट 3.5 राउंड_टू_प्रिसिजन(3.75, 0.5); // आउटपुट 4 राउंड_टू_प्रिसिजन(3.8, 0.5); // आउटपुट 4
विशेष विवरण| ईसीएमएस्क्रिप्ट प्रथम संस्करण (ईसीएमए-262) | मानक | प्रारंभिक परिभाषा. जावास्क्रिप्ट 1.0 में लागू किया गया। |
| ईसीएमएस्क्रिप्ट 5.1 (ईसीएमए-262) |
मानक | |
| ईसीएमएस्क्रिप्ट 2015 (छठा संस्करण, ईसीएमए-262) उस विनिर्देश में "मैथ.राउंड" की परिभाषा। |
मानक | |
| ईसीएमएस्क्रिप्ट नवीनतम ड्राफ्ट (ईसीएमए-262) उस विनिर्देश में "मैथ.राउंड" की परिभाषा। |
मसौदा |
इस पृष्ठ में संगतता तालिका संरचित डेटा से तैयार की गई है। यदि आप डेटा में योगदान देना चाहते हैं, तो कृपया https://github.com/mdn/browser-compat-data देखें और हमें एक पुल अनुरोध भेजें।
GitHub पर संगतता डेटा अपडेट करें
| डेस्कटॉप मोबाइल सर्वर | ||||||||||||
| क्रोम एज फ़ायरफ़ॉक्स इंटरनेट एक्सप्लोरर ओपेरा सफारी एंड्रॉइड वेबव्यू एंड्रॉइड के लिए क्रोम एंड्रॉइड के लिए फ़ायरफ़ॉक्स एंड्रॉइड के लिए ओपेरा आईओएस सैमसंग इंटरनेट नोड.जेएस पर एंड्रॉइड के लिए सफारी | ||||||||||||
| क्रोम पूर्ण समर्थन 1 | एज पूर्ण समर्थन 12 | फ़ायरफ़ॉक्स पूर्ण समर्थन 1 | IE पूर्ण समर्थन 3 | ओपेरा पूर्ण समर्थन हाँ | सफ़ारी पूर्ण समर्थन हाँ | WebView Android पूर्ण समर्थन 1 | क्रोम एंड्रॉइड पूर्ण समर्थन 18 | फ़ायरफ़ॉक्स एंड्रॉइड पूर्ण समर्थन 4 | ओपेरा एंड्रॉइड पूर्ण समर्थन हां | सफ़ारी iOS पूर्ण समर्थन हाँ | सैमसंग इंटरनेट एंड्रॉइड पूर्ण समर्थन 1.0 | नोडज पूर्ण समर्थन हाँ |
आइए अब फर्श विधि पर नजर डालें (लिंग के रूप में अनुवादित), जो सीईआईएल विधि के विपरीत काम करता है, यानी। यह एक अंश को नीचे की ओर पूर्णांकित करता है।
वर आयु = 35.97 ;
उम्र = गणित.मंजिल(उम्र); /*आयु चर के मान को नीचे की ओर पूर्णांकित करें*/
दस्तावेज़.लिखें(उम्र);
जैसा कि आप देख सकते हैं, फ़्लोर पद्धति ने संख्या को 35.97 से 35 तक पूर्णांकित किया, अर्थात नीचे की ओर। इस तथ्य के बावजूद कि 0.97, 0.5 से अधिक है (सेमी। ).
इस पाठ में भिन्नात्मक दशमलव संख्याओं को पूर्णांकित करने के लिए गणित वस्तु के तरीकों पर ध्यान दिया गया।
अब तुम्हें अपना होमवर्क करना है.
आपका कार्य एक फ़ंक्शन लिखना है जो दो पैरामीटर लेता है।
1. भिन्नों वाली संख्याओं से युक्त एक सारणी।
2. गोलाई विधि "गोल", "छत" या "फर्श"।
आउटपुट पर, फ़ंक्शन को समान सरणी आउटपुट करनी चाहिए, लेकिन एक ही समय में सभी सरणी तत्व, दूसरे पैरामीटर में निर्दिष्ट गणित ऑब्जेक्ट विधि का उपयोग करके गोल किया जाना चाहिए।
स्रोत सरणी:
वर संख्याअरे = ;
सबसे पहले, इस कार्य को हल करना होमवर्क की समस्याओं को हल करने के लगभग समान लग सकता है पहले तीनपाठ इस विषय. लेकिन सब कुछ इतना सरल नहीं है...
समाधान #1 - ध्यान दें
कार्य की शर्तों के अनुसार, फ़ंक्शन को दो पैरामीटर लेने होंगे - मूल सरणी और विधियों में से एक: "गोल", "छत" या "मंजिल"। इसके आधार पर, मैंने यह करने का प्रयास किया...
फ़ंक्शन दशमलव (कोई भी ऐरे, विधि) /* दो पैरामीटर के साथ एक फ़ंक्शन बनाएं */
{
(i = 0 के लिए; i< anyArray .length ; i ++ )
{
दस्तावेज़.लिखें(anyArray
"
)
AnyArray = Math.method(anyArray); /* गणित ऑब्जेक्ट के तरीकों में से एक का उपयोग करके, हम सरणी के वर्तमान तत्व को गोल करते हैं */
दस्तावेज़.लिखें(anyArray + "
"
)
}
दशमलव (नंबरअरे, राउंड) /* फ़ंक्शन को कॉल करें और इसके लिए दो पैरामीटर निर्दिष्ट करें। लेकिन आप विधि NAME को फ़ंक्शन पैरामीटर के रूप में निर्दिष्ट नहीं कर सकते */
इस समाधान में, हम दो पैरामीटर के साथ एक फ़ंक्शन बनाते हैं, और जब हम इसे कॉल करते हैं, तो हम स्रोत सरणी और एक विधि के NAME को फ़ंक्शन पैरामीटर के रूप में निर्दिष्ट करने का प्रयास करते हैं:
दशमलव (नंबरअरे, राउंड) - इस मामले में राउंड।
लेकिन हमें कोई परिणाम नहीं मिलेगा, क्योंकि आप विधि NAME को फ़ंक्शन पैरामीटर के रूप में निर्दिष्ट नहीं कर सकते।
कृपया ध्यान दें: यह कोई संयोग नहीं है कि समस्या कथन में "राउंड", "सील" और "फ्लोर" विधियों के नाम उद्धरण चिह्नों में संलग्न हैं।
दशमलव (संख्या सारणी, "गोल") - लेकिन ऐसा अंकन भी सही नहीं होगा!!!
समाधान क्रमांक 2 - पिछले समाधान को सुधारना
आप फ़ंक्शन के लिए एक पैरामीटर निर्दिष्ट करके समस्या का समाधान कर सकते हैं।
वर संख्याअरे = ;
फ़ंक्शन दशमलव (anyArray ) /* एक पैरामीटर के साथ एक फ़ंक्शन बनाएं */
{
(i = 0 के लिए; i< anyArray .length ; i ++ ) /* Перебираем элементы массива */
{
document.write(anyArray + " - स्रोत सरणी तत्व
" ) /* सरणी के वर्तमान तत्व को आउटपुट करें */
/* गणित ऑब्जेक्ट की गोल विधि का उपयोग करके, हम सरणी के वर्तमान तत्व को गोल करते हैं */
document.write(anyArray + " - गोलाकार तत्व
" ) /* गोलाकार सरणी तत्व को आउटपुट करें */
}
दशमलव (नंबरअरे) /* फ़ंक्शन को कॉल करें और एक पैरामीटर निर्दिष्ट करें - मूल सरणी */
35 - गोल तत्व
13 - गोल तत्व
17 - गोल तत्व
79 - गोल तत्व
यहां हम वांछित परिणाम प्राप्त करने में कामयाब रहे: राउंड विधि ने सभी संख्याओं को पूर्णांकित किया। लेकिन शर्त पूरी नहीं हुई, क्योंकि फ़ंक्शन केवल एक पैरामीटर लेता है।
समाधान #3 - दो मापदंडों के साथ कार्य
यहां समस्या का सही समाधान किया गया है. ऐसा करने के लिए मुझे याद रखना पड़ा जावास्क्रिप्ट शर्तें थीमऔर आवेदन करें कई शर्तेंइसके साथ ही।
वर संख्याअरे = ;
फ़ंक्शन दशमलव (कोई भी ऐरे, विधि)
{
(i = 0 के लिए; i<
anyArray
.length
; i
++
)
{
document.write(anyArray + " - स्रोत सरणी तत्व
"
);
यदि (विधि
{
AnyArray = Math.round(anyArray);
document.write(anyArray + " - मानक गोलाई
"
)
}
अन्यथा यदि(विधि
{
document.write (anyArray + " - राउंड अप
"
)
}
अन्यथा यदि(विधि
{
document.write (anyArray + " - राउंड डाउन
"
)
}
}
}
दशमलव (नंबरअरे, "सील") /* फ़ंक्शन का दूसरा पैरामीटर - उद्धरण चिह्नों में, विधियों में से एक का नाम इंगित करें */
34.82 - सरणी का प्रारंभिक तत्व
35 - राउंड अप
12.9 - प्रारंभिक सरणी तत्व
13 - राउंड अप
17.01 - सरणी का प्रारंभिक तत्व
18 - राउंड अप
78.51 - सरणी का प्रारंभिक तत्व
79 - राउंड अप
यह सही समाधानगृहकार्य। यहां शर्त के अनुसार फ़ंक्शन के लिए दो पैरामीटर निर्दिष्ट किए गए हैं।
इसे आज़माएं अंतिम पंक्तियह समाधान:
दशमलव (नंबरअरे, "सील") फ़ंक्शन के दूसरे पैरामीटर के रूप में, गणित ऑब्जेक्ट के अन्य तरीकों "राउंड" और "फ्लोर" के नाम निर्दिष्ट करें।
समाधान #4 - दो मापदंडों के साथ कार्य + शीघ्र विधि
मैंने पिछले समाधान को थोड़ा अनुकूलित करने का निर्णय लिया और जोड़ा शीघ्र विधिजिसकी वजह से मोडल विंडो, जिसमें जानकारी दर्ज करने के लिए एक फ़ील्ड शामिल है।
अब, इसके लिए धन्यवाद, आप इनपुट फ़ील्ड में राउंड, फ़्लोर या सील में से किसी एक विधि का नाम दर्ज कर सकते हैं और संबंधित परिणाम प्राप्त कर सकते हैं।
वर संख्याअरे = ;
फ़ंक्शन दशमलव (कोई भी ऐरे, विधि)
{
(i = 0 के लिए; i<
anyArray
.length
; i
++
)
{
document.write(anyArray + " - स्रोत सरणी तत्व
"
);
यदि (विधि == "गोल") /* पहली शर्त */
{
AnyArray = Math.round(anyArray);
दस्तावेज़.लिखें(anyArray + "
"
)
}
अन्यथा यदि (विधि == "छत") /* दूसरी शर्त */
{
AnyArray = Math.ceil(anyArray);
दस्तावेज़.लिखें(anyArray + "
"
)
}
अन्यथा यदि (विधि == "मंजिल") /* तीसरी शर्त */
{
AnyArray = Math.floor(anyArray);
दस्तावेज़.लिखें(anyArray + "
"
)
}
/* शीघ्र विधि जोड़ें */
var विधि = संकेत ("विधियों में से एक दर्ज करें: गोल, छत या फर्श");
यदि (विधि == "मंजिल") /* पहली शर्त */
{
document.write("आपने एक विधि " + विधि + " दर्ज की है जो संख्याओं को नीचे की ओर पूर्णांकित करती है
"
)
}
अन्यथा यदि (विधि == "गोल") /* दूसरी शर्त */
{
document.write("आपने एक विधि " + विधि + " दर्ज की है जो मानक नियमों के अनुसार संख्याओं को पूर्णांकित करती है
"
)
}
अन्यथा यदि (विधि == "छत") /* तीसरी शर्त */
{
document.write("आपने एक विधि " + विधि + " दर्ज की है जो संख्याओं को पूर्णांकित करती है
"
)
}
अन्यथा /* अन्यथा... */
{
document.write("आपने कोई विधि गलत तरीके से दर्ज नहीं की है या दर्ज नहीं की है
"
)
}
दशमलव (नंबरअरे, विधि) /* फ़ंक्शन को कॉल करें */
गणित वस्तु की गोल, फर्श या छत विधियाँ इसी प्रकार काम करती हैं, जो भिन्नात्मक संख्याओं को गोल करती हैं।
इस लेख में हम संख्याओं, गणितीय ऑपरेटरों, किसी संख्या को एक स्ट्रिंग में बदलने के तरीकों और इसके विपरीत, साथ ही कई अन्य महत्वपूर्ण बिंदुओं पर विस्तार से नज़र डालेंगे।
परिमित फ़ंक्शन हैIsFinite फ़ंक्शन आपको यह जांचने की अनुमति देता है कि कोई तर्क एक सीमित संख्या है या नहीं।
उत्तर के रूप में यह फ़ंक्शनयदि तर्क Infinity , -Infinity , NaN है, या इन विशेष संख्यात्मक मानों में से किसी एक पर डाला जाएगा तो गलत रिटर्न देता है। अन्यथा, यह फ़ंक्शन सत्य लौट आएगा।
परिमित(73); //सत्य isFinite(-1/0); //झूठा isFinite(अनंत); //झूठा isFinite(NaN); //झूठा isFinite('पाठ'); // असत्य
के अलावा वैश्विक कार्य isFinite जावास्क्रिप्ट में Number.isFinite नामक एक विधि भी है। IsFinite के विपरीत, यह तर्क को किसी संख्या में परिवर्तित करने के लिए बाध्य नहीं करता है।
IsFinite('73'); //सत्य संख्या.isFinite('73'); // असत्य
isNaN फ़ंक्शनIsNaN फ़ंक्शन को यह निर्धारित करने के लिए डिज़ाइन किया गया है कि कोई तर्क एक संख्या है या उसे एक में परिवर्तित किया जा सकता है। यदि ऐसा है, तो isNaN फ़ंक्शन गलत रिटर्न देता है। अन्यथा यह सत्य हो जाता है।
IsNaN(NaN); //सत्य isNaN('25px'); //सच है, क्योंकि 20px एक संख्या नहीं है isNaN(25.5); //झूठा isNaN('25.5'); //झूठा isNaN(''); //झूठा, क्योंकि एक स्थान या कई रिक्त स्थान को 0 isNaN(null) में परिवर्तित किया जाता है; //झूठा, क्योंकि null को 0 isNaN(true) में बदल दिया गया है; //झूठा, क्योंकि सत्य को 1 isNaN(गलत) में बदल दिया गया है; //झूठा, क्योंकि असत्य को 0 में बदल दिया गया है
यदि इस क्रिया को बिना टाइप कास्ट के निष्पादित करने की आवश्यकता है, तो Number.isNaN विधि का उपयोग करें। इस पद्धति को ECMAScript 6 से शुरू करके भाषा में पेश किया गया था।
किसी स्ट्रिंग को स्पष्ट रूप से किसी संख्या में कैसे परिवर्तित करें?आप निम्न विधियों का उपयोग करके किसी स्ट्रिंग को स्पष्ट रूप से किसी संख्या में परिवर्तित कर सकते हैं:
1. यूनरी + ऑपरेटर का उपयोग करें, जिसे मान से पहले रखा जाना चाहिए।
+"7.35"; // 7.35 +"पाठ"; // NaN
यह विधि पंक्ति के आरंभ और अंत में रिक्त स्थान, साथ ही \n (लाइन फ़ीड) को अनदेखा करती है।
+"7.35"; //7.35 +"7.35 \n "; //7.35
का उपयोग करते हुए यह विधिध्यान दें कि एक खाली स्ट्रिंग या रिक्त स्थान और \n से युक्त एक स्ट्रिंग को संख्या 0 में परिवर्तित किया जाता है। इसके अलावा, यह शून्य डेटा प्रकार और बूलियन मानों को भी एक संख्या में परिवर्तित करता है।
व्यर्थ; //0 +सत्य; //1 +झूठा; //0 +" "; //0
2. पार्सइंट फ़ंक्शन। यह फ़ंक्शन किसी तर्क को पूर्णांक में बदलने के लिए डिज़ाइन किया गया है। यूनरी + ऑपरेटर का उपयोग करने के विपरीत, यह विधिआपको एक स्ट्रिंग को एक संख्या में बदलने की अनुमति देता है जिसमें सभी वर्ण संख्यात्मक नहीं होते हैं। यह पहले अक्षर से शुरू करके, स्ट्रिंग को परिवर्तित करना शुरू करता है। और जैसे ही इसका सामना किसी गैर-संख्यात्मक वर्ण से होता है, यह फ़ंक्शन अपना काम बंद कर देता है और परिणामी संख्या लौटा देता है।
ParseInt('18px'); //18 पार्सइंट('33.3%'); //33
यह फ़ंक्शन विभिन्न संख्या प्रणालियों (बाइनरी, ऑक्टल, दशमलव, हेक्साडेसिमल) के साथ काम कर सकता है। संख्या प्रणाली का आधार 2 तर्कों का उपयोग करके निर्दिष्ट किया गया है।
ParseInt('18px', 10); //18 पार्सइंट('33.3%', 10); //33 पार्सइंट('101',2); //5 पार्सइंट('बी5',16); //181
ParseInt फ़ंक्शन के अलावा, जावास्क्रिप्ट में Number.parseInt विधि है। यह विधि parseInt फ़ंक्शन से अलग नहीं है और इसे ECMASCRIPT 2015 (6) विनिर्देश के साथ जावास्क्रिप्ट में पेश किया गया था।
3. पार्सफ्लोट फ़ंक्शन। ParseFloat फ़ंक्शन parseInt के समान है, सिवाय इसके कि यह आपको तर्क को भिन्नात्मक संख्या में बदलने की अनुमति देता है।
पार्सफ्लोट('33.3%'); //33.3
इसके अलावा, parseFloat फ़ंक्शन, parseInt के विपरीत, 2 तर्क नहीं है, और इसलिए यह हमेशा दशमलव नोटेशन सिस्टम में स्ट्रिंग को एक संख्या के रूप में मानने का प्रयास करता है।
पार्सफ्लोट('3.14'); पार्सफ्लोट('314e-2'); पार्सफ्लोट('0.0314ई+2');
पार्सफ्लोट फ़ंक्शन के अलावा, जावास्क्रिप्ट में Number.parseFloat विधि है। यह विधि पार्सफ्लोट फ़ंक्शन से अलग नहीं है और इसे ECMASCRIPT 2015 (6) विनिर्देश के साथ जावास्क्रिप्ट में पेश किया गया था।
किसी संख्या को स्ट्रिंग में परिवर्तित करनाआप toString विधि का उपयोग करके किसी संख्या को स्ट्रिंग में बदल सकते हैं।
(12.8).toString(); //"12.8"
ToString विधि आपको संख्या प्रणाली का आधार निर्दिष्ट करने की भी अनुमति देती है, जिसे ध्यान में रखते हुए आपको संख्या को स्पष्ट रूप से एक स्ट्रिंग में बदलने की आवश्यकता होती है:
(255).टूस्ट्रिंग(16); //"एफएफ"
कैसे जांचें कि कोई वेरिएबल एक संख्या है या नहींआप निम्न विधियों में से किसी एक का उपयोग करके यह निर्धारित कर सकते हैं कि किसी चर का मान एक संख्या है या नहीं:
1. isNaN और isFinite फ़ंक्शंस का उपयोग करना:
// myVar एक वेरिएबल है यदि (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar एक संख्या है या इसे इसमें डाला जा सकता है);
एक समारोह के रूप में:
// फ़ंक्शन फ़ंक्शन isNumeric(value) ( return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // var myVar = "12px" का उपयोग करें; कंसोल.लॉग(isन्यूमेरिक(myVar)); //सत्य
यह विधि आपको यह निर्धारित करने की अनुमति देती है कि निर्दिष्ट मान एक संख्या है या उसे एक में परिवर्तित किया जा सकता है। यह विकल्प रिक्त स्ट्रिंग, रिक्त स्थान की स्ट्रिंग, शून्य, अनंत, -अनंत, सत्य और असत्य को एक संख्या के रूप में नहीं गिनता है।
2. टाइपोफ़ ऑपरेटर और isFinite, isNaN फ़ंक्शंस का उपयोग करना:
// फ़ंक्शन जो जांचता है कि मान एक संख्या फ़ंक्शन है या नहीं, फ़ंक्शन isNumber(value) ( मान का रिटर्न प्रकार === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}
यह फ़ंक्शन निर्धारित करता है कि क्या निर्दिष्ट मान संख्या प्रकार का है और क्या यह विशेष मान इन्फिनिटी, -इन्फिनिटी और NaN में से एक है। यदि ऐसा है, तो यह फ़ंक्शन सत्य लौटाता है।
3. ECMAScript 6 Number.isInteger(value) पद्धति का उपयोग करना। यह विधि आपको यह निर्धारित करने की अनुमति देती है कि निर्दिष्ट मान एक पूर्णांक है या नहीं।
Number.isInteger("20"); //झूठा, क्योंकि यह विधि किसी स्ट्रिंग को किसी संख्या में परिवर्तित नहीं करती है Number.isInteger(20); //सच है, क्योंकि यह मान एक संख्या है
सम और विषम संख्याएँआप निम्नलिखित फ़ंक्शन का उपयोग करके जांच सकते हैं कि कोई संख्या सम है या विषम:
// सम समता फ़ंक्शन के लिए किसी संख्या की जाँच करने का फ़ंक्शन isEven(n) ( return n % 2 == 0; ) // विषम समता फ़ंक्शन के लिए किसी संख्या की जाँच करने का फ़ंक्शन isOdd(n) ( return Math.abs(n % 2) == 1 )
लेकिन ऐसी जाँच करने से पहले, यह सुनिश्चित करना उचित है कि निर्दिष्ट मान एक संख्या है:
मान = 20; यदि (Number.isInteger(मान)) ( यदि (isEven(मान)) ( कंसोल.लॉग("नंबर " + value.toString() + " - सम"); ) )
जावास्क्रिप्ट में अभाज्य संख्याएँआइए एक उदाहरण देखें जिसमें से हम प्राप्त करते हैं जावास्क्रिप्ट का उपयोग करना 2 से 100 तक अभाज्य संख्याएँ।
// फ़ंक्शन जो जाँचता है कि कोई संख्या अभाज्य है या नहीं फ़ंक्शन isPrime(value) ( if (isNaN(value) || !isFinite(value) || value%1 || value< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i (больше), < (меньше), >= (इससे अधिक या इसके बराबर), 3); //झूठा कंसोल.लॉग(5>=3); //सत्य
भिन्नात्मक भाग के साथ संख्याओं की तुलना करते समय, इन गणनाओं के दौरान उत्पन्न होने वाली त्रुटियों को ध्यान में रखना आवश्यक है।
उदाहरण के लिए, जावास्क्रिप्ट में संख्याओं का योग (0.2 + 0.4) 0.6 के बराबर नहीं है:
कंसोल.लॉग((0.2+0.4)==0.6); //असत्य
त्रुटियाँ इसलिए होती हैं क्योंकि सभी गणनाएँ कंप्यूटर या अन्य द्वारा की जाती हैं इलेक्ट्रॉनिक उपकरण 2 संख्या प्रणाली में उत्पादन होता है। वे। कोई भी कार्य करने से पहले, कंप्यूटर को पहले अभिव्यक्ति में प्रस्तुत संख्याओं को दूसरी संख्या प्रणाली में परिवर्तित करना होगा। लेकिन प्रत्येक भिन्नात्मक दशमलव संख्या को दूसरी संख्या प्रणाली में सटीक रूप से प्रदर्शित नहीं किया जा सकता है।
उदाहरण के लिए, संख्या 0.25 10 इंच बायनरी सिस्टमबिल्कुल परिवर्तित।
0.125 × 2 = 0.25 | 0 0.25 × 2 = 0.5 | 0 0.5 × 2 = 1 | 1 0.125 10 = 0.001 2
उदाहरण के लिए, संख्या 0.2 10 को केवल एक निश्चित सटीकता के साथ 2 प्रणाली में परिवर्तित किया जा सकता है:
0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 ... 0.2 10 = 0.001100110011... 2
परिणामस्वरूप, ये त्रुटियाँ दो संख्याओं के योग की गणना और तुलना परिणामों को प्रभावित करेंगी। वे। यह पता चला है कि जावास्क्रिप्ट वास्तव में इस प्रविष्टि को इस प्रकार देखेगा:
0.6000000000000001==0.6
भिन्नात्मक भागों के साथ संख्याओं की गणना या प्रदर्शित करते समय, आपको हमेशा उस सटीकता को इंगित करना होगा जिसके साथ आप ऐसा करना चाहते हैं।
उदाहरण के लिए, toFixed() और toPrecision() विधियों का उपयोग करके 2 दशमलव स्थानों तक की संख्याओं की तुलना करें:
//विधि toFixed() कंसोल.लॉग((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //सही //विधि toPrecision() कंसोल.लॉग((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //सत्य
बुनियादी गणित संचालनजावास्क्रिप्ट में निम्नलिखित गणितीय ऑपरेटर मौजूद हैं: + (जोड़), - (घटाव), * (गुणा), / (विभाजन), % (मॉड्यूलो), ++ (मान को 1 से बढ़ाएं), - (मान को घटाएं) 1 ).
6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, यानी। 6:3=2 => 6-3*2 => बाकी(0) 5%2 //1, यानी। 5:2=2(.5) => 5-2*2 => बाकी(1) 7.3%2 //1.3, यानी। 7.3:2=3(.65) => 7.3-2*3 => बाकी(1.3) //% ऑपरेशन के परिणाम का चिह्न पहले मान के चिह्न के बराबर है -9%2.5 //-1.5 , अर्थात। 9:2.5=3(.6) => 9-2.5*3 => बाकी(1.5) -9%-2.5 //-1.5, यानी। 9:2.5=3(.6) => 9-2.5*3 => बाकी(1.5) -2%5 //-2, यानी। 2:5=0(.4) => 2-5*0 => बाकी(2) x = 3; कंसोल.लॉग(x++); //आउटपुट 3, फिर सेट 4 कंसोल.लॉग(x); //4 एक्स = 3; कंसोल.लॉग(++x); //सेट 4 और आउटपुट x = 5; कंसोल.लॉग(x--); //आउटपुट 5, फिर सेट 4 कंसोल.लॉग(x); //4 x = 5; कंसोल.लॉग(--x); //सेट 4 और आउटपुट इसके अलावा, जावास्क्रिप्ट में संयोजन ऑपरेटर हैं: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y). एक्स = 3; y = 6; x+=y; कंसोल.लॉग(x); //9 x = 3; y = 6; x-=y; कंसोल.लॉग(x); //-3 एक्स = 3; y = 6; x*=y; कंसोल.लॉग(x); //18 x = 3; y = 6; x/=y; कंसोल.लॉग(x); //0.5 x = 3; y = 6; x%=y; कंसोल.लॉग(x); //3
