पार्सफ़्लोट जावास्क्रिप्ट 2 दशमलव स्थान। जावास्क्रिप्ट में संख्याओं को पूर्णांकित करने की विधियाँ। निकटतम संख्या तक पूर्णांकित करें

जावास्क्रिप्ट गणित, दो दशमलव स्थानों तक पूर्णांकन (9)

मेरे पास निम्नलिखित जावास्क्रिप्ट सिंटैक्स है:

वार छूट = गणित.राउंड(100 - (मूल्य / सूची मूल्य) * 100);

इसे निकटतम पूर्ण संख्या में पूर्णांकित किया जाता है। मैं दो दशमलव स्थानों के साथ परिणाम कैसे लौटा सकता हूँ?

यहाँ एक कार्यशील उदाहरण है

वार मान=200.2365455; परिणाम=गणित.राउंड(मूल्य*100)/100 //परिणाम 200.24 होगा

दशमलव स्थानों की किसी भी संख्या में राउंडिंग को संभालने के लिए, कोड की 2 पंक्तियों वाला एक फ़ंक्शन अधिकांश आवश्यकताओं के लिए पर्याप्त होगा। यहाँ खेल के लिए एक उदाहरण कोड है.

वार टेस्टनम = 134.9567654; var decPl = 2; var testRes = राउंडडेक(testNum,decPl); चेतावनी(testNum + " पूर्णांकित " + decPl + " दशमलव स्थान है " + testRes); फ़ंक्शन राउंडडेक(nbr,dec_places)( var mult = Math.pow(10,dec_places); रिटर्न Math.round(nbr * मल्टी) / मल्टी; )

सबसे अच्छा और सरल समाधान जो मुझे मिला वह यह है

फ़ंक्शन राउंड(मान, दशमलव) (वापसी संख्या(गणित.राउंड(मान+"ई"+दशमलव)+"ई-"+दशमलव); ) राउंड(1.005, 2); // 1.01

स्वीकृत उत्तर में थोड़ा बदलाव। toFixed(2) एक स्ट्रिंग लौटाता है और आपको हमेशा दो दशमलव स्थान मिलेंगे। ये शून्य हो सकते हैं. यदि आप पिछले शून्य को दबाना चाहते हैं, तो बस यह करें:

वार डिस्काउंट = + ((कीमत/सूची कीमत).टूफिक्स्ड(2));

संपादित: मुझे अभी पता चला है कि फ़ायरफ़ॉक्स 35.0.1 में एक बग प्रतीत होता है, जिसका अर्थ है कि उपरोक्त NaN को कुछ मान दे सकता है।
मैंने अपना कोड इसमें बदल दिया

वार छूट = गणित.राउंड(मूल्य / सूची मूल्य * 100) / 100;

इससे संख्या दो दशमलव स्थानों तक सटीक हो जाती है। यदि आपको तीन की आवश्यकता है, तो आप 1000 से गुणा और भाग करेंगे, इत्यादि।
ओपी हमेशा दो दशमलव स्थान चाहता है, लेकिन यदि फ़ायरफ़ॉक्स में toFixed() टूट गया है, तो इसे पहले ठीक करने की आवश्यकता है।
https://bugzilla.mozilla.org/show_bug.cgi?id=1134388 देखें

दो दशमलव स्थानों के साथ परिणाम प्राप्त करने के लिए, आप निम्नलिखित कार्य कर सकते हैं:

वार छूट = गणित.राउंड((100 - (मूल्य / सूची मूल्य) * 100) * 100) / 100;

पहले दो अंकों को बनाए रखने के लिए पूर्णांकित किए जाने वाले मान को 100 से गुणा किया जाता है, फिर वास्तविक परिणाम प्राप्त करने के लिए हम 100 से विभाजित करते हैं।

मुझे लगता है कि सबसे अच्छा तरीकामैंने जो देखा है वह यह है कि अंकों की संख्या को 10 से गुणा करें, फिर गणित करें, और फिर अंत में अंकों की संख्या से 10 से भाग दें। यहां एक सरल फ़ंक्शन है जिसका उपयोग मैं टाइपस्क्रिप्ट में करता हूं:

फ़ंक्शन राउंडटूएक्सडिजिट्स (मूल्य: संख्या, अंक: संख्या) (मूल्य = मूल्य * गणित.पाउ(10, अंक); मूल्य = गणित.राउंड(मान); मूल्य = मूल्य / गणित.पाउ(10, अंक); वापसी मूल्य; )

या सरल जावास्क्रिप्ट:

फ़ंक्शन राउंडटूएक्सडिजिट्स (मूल्य, अंक) (यदि (अंक) (अंक = 2;) मूल्य = मूल्य * गणित.पाउ (10, अंक); मूल्य = गणित.राउंड (मूल्य); मूल्य = मूल्य / गणित.पाउ (10) , अंक); वापसी मूल्य)

टिप्पणी। - यदि 3-अंकीय परिशुद्धता महत्वपूर्ण है तो संपादन 4 देखें।

वार डिस्काउंट = (कीमत/सूची कीमत).toFixed(2);

2 दशमलव स्थानों से अधिक मानों के आधार पर आपके लिए राउंड ऊपर या नीचे निश्चित किया गया।

परिवर्तन।जैसा कि अन्य ने उल्लेख किया है, यह परिणाम को एक स्ट्रिंग में परिवर्तित करता है। इससे बचने के लिए:

वार छूट = +((कीमत/सूचीमूल्य).टूफिक्स्ड(2));

संपादन 2- जैसा कि टिप्पणियों में बताया गया है, यह फ़ंक्शन कुछ सटीकता के साथ कार्य नहीं करता है, उदाहरण के लिए 1.005 के मामले में यह 1.01 के बजाय 1.00 लौटाएगा। यदि सटीकता इतनी ही महत्वपूर्ण है, तो मुझे यह उत्तर मिला: https://.com/a/32605063/1726511 जो मेरे द्वारा आजमाए गए सभी परीक्षणों के साथ अच्छा काम करता प्रतीत होता है।

एक मामूली संशोधन की आवश्यकता है, लेकिन उपरोक्त उत्तर में फ़ंक्शन पूर्णांक देता है जब इसे एक में पूर्णांकित किया जाता है, इसलिए उदाहरण के लिए 99.004 99.00 के बजाय 99 लौटाएगा, जो कीमतें प्रदर्शित करने के लिए आदर्श नहीं है।

संपादित करें 3- ऐसा लगता है कि वास्तविक स्टिल रिटर्न पर फिक्स्ड कुछ संख्याओं को खराब कर रहा था, यह अंतिम संपादन काम करता प्रतीत होता है। हे भगवान, बहुत सारी क्षतिपूर्ति!

वार डिस्काउंट = राउंडटू((कीमत / सूची कीमत), 2); फ़ंक्शन राउंडटू(एन, अंक) (यदि (अंक === अपरिभाषित) (अंक = 0; ) वर गुणक = गणित.पाउ(10, अंक); एन = पार्सफ्लोट((एन * गुणक).टूफिक्स्ड(11)); var परीक्षण =(गणित.राउंड(एन) / गुणक); वापसी +(परीक्षण.टूफिक्स्ड(अंक));

संपादित करें 4- तुम लोग मुझे मार रहे हो। संपादित करें 3 ऋणात्मक संख्याओं पर विफल रहता है, बिना यह जाने कि पूर्णांकन करने से पहले ऋणात्मक संख्या को सकारात्मक बनाना आसान क्यों है, और फिर परिणाम वापस करने से पहले इसे वापस बदल दें।

फ़ंक्शन राउंडटू (एन, अंक) (var नकारात्मक = गलत; यदि (अंक === अपरिभाषित) (अंक = 0;) यदि (एन)< 0) { negative = true; n = n * -1; } var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); n = (Math.round(n) / multiplicator).toFixed(2); if(negative) { n = (n * -1).toFixed(2); } return n; }

सबसे तेज़ तरीका- toFixed() से तेज़:

दो डिकल्स

तीन दशमलवता

फ़ंक्शन राउंड(num,dec) ( num = Math.round(num+"e"+dec) रिटर्न नंबर(num+"e-"+dec) ) //अपनी पसंद के दशमलव तक राउंड करें: राउंड(1.3453,2)

पूर्णांकन क्यों आवश्यक है?

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
व्यावहारिक उद्देश्यों के लिए यह अशुद्धि कोई मायने नहीं रखती, हमारे मामले में हम क्विंटिलियंथ में त्रुटि के बारे में बात कर रहे हैं, हालाँकि, यह कुछ लोगों को निराश कर सकता है। मुद्राओं, प्रतिशतों या फ़ाइल आकारों को दर्शाने वाली संख्याओं के साथ काम करते समय हमें कुछ अजीब परिणाम भी मिल सकते हैं। इन अशुद्धियों को ठीक करने के लिए, हमें केवल परिणामों को पूर्णांकित करने में सक्षम होने की आवश्यकता है, और यह दशमलव परिशुद्धता निर्धारित करने के लिए पर्याप्त है।

संख्याओं को पूर्णांकित करना है प्रायोगिक उपयोग, हम किसी सीमा के भीतर किसी संख्या में हेरफेर कर सकते हैं, उदाहरण के लिए हम केवल दशमलव भाग के साथ काम करने के बजाय मान को निकटतम पूर्ण संख्या में पूर्णांकित करना चाहते हैं।

दशमलव संख्याओं को पूर्णांकित करना

1. यदि किसी तर्क को toFixed() के लिए परिभाषित नहीं किया गया है तो यह डिफ़ॉल्ट रूप से शून्य हो जाएगा, जिसका अर्थ है कि तर्क में 0 दशमलव स्थान हैं अधिकतम मूल्य, 20 के बराबर.
2. यदि toPrecision को कोई तर्क नहीं दिया जाता है, तो संख्या अछूती रह जाती है

मान लीजिए 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"

दशमलव में पूर्णांकन त्रुटियों से कैसे बचें

मान लीजिए 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

निकटतम संख्या तक पूर्णांकित करें

गणित.राउंड(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
एमडीएन पर आपको एक पॉलीफ़िल मिलेगा जो ब्राउज़र और IE/Edge में Math.trunc के लिए समर्थन प्रदान करेगा।

निकटतम पूर्ण संख्या तक पूर्णांकित करें

Math.ceil(42.23); >43 Math.ceil(36.93); >37 Math.ceil(-36.93); >-36

आवश्यक संख्या तक ऊपर/नीचे पूर्णांकित करना

फ़ंक्शन राउंडटू5(संख्या) (वापसी गणित.राउंड(संख्या/5)*5; )
अब:

राउंडटू5(11); >10
यदि आप अपने मान के गुणजों में पूर्णांक बनाना चाहते हैं, तो हम एक अधिक सामान्य फ़ंक्शन का उपयोग करते हैं, प्रारंभिक मान और गुणज को पास करते हुए:

फ़ंक्शन राउंडटूमल्टीपल(संख्या, एकाधिक) (वापसी Math.round(num/multiple)*multiple; )
अब:

माना प्रारंभिक संख्या = 11; मान लीजिए एकाधिक = 10; राउंडटूमल्टीपल (प्रारंभिक संख्या, एकाधिक); >10;

किसी श्रेणी में कोई संख्या निश्चित करना

चलो 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 की स्थिति को स्वैप करें।

JSON-जैसी संरचना को क्रमबद्ध करना

मान लीजिए स्कोर = [( "नाम": "डैनियल", "स्कोर": 21768 ), ( "नाम": "माइकल", "स्कोर": 33579 ), ( "नाम": "एलिसन", "स्कोर": 38395 ) ];
ES6+ में, आप एरो फ़ंक्शंस का उपयोग कर सकते हैं:

स्कोर.सॉर्ट((ए, बी) => बी.स्कोर - ए.स्कोर));
पुराने ब्राउज़रों के लिए जिनके पास यह समर्थन नहीं है:

स्कोर्स.सॉर्ट(फ़ंक्शन(ए, बी) ( रिटर्न ए.स्कोर - बी.स्कोर ));
जैसा कि आप देख सकते हैं, जावास्क्रिप्ट में सॉर्ट करना एक अस्पष्ट बात है, मुझे उम्मीद है कि ये उदाहरण किसी तरह जीवन को आसान बना देंगे।

पावर फ़ंक्शंस के साथ कार्य करना

जावास्क्रिप्ट में ऊर्जा समीकरण Math.pow() के रूप में पेश किए गए, नए ES7 मानक ने एक नया घातांक ऑपरेटर, "* *" पेश किया।

घातांक

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(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, पार्सइंट, पार्सफ्लोट

गणित.abs()

मान लीजिए newVal = -57.64; Math.abs(newVal); >57.64
Math.abs(0) हमेशा शून्य लौटाता है, लेकिन अगर हम -Math.abs(NUM) फ़ंक्शन के सामने ऋण चिह्न लगाते हैं तो हमें हमेशा एक नकारात्मक मान मिलेगा।

Math.abs(0); >-0

पार्सइंट()

सिंटैक्स: पार्सइंट (स्ट्रिंग, रेडिक्स);

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() अत्यंत हैं उपयोगी विशेषताएँ, यह ध्यान रखना महत्वपूर्ण है कि इसमें कुछ त्रुटियां शामिल हैं, इसलिए अपेक्षित मूल्यों की सीमा की जांच करना और अंततः यह सुनिश्चित करने के लिए परिणाम का विश्लेषण करना आवश्यक है कि प्राप्त मूल्य सही हैं।
गुमनाम रूप से भेजें

अक्सर गणना से ऐसे परिणाम मिलते हैं जो वांछित सीमा से बाहर होते हैं। फलस्वरूप इसे क्रियान्वित करना आवश्यक है जावास्क्रिप्ट गोलाईएक निश्चित मूल्य तक.

गोल संख्याएँ क्यों?

जावास्क्रिप्ट पूर्णांकों को संग्रहीत नहीं करता है क्योंकि उनके मान फ़्लोटिंग पॉइंट संख्याओं के रूप में दर्शाए जाते हैं। कई अंशों को दशमलव स्थानों की एक विशिष्ट सीमित संख्या के साथ एक संख्या के रूप में प्रस्तुत नहीं किया जा सकता है, इसलिए जावास्क्रिप्ट निम्नलिखित जैसे परिणाम उत्पन्न कर सकता है:

0.1 * 0.2; > 0.020000000000000004

व्यवहार में, इससे कोई फर्क नहीं पड़ेगा, क्योंकि हम 2 क्विंटलियनवें हिस्से की त्रुटि के बारे में बात कर रहे हैं। लेकिन यह उन संख्याओं के साथ काम करते समय परिणामों को प्रभावित कर सकता है जो मुद्रा मूल्यों, प्रतिशत या फ़ाइल आकार का प्रतिनिधित्व करते हैं। इसलिए, आपको एक निश्चित दशमलव स्थान पर या करने की आवश्यकता है।

दशमलव संख्याओं को पूर्णांकित करना

दशमलव संख्या को "काटने" के लिए, toFixed() या toPrecision() विधियों का उपयोग करें। वे दोनों एक तर्क लेते हैं, जो परिणाम में शामिल किए जाने वाले महत्वपूर्ण और दशमलव स्थानों की संख्या निर्दिष्ट करता है:

• यदि toFixed() में कोई तर्क निर्दिष्ट नहीं है, तो डिफ़ॉल्ट मान 0 है, अर्थात, कोई दशमलव स्थान नहीं है; अधिकतम तर्क मान 20 है;
• यदि toPrecision() के लिए कोई तर्क नहीं दिया जाता है, तो संख्या नहीं बदली जाती है।

वर रैंडनम = 6.25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" वर रैंडनम = 87.335; randNum.toFixed(2); > "87.33" var randNum = 87.337; randNum.toPrecision(3); > "87.3"

टिप्पणी

ToFixed() और toPrecision दोनों किसी संख्या के बजाय परिणाम का एक गोलाकार स्ट्रिंग प्रतिनिधित्व लौटाते हैं। इसका मतलब यह है कि randNum में राउंड जोड़ने से एकल संख्या के बजाय स्ट्रिंग्स का संयोजन होगा:

कंसोल.लॉग(रैंडनम + राउंडेड); > "6.256"

यदि आप चाहते हैं कि जावास्क्रिप्ट किसी संख्या को निकटतम सौवें तक पूर्णांकित करे, तो parseFloat() का उपयोग करें:

वर रैंडनम = 6.25; var गोलाकार = parseFloat(randNum.toFixed(1)); कंसोल.लॉग(गोल); > 6.3

बड़ी संख्या में दशमलव स्थानों को छोटा करने के लिए toFixed() और toPrecision() भी उपयोगी तरीके हैं। मौद्रिक इकाइयों का प्रतिनिधित्व करने वाली संख्याओं के साथ काम करते समय यह उपयोगी है:

var totalNum = 1 vardolCents = totalNum.toFixed(2); कंसोल.लॉग(डॉलरसेंट्स); > "1.00"

ध्यान दें कि यदि किसी संख्या में निर्दिष्ट परिशुद्धता से अधिक अंक हैं, तो प्रिसिजन परिणाम को वैज्ञानिक प्रारूप में आउटपुट करेगा:

var संख्या = 123.435 num.toPrecision(2); > "1.2e+2"

दशमलव को पूर्णांकित करते समय गलतियों से कैसे बचें

कुछ मामलों में toFixed और toPrecision लागू किया जाता है जावास्क्रिप्ट 5 से नीचे की ओर पूर्णांकित हो रहा है, और अधिक नहीं:

var numTest = 1.005; numTest.toFixed(2); > 1;

उपरोक्त उदाहरण का परिणाम 1.01 होना चाहिए, 1 नहीं। यदि आप इस त्रुटि से बचना चाहते हैं, तो मैं घातीय संख्याओं का उपयोग करने की सलाह देता हूं:

फ़ंक्शन राउंड(मान, दशमलव) (वापसी संख्या(गणित.राउंड(मान+"ई"+दशमलव)+"ई-"+दशमलव); )

आवेदन पत्र:

राउंड(1.005,2); > 1.01

यदि आपको राउंडिंग से भी अधिक मजबूत समाधान की आवश्यकता है, तो यह यहां उपलब्ध है एमडीएन.

ईपीएसलॉन के साथ गोलाई

वैकल्पिक तरीका जावास्क्रिप्ट को दसवें तक पूर्णांकित किया जा रहा है ES6 में पेश किया गया था ( जावास्क्रिप्ट 2015 के रूप में भी जाना जाता है). « मशीन ईपीएसलॉन"दो फ़्लोटिंग पॉइंट संख्याओं की तुलना करते समय त्रुटि का उचित मार्जिन प्रदान करता है। पूर्णांकन के बिना, तुलनाएँ निम्नलिखित के समान परिणाम उत्पन्न कर सकती हैं:

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

फ़ंक्शन दो तर्क लेता है: एक में गणनाएं शामिल हैं, दूसरे में अपेक्षित (गोल) परिणाम। यह इन दो मापदंडों की तुलना लौटाता है:

ईपीएसईक्यू(0.1 + 0.2, 0.3) > सत्य

सभी आधुनिक ब्राउज़र ES6 गणित फ़ंक्शंस का समर्थन करते हैं। लेकिन यदि आपको पुराने ब्राउज़र में सहायता प्रदान करने की आवश्यकता है, तो आपको पॉलीफ़िल का उपयोग करना होगा।

दशमलव संख्याओं का कटाव

पहले प्रस्तुत सभी विधियाँ कार्य करती हैं जावास्क्रिप्ट को दसवें तक पूर्णांकित किया जा रहा है. काट-छाँट करना सकारात्मक संख्यादशमलव के दो स्थानों तक, इसे 100 से गुणा करें, इसे फिर से छोटा करें, और फिर परिणाम को 100 से विभाजित करें, आपको चाहिए:

फ़ंक्शन छोटा किया गया(संख्या) (वापसी Math.trunc(num * 100) / 100; ) छोटा किया गया(3.1416) > 3.14

यदि आपको कुछ अधिक लचीला चाहिए, तो आप बिटवाइज़ ऑपरेटर का उपयोग कर सकते हैं:

फ़ंक्शन छोटा किया गया (संख्या, दशमलव स्थान) (var numPowerConverter = Math.pow(10, दशमलव स्थान); वापसी ~~(num * numPowerConverter)/numPowerConverter; )

उपयोग:

var randInt = 35.874993; काट दिया गया(randInt,3); >35.874

निकटतम संख्या तक पूर्णांकित करें

अमल करना जावास्क्रिप्ट को निकटतम पूर्णांक तक पूर्णांकित करना, Math.round() का उपयोग किया जाता है:

गणित.राउंड(4.3) > 4 गणित.राउंड(4.5) >5

ध्यान दें कि " आधा मूल्य", जैसे कि .5, को पूर्णांकित किया जाता है।

निकटतम पूर्ण संख्या तक पूर्णांकित करें

यदि आप पूर्णांक बनाना चाहते हैं, तो Math.floor() विधि का उपयोग करें:

मठ.तल(42.23); >42 मठ.तल(36.93); >36

पूर्णांकन में ऋणात्मक सहित सभी संख्याओं के लिए एक दिशा होती है। इसकी कल्पना एक गगनचुंबी इमारत के रूप में की जा सकती है जिसमें नींव स्तर से नीचे सहित अनगिनत मंजिलें हैं ( ऋणात्मक संख्याओं का प्रतिनिधित्व करना). यदि आप बेसमेंट मंजिल 2 और 3 के बीच लिफ्ट में हैं ( जो -2.5 के मान से मेल खाता है), Math.floor आपको मंजिल -3 पर ले जाएगा:

मठ.तल(-2.5); > -3

यदि आपको इससे बचने की आवश्यकता है, तो Math.trunc() का उपयोग करके जावास्क्रिप्ट गणित राउंडिंग का उपयोग करें, जो सभी आधुनिक ब्राउज़रों में समर्थित है (छोड़कर) आईई/एज):

गणित.ट्रंक(-41.43); >-41

एमडीएन भी प्रदान करता है पुराने ब्राउज़रों और IE/Edge में Math.trunc के लिए समर्थन प्रदान करने के लिए तीन-पंक्ति पॉलीफ़िल.

निकटतम पूर्ण संख्या तक पूर्णांकित करें

यदि आप दशमलव संख्याओं को पूर्णांकित करना चाहते हैं, तो Math.ceil का उपयोग करें। इस विधि को एक अनंत एलिवेटर के रूप में भी सोचा जा सकता है: Math.ceil हमेशा आपको "ऊपर" ले जाता है, भले ही संख्या नकारात्मक हो या सकारात्मक:

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

फ़ंक्शन का उपयोग करने के लिए, पूर्णांकित की जाने वाली संख्या और उसके कॉल में गुणक शामिल करें:

var प्रारंभिक संख्या = 11; वर एकाधिक = 10; राउंडटूमल्टीपल (प्रारंभिक संख्या, एकाधिक); >10;

केवल ऊपर या नीचे मानों को गोल करने के लिए, फ़ंक्शन में राउंड को छत या फर्श से बदलें।

रेंज बाइंडिंग

कभी-कभी आपको x के लिए एक मान प्राप्त करने की आवश्यकता होती है जो एक निश्चित सीमा के भीतर होना चाहिए। उदाहरण के लिए, हमें 1 से 100 तक मान की आवश्यकता है, लेकिन हमें मान 123 मिलता है। इसे ठीक करने के लिए आप min() ( सबसे छोटी संख्या लौटाता है) और अधिकतम ( अधिकतम अनुमत संख्या लौटाता है).

उपयोग:

वर लोबाउंड = 1; वर हाईबाउंड = 100; var numInput = 123; var क्लैंप्ड = Math.max(lowBound, Math.min(numInput,highBound)); कंसोल.लॉग(क्लैम्प्ड); > 100;

आप संख्या वर्ग का एक फ़ंक्शन या एक्सटेंशन बना सकते हैं।

इस लेख में हम संख्याओं, गणितीय संचालकों, किसी संख्या को एक स्ट्रिंग में बदलने के तरीकों और इसके विपरीत, साथ ही कई अन्य महत्वपूर्ण बिंदुओं पर विस्तार से नज़र डालेंगे।

परिमित फ़ंक्शन है

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(value)) ( if (isEven(value)) ( console.log("Number " + value.toString() + " -even"); ) )

जावास्क्रिप्ट में अभाज्य संख्याएँ

आइए एक उदाहरण देखें जिसमें से हम प्राप्त करते हैं जावास्क्रिप्ट का उपयोग करना 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 <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

जावास्क्रिप्ट में किसी संख्या को पूर्णांकित करना

जावास्क्रिप्ट में किसी भिन्न को पूर्ण संख्या में पूर्णांकित करने के विभिन्न तरीके हैं।

1. इसके लिए विशेष रूप से डिज़ाइन की गई Math.floor, Math.ceil और Math.round विधियों का उपयोग करना। Math.floor विधि एक भिन्न को निकटतम पूर्णांक तक पूर्णांकित करती है, अर्थात। बस भिन्नात्मक भाग को त्याग देता है। Math.ceil किसी भिन्न को निकटतम पूर्ण संख्या तक पूर्णांकित करता है। Math.round भिन्नात्मक भाग के मान के आधार पर किसी संख्या को ऊपर या नीचे पूर्णांकित करता है। यदि भिन्नात्मक भाग 0.5 से अधिक या उसके बराबर है, तो ऊपर, अन्यथा मोड़ नीचे है।

कंसोल.लॉग(मैथ.फ्लोर(7.9)); //7 कंसोल.लॉग(मैथ.सील(7.2)); //8 कंसोल.लॉग(मैथ.राउंड(7.5)); //8

2. टूफिक्स्ड (सटीक) विधि का उपयोग करना। यह विधि किसी संख्या के भिन्नात्मक भाग को एक निर्दिष्ट परिशुद्धता तक पूर्णांकित करती है। पूर्णांकन परिणाम एक स्ट्रिंग के रूप में लौटाया जाता है।

कंसोल.लॉग(7.987.टूफिक्स्ड(2)); //"7.99"

यदि संख्या की निर्दिष्ट परिशुद्धता बनाने के लिए पर्याप्त दशमलव स्थान नहीं हैं, तो इसे शून्य से भर दिया जाता है।

कंसोल.लॉग(7.987.टूफिक्स्ड(5)); //"7.98700"

3. सटीकता (सटीकता) विधि का उपयोग करना। यह विधि एक निर्दिष्ट परिशुद्धता के साथ एक संख्या का प्रतिनिधित्व करती है। साथ ही, वह न केवल भिन्नात्मक, बल्कि संख्या के पूरे भाग को भी पूर्णांकित कर सकता है। परिणाम के आधार पर, यह विधि परिणामी संख्या को एक निश्चित बिंदु के साथ या घातांकीय रूप में प्रस्तुत कर सकती है।

कंसोल.लॉग((1001).toPrecision(2)); //"1.0e+3" कंसोल.लॉग((1001).toPrecision(5)); //"1001.0" कंसोल.लॉग((12.4).toPrecision(1)); //"1e+1" कंसोल.लॉग((12.4).toPrecision(2)); //"12" कंसोल.लॉग((12.4).toPrecision(3)); //"12.4" कंसोल.लॉग((12.4).toPrecision(5)); //"12.400"

4. लॉजिकल ऑपरेटर्स NOT या OR का उपयोग करना।

//डबल लॉजिकल नेगेशन कंसोल.लॉग के माध्यम से(~~7.9); //7 // तार्किक या शून्य के साथ उपयोग करके: कंसोल.लॉग(7.9^0); //7

किसी संख्या का पूर्णांक और भिन्नात्मक भाग

आप Math.floor() और parseInt() विधियों का उपयोग करके किसी संख्या का पूर्णांक भाग प्राप्त कर सकते हैं:

कंसोल.लॉग(मैथ.फ्लोर(7.21)); // 7 कंसोल.लॉग(parseInt(7.21)); // 7

आप प्रतिशत (%) ऑपरेटर का उपयोग करके किसी संख्या का भिन्नात्मक भाग प्राप्त कर सकते हैं। यह ऑपरेटर पहली संख्या को दूसरी संख्या से विभाजित करने पर प्राप्त शेषफल लौटाता है। इस स्थिति में, आपको दूसरे नंबर के रूप में 1 का उपयोग करना होगा।

कंसोल.लॉग(7.21%1); // 0.20999999999999996 // 2 दशमलव स्थानों तक सटीक कंसोल.लॉग((7.21%1).toFixed(2)); // "0.21"

इसके अलावा, भिन्नात्मक भाग को गणनाओं का उपयोग करके भी प्राप्त किया जा सकता है:

वर संख्या = 7.21; var भिन्न संख्या = संख्या - गणित.तल(गणित.abs(संख्या)); कंसोल.लॉग(अंश संख्या); // 0.209999999999999996

क्या संख्या पूर्णांक से विभाज्य है?

आप प्रतिशत ऑपरेटर का उपयोग करके यह निर्धारित कर सकते हैं कि कोई संख्या पूर्णांक से विभाज्य है या नहीं:

वर संख्या = 9; // यदि संख्या को 3 से विभाजित करने पर शेषफल 0 आता है, तो हाँ, अन्यथा नहीं, यदि (संख्या%3==0) ( कंसोल.लॉग ("संख्या " + संख्या + " 3 से विभाज्य है"); ) अन्यथा ( कंसोल. लॉग ("संख्या" + संख्या + "3 से विभाज्य नहीं है");

संख्याओं का स्वरूपण

जावास्क्रिप्ट में, toLocaleString() विधि आपको क्षेत्रीय मानकों (ऑपरेटिंग सिस्टम की भाषा सेटिंग्स) के अनुसार किसी संख्या के आउटपुट को प्रारूपित करने की अनुमति देती है।

उदाहरण के लिए, आइए किसी संख्या को क्षेत्रीय मानकों के अनुसार प्रारूपित करें जो सिस्टम में डिफ़ॉल्ट रूप से स्थापित हैं:

वार संख्या = 345.46; कंसोल.लॉग(नंबर.टूलोकेलस्ट्रिंग()); //"345.46"

उदाहरण के लिए, आइए रूस के क्षेत्रीय मानकों (आरयू) के अनुसार संख्या को प्रारूपित करें:

कंसोल.लॉग((108.1).toLocaleString("ru-RU")); //"108.1"

इस पद्धति का उपयोग किसी संख्या को मुद्रा के रूप में प्रारूपित करने के लिए भी किया जा सकता है:

कंसोल.लॉग((2540.125).toLocaleString("ru-RU",(शैली:"मुद्रा", मुद्रा:"RUB"))); //"2,540.13 ₽" कंसोल.लॉग((89.3).toLocaleString("ru-RU",(शैली:"मुद्रा", मुद्रा:"USD"))); //"$89.30" कंसोल.लॉग((2301.99).toLocaleString("ru-RU",(शैली:"मुद्रा", मुद्रा:"EUR"))); //"€2,301.99"

किसी संख्या को प्रतिशत के रूप में प्रदर्शित करना:

कंसोल.लॉग((0.45).toLocaleString("ru-RU",(शैली:"प्रतिशत"))); //"45%"

किसी संख्या को अंकों में तोड़ें (समूह संपत्ति का उपयोग करें):

कंसोल.लॉग((125452.32).toLocaleString("ru-RU",(useGrouping:true))); //"125,452.32"

दशमलव बिंदु के बाद अंकों की एक निश्चित संख्या (2) वाली संख्या प्रिंट करें:

कंसोल.लॉग((1240.4564).toLocaleString("ru-RU",(न्यूनतमफ्रैक्शनडिजिट्स:2, मैक्सिममफ्रैक्शनडिजिट्स:2))); //"1,240.46"

संख्याओं की तुलना

जावास्क्रिप्ट में संख्याओं की तुलना करने के लिए निम्नलिखित ऑपरेटरों का उपयोग किया जाता है: == (बराबर), != (बराबर नहीं), > (से अधिक),< (меньше), >= (इससे अधिक या इसके बराबर),<= (меньше или равно).

उदाहरण के लिए, आइए दो संख्याओं की तुलना करें:

कंसोल.लॉग(2>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