मैं एक फ्लोट संख्या को जावास्क्रिप्ट में पूरी संख्या में कैसे बदलूं?

Question

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

Comments

यदि आप इसे नहीं जानते हैं, तो जावास्क्रिप्ट में सभी नंबर फ़्लोट हैं। विनिर्देशन से:

— कुछ

4.3.20 संख्या प्रकार: प्रकार संख्या संख्याओं का प्रतिनिधित्व करने वाले मूल्यों का एक समूह है। ECMAScript में, मानों का सेट विशेष "Not-a-Number" (NaN) मान, सकारात्मक अनन्तता और नकारात्मक अनंत सहित दोहराव 64-बिट प्रारूप IEEE 754 मूल्यों का प्रतिनिधित्व करता है।

— कुछ

हां, जावास्क्रिप्ट का एक अलग "पूर्णांक" प्रकार नहीं है, लेकिन इस रूपांतरण को करने के लिए अभी भी असामान्य नहीं है। उदाहरण के लिए, मेरे एप्लिकेशन में उपयोगकर्ता एक संख्या में टाइप करते हैं (संभवतः सेंट सहित)। मुझे सेंट को छोटा करना और w / अल्पविराम प्रदर्शित करना था। चरण 1 को इंट में बदलना था।

— mcherm

उपयोगी भी: सभी तरीकों की गति तुलना jsperf.com/math-floor-vs-math-round-vs-parseint/33

— c ..

@ कर्ल: यदि मैं किसी क्षेत्र में इनपुट स्वीकार कर रहा हूं, तो मैं यह नियंत्रित करने में सक्षम हो सकता हूं कि मैं कौन से वर्ण स्वीकार करता हूं, लेकिन मैं जावास्क्रिप्ट में सभी प्रकार के प्रसंस्करण कर सकता हूं, न कि केवल उपयोगकर्ता इनपुट को स्वीकार करने में। फिर भी मैं इसे समर्थन पेस्ट जैसी चीजों के लिए चाह सकता हूं।

— mcherm

Answer 1

var intvalue = Math.floor( floatvalue );
var intvalue = Math.ceil( floatvalue ); 
var intvalue = Math.round( floatvalue );

// `Math.trunc` was added in ECMAScript 6
var intvalue = Math.trunc( floatvalue );

गणित वस्तु संदर्भ

---

उदाहरण

सकारात्मक

// value=x        //  x=5          5<x<5.5      5.5<=x<6  

Math.floor(value) //  5            5            5
Math.ceil(value)  //  5            6            6
Math.round(value) //  5            5            6
Math.trunc(value) //  5            5            5
parseInt(value)   //  5            5            5
~~value           //  5            5            5
value | 0         //  5            5            5
value >> 0        //  5            5            5
value >>> 0       //  5            5            5
value - value % 1 //  5            5            5

नकारात्मक

// value=x        // x=-5         -5>x>=-5.5   -5.5>x>-6

Math.floor(value) // -5           -6           -6
Math.ceil(value)  // -5           -5           -5
Math.round(value) // -5           -5           -6
Math.trunc(value) // -5           -5           -5
parseInt(value)   // -5           -5           -5
value | 0         // -5           -5           -5
~~value           // -5           -5           -5
value >> 0        // -5           -5           -5
value >>> 0       // 4294967291   4294967291   4294967291
value - value % 1 // -5           -5           -5

पॉजिटिव - बड़ी संख्या

// x = Number.MAX_SAFE_INTEGER/10 // =900719925474099.1

// value=x            x=900719925474099    x=900719925474099.4  x=900719925474099.5

Math.floor(value) //  900719925474099      900719925474099      900719925474099
Math.ceil(value)  //  900719925474099      900719925474100      900719925474100
Math.round(value) //  900719925474099      900719925474099      900719925474100
Math.trunc(value) //  900719925474099      900719925474099      900719925474099
parseInt(value)   //  900719925474099      900719925474099      900719925474099
value | 0         //  858993459            858993459            858993459
~~value           //  858993459            858993459            858993459
value >> 0        //  858993459            858993459            858993459
value >>> 0       //  858993459            858993459            858993459
value - value % 1 //  900719925474099      900719925474099      900719925474099

ऋणात्मक - बड़ी संख्या

// x = Number.MAX_SAFE_INTEGER/10 * -1 // -900719925474099.1

// value = x      // x=-900719925474099   x=-900719925474099.5 x=-900719925474099.6

Math.floor(value) // -900719925474099     -900719925474100     -900719925474100
Math.ceil(value)  // -900719925474099     -900719925474099     -900719925474099
Math.round(value) // -900719925474099     -900719925474099     -900719925474100
Math.trunc(value) // -900719925474099     -900719925474099     -900719925474099
parseInt(value)   // -900719925474099     -900719925474099     -900719925474099
value | 0         // -858993459           -858993459           -858993459
~~value           // -858993459           -858993459           -858993459
value >> 0        // -858993459           -858993459           -858993459
value >>> 0       //  3435973837           3435973837           3435973837
value - value % 1 // -900719925474099     -900719925474099     -900719925474099

Comments

जैसा कि एक अन्य उत्तर में उल्लेख किया गया है, एक नकारात्मक-सुरक्षित ट्रंकट का उपयोग करके किया जा सकता है var intValue = ~~floatValue;। यदि नोटेशन आपके स्वाद के लिए बहुत अस्पष्ट है, तो बस इसे किसी फ़ंक्शन में छिपाएं function toInt(value) { return ~~value; }:। (यह स्ट्रिंग्स को पूर्णांकों में भी परिवर्तित करता है, अगर आप ऐसा करना चाहते हैं।)

— कीन

यदि यह उत्तर उदाहरण इनपुट / आउटपुट था, तो अपवोट करेगा।

— जे। रैंडम कोडर

टिप्पणी के बारे में ~~ 32 बिट हस्ताक्षरित पूर्णांकों के लिए मूल्य को सीमित करता है, जबकि Math.floor / Ceil / Round 53-बिट (Number.MAX_SAFE_INTEGER 9007199254740991) को संभाल सकता है। इसका उल्लेख नीचे दिए गए उत्तर में किया गया है, लेकिन इन टिप्पणियों को पढ़ने वालों के लिए यहां दोहराना लायक है।

— जॉन

नीचे से कई स्थानों पर पढ़ें: Math.trunc(val);टिप्पणी करें क्योंकि यह स्वीकृत उत्तर है

— ओल्ड बैडमैन ग्रे

मानों के लिए सटीक सटीकता के साथ काम नहीं करता है2.3 - 2.3 % 1

— लापीस

Answer 2

बिटवाइज़ OR ऑपरेटर

एक बिटवाइज़ या ऑपरेटर का उपयोग फ़्लोटिंग पॉइंट आकृतियों को छोटा करने के लिए किया जा सकता है और यह सकारात्मक के साथ-साथ नकारात्मक के लिए भी काम करता है:

function float2int (value) {
    return value | 0;
}

परिणाम

float2int(3.1) == 3
float2int(-3.1) == -3
float2int(3.9) == 3
float2int(-3.9) == -3

प्रदर्शन की तुलना?

मैंने एक JSPerf परीक्षण बनाया है, जो प्रदर्शन के बीच तुलना करता है:

• Math.floor(val)
• val | 0 ^{बिटवार या}
• ~~val ^{बिट वाइज नहीं}
• parseInt(val)

यह केवल सकारात्मक संख्याओं के साथ काम करता है। इस मामले में आप Math.floorफ़ंक्शन के रूप में बिटवाइज़ संचालन का उपयोग करने के लिए सुरक्षित हैं ।

लेकिन अगर आपको अपने कोड को सकारात्मक और नकारात्मक के साथ काम करने की आवश्यकता है , तो एक बिटवाइज़ ऑपरेशन सबसे तेज़ है (या पसंदीदा होने के नाते)। यह अन्य JSPerf परीक्षण उसी की तुलना करता है जहां यह बहुत स्पष्ट है कि अतिरिक्त हस्ताक्षर की वजह से गणित अब चार में से सबसे धीमा है।

ध्यान दें

जैसा कि टिप्पणियों में कहा गया है, BITWISE ऑपरेटरों ने हस्ताक्षर किए गए 32 बिट पूर्णांक पर काम किया है, इसलिए बड़ी संख्या में रूपांतरण किया जाएगा, उदाहरण:

1234567890  | 0 => 1234567890
12345678901 | 0 => -539222987

Comments

@ फैबियोपोलोनी: हाँ सुपर सिंपल और लगता है कि बिटवाइज़ ऑपरेटर्स सबसे तेज़ हैं। विशेष रूप से OR ऑपरेटर हमेशा सबसे तेजी से अक्सर NOT और Math ऑपरेशंस से मेल खाता है, हालांकि जब आप नेगेटिव नंबर्स को सपोर्ट करना चाहते हैं तो Math ऑपरेशंस सबसे धीमे होते हैं, क्योंकि यह नंबर साइन का एक अतिरिक्त चेक जोड़ता है।

— रॉबर्ट कोरिटनिक

@thefourtheye: अहस्ताक्षरित सही बदलाव को छोड़कर सभी बिटवाइज़ ऑपरेशन, हस्ताक्षरित 32-बिट पूर्णांक पर काम करते हैं। इसलिए फ़्लोटिंग पॉइंट वैल्यूज़ पर बिटवाइज़ ऑपरेशंस का उपयोग करके उन्हें दशमलव बिंदु के बाद अंकों से अलग करने वाले पूर्णांक में बदल दिया जाएगा।

— रॉबर्ट कोरिटनिक

यदि आपको केवल सकारात्मक संख्याओं के लिए इसकी आवश्यकता है, Math.floor()तो तेज है (कम से कम Google Chrome पर आपके पहले JSPerf परीक्षण के संस्करण के अनुसार, संस्करण 30.0.1599.101), अधिक मजबूत (क्योंकि यह निर्भर नहीं करता है कि संख्याओं का प्रतिनिधित्व बिट्स में कैसे किया जाता है,) जो बदल सकता है और संभवतः इस बिटवाइज़ समाधान को तोड़ सकता है), और सबसे महत्वपूर्ण बात, अधिक स्पष्ट।

— ma11hew28

ध्यान दें कि बिटवाइज़ ऑपरेटर 32 बिट नंबरों पर काम करते हैं। वे 32 बिट में फिट होने के लिए बहुत बड़ी संख्या के लिए काम नहीं करेंगे।

— कैट

~~बेहतर है क्योंकि यह एक अपर ऑपरेटर है। 4.2|0+4बराबरी 4लेकिन ~~4.2+4बराबर8

— Janus Troelsen

Answer 3

नोट: आप Math.floor()ट्रंक के लिए प्रतिस्थापन के रूप में उपयोग नहीं कर सकते , क्योंकि Math.floor(-3.1) = -4और नहीं -3!!

ट्रंकट के लिए एक सही प्रतिस्थापन होगा:

function truncate(value)
{
    if (value < 0) {
        return Math.ceil(value);
    }

    return Math.floor(value);
}

Comments

यह नकारात्मक संख्याओं के लिए वांछित व्यवहार पर निर्भर करता है। अधिक नकारात्मक मान (-3.5 -> -4) के लिए मैप करने के लिए कुछ लोगों को नकारात्मक संख्याओं की आवश्यकता होती है और कुछ को छोटे पूर्णांक (-3.5 -> -3) के मानचित्र की आवश्यकता होती है। पूर्व को आम तौर पर "मंजिल" कहा जाता है। शब्द "ट्रंकट" अक्सर व्यवहार का वर्णन करने के लिए उपयोग किया जाता है। मेरे मामले में, मैं केवल इसे नकारात्मक संख्याओं को खिलाने जा रहा था। लेकिन यह टिप्पणी उन लोगों के लिए एक उपयोगी चेतावनी है जो नकारात्मक संख्या व्यवहार के बारे में परवाह करते हैं।

— मचर्म

@ शुक्राणु: तब वे "ट्रंकट" शब्द को ठीक से समझ नहीं पाते हैं। Truncate ठीक वैसे ही करता है जैसे इसका नाम निकलता है: यह अंकों को काटता है। यह कभी भी (सामान्य अर्थ में) फर्श या छत के बराबर नहीं होता है। en.wikipedia.org/wiki/Truncation

— थानाटोस

Math.trunc(value)ECMAScript 6

— 4esn0k

floorदौर की ओर -infinity, truncateशून्य की ओर दौर। ( ceilचक्कर + अनंत की ओर)।

— पीटर कॉर्ड्स

Answer 4

डबल बिटवाइज़ नहीं ऑपरेटर को फ़्लोटक फ़्लोट करने के लिए उपयोग किया जा सकता है। अन्य कार्यों आप का उल्लेख उपलब्ध के माध्यम से कर रहे हैं Math.floor, Math.ceilऔर Math.round।

> ~~2.5
2
> ~~(-1.4)
-1

अधिक जानकारी जेम्स Padolsey के सौजन्य से।

Comments

यह शायद उत्पादन कोड के लिए एक बुरी बात है (क्योंकि यह अस्पष्ट है), लेकिन यह वही था जो मुझे जेएस में अपने <canvas>फ़ॉन्ट रेंडरिंग इंजन कोडिंग के लिए आवश्यक था । धन्यवाद!

— Kragen जेवियर सीटकेर

यह भी n के साथ पूरा किया जा सकता है | 0.

— जे डौसल

ध्यान दें कि या तो विधि (~~ n या n। 0) केवल 2 ^ 31-1, या 2147483647 नंबर पर काम करती है। 2147483648 या उच्चतर गलत परिणाम देगा; उदाहरण के लिए, 2147483647 | 0 रिटर्न -2147483648, और 4294967290; 0 रिटर्न -1, जो लगभग निश्चित रूप से नहीं है जो आप चाहते हैं।

— ईडी बेयेट्स

Answer 5

छंटनी के लिए:

var intvalue = Math.floor(value);

दौर के लिए:

var intvalue = Math.round(value);

Comments

Math.floor नकारात्मक मूल्यों को काट नहीं करता है। ऊपर उत्तर देखें। अन्यथा अच्छा जवाब।

— ऑलिगॉफ्रेन

यदि आप प्रदर्शन में रुचि रखते हैं, तो मैंने एक छोटा परीक्षण मामला यहां रखा है: jsperf.com/dsafdgdfsaf/2 (var | 0 win here)।

— प्रतीकात्मक

Answer 6

आप बिना किसी गोलाई के parseInt विधि का उपयोग कर सकते हैं । 0x (हेक्स) और 0 (ऑक्टल) उपसर्ग विकल्पों के कारण उपयोगकर्ता इनपुट से सावधान रहें।

var intValue = parseInt(floatValue, 10);

Comments

यह वास्तव में तब सहायक होता है, जब आप केवल दशमलव के पूर्णांक भाग को, ऊपर या नीचे की ओर, जो कि। चारों ओर, बिना।

— जुदा गेब्रियल हिमंगो

... यहां तक ​​कि जब बस छंटाई यह सबसे धीमी विधि है। jsperf.com/float-to-int-conversion-comparison

— रॉबर्ट कोरिटनिक

आप किस आधार पर अपेक्षा कर रहे हैं, यह निर्दिष्ट करने के लिए हमेशा 2 मान पास करें। तो, parseInt (फ्लोटवैल्यू, 10) को हमेशा आधार पाने के लिए। 10.

— टिम टिसडल

हालांकि यह पुराना है, यह प्रश्न एक ऐसा लगता है जो अक्सर पूछा जाता है, इसलिए मैं इसे यहां एक चेतावनी के रूप में रखूंगा। यदि मूल्य को उसके आकार के कारण "ई" अंकन का उपयोग करके दर्शाया जाएगा, तो यह केवल एक अंक में परिणाम देगा, न कि जो अपेक्षित है। उदाहरण के लिए, parseInt(1000000000000000000000, 10);1 में परिणाम, न कि 1 000 000 000 000 000 000 000। वैसे भी, सवाल स्पष्ट रूप से " एक स्ट्रिंग और पार्सिंग में परिवर्तित नहीं करना चाहता था ", हालांकि यह अपेक्षाकृत मामूली है ...;)

— Qantas 94 हैवी

@ Qantas94Heavy इस व्यवहार का कारण है, क्योंकि इसके पहले पैरामीटर के रूप में parseInt()एक स्ट्रिंग नहीं एक संख्या की उम्मीद है । जब आप इस पूर्णांक को पास करते हैं, तो इसे परिवर्तित किया जाता है 1e21और फिर parseIntस्ट्रिंग को पार्स किया जाता है 1e21, जिसके परिणामस्वरूप 1।

— ओलाफ डायटशे

Answer 7

बिट शिफ्ट 0 से जो कि विभाजन से 1 के बराबर है

// >> or >>>
2.0 >> 0; // 2
2.0 >>> 0; // 2

Comments

छोटा नोट: >> 0केवल पूर्णांक < 2 ^ 31-1 , और >>> 0पूर्णांक < 2 ^ 32-1 के लिए काम करता है । यह बड़े मूल्यों के लिए 0 लौटाता है

— रोमानी ब्रुनेट

@RomualdBrunet, हां, जावास्क्रिप्ट 32 बिट नंबरों पर परिचालन के रूप में स्पष्ट रूप से सभी बिटवाइज़ संचालन को परिभाषित करता है। यह ऐनक में है।

— एलेक्सिस विल्के

यह कार्य करता है क्योंकि जावास्क्रिप्ट केवल 32 बिट (हस्ताक्षरित) पूर्णांक के साथ बिटवाइज़ ऑपरेशन करता है जैसा कि ऊपर दिए गए उत्तर में दिया गया है। तो कोई भी बिट-ऑपरेशन जो कुछ भी नहीं लगता है (जैसे 0 के लिए एक बदलाव, या 0 के साथ, और 1 के साथ, डबल नहीं) अभी भी मूल्य को 32 बिट इंट में बदलने के लिए जावास्क्रिप्ट दुभाषिया की आवश्यकता है।

— फ्रैंककर्मॉन

Answer 8

आपके मामले में, जब आप अंत में एक स्ट्रिंग चाहते हैं (कॉमा डालने के लिए), तो आप केवल Number.toFixed()फ़ंक्शन का उपयोग कर सकते हैं , हालांकि, यह राउंडिंग प्रदर्शन करेगा।

Answer 9

यहाँ कई सुझाव हैं। बिटवाइड या दूर से सबसे सरल प्रतीत होता है। यहां एक और संक्षिप्त समाधान है जो मोड्यूलो ऑपरेटर का उपयोग करके नकारात्मक संख्याओं के साथ काम करता है। यह शायद बिटवाइज़ की तुलना में समझना आसान है:

intval = floatval - floatval%1;

यह विधि उच्च मान संख्याओं के साथ भी काम करती है जहाँ न तो '0' और न ही '~~' और न ही '0' सही ढंग से काम करते हैं:

> n=4294967295;
> n|0
-1
> ~~n
-1
> n>>0
-1
> n-n%1
4294967295

Comments

यदि आप किसी अन्य उत्तर का संदर्भ देते हैं, तो कृपया या तो इसका संदर्भ जोड़ें या इसके विचार को शीघ्र ही स्केच करें।

— बर्टल

Answer 10

छंटनी करने के लिए :

// Math.trunc() is part of the ES6 spec
Math.trunc( 1.5 );  // returns 1
Math.trunc( -1.5 ); // returns -1
// Math.floor( -1.5 ) would return -2, which is probably not what you wanted

गोल करने के लिए :

Math.round( 1.5 );  // 2
Math.round( 1.49 ); // 1
Math.round( -1.6 ); // -2
Math.round( -1.3 ); // -1

Answer 11

एक और संभव तरीका - XOR ऑपरेशन का उपयोग करें:

console.log(12.3 ^ 0); // 12
console.log("12.3" ^ 0); // 12
console.log(1.2 + 1.3 ^ 0); // 2
console.log(1.2 + 1.3 * 2 ^ 0); // 3
console.log(-1.2 ^ 0); // -1
console.log(-1.2 + 1 ^ 0); // 0
console.log(-1.2 - 1.3 ^ 0); // -2

बिटवाइज़ ऑपरेशंस की प्राथमिकता गणित के संचालन की प्राथमिकता कम है, यह उपयोगी है। Https://jsfiddle.net/au51uj3r/ पर कोशिश करें

Answer 12

यदि Mathजावास्क्रिप्ट में देशी वस्तु को देखें, तो आपको संख्याओं और मानों आदि पर काम करने के लिए कार्यों का पूरा गुच्छा मिलता है ...

मूल रूप से आप जो करना चाहते हैं वह जावास्क्रिप्ट में काफी सरल और मूल है ...

कल्पना कीजिए कि आपके पास नीचे की संख्या है:

const myValue = 56.4534931;

और अब यदि आप इसे निकटतम संख्या में गोल करना चाहते हैं, तो बस करें:

const rounded = Math.floor(myValue);

और आपको मिलता है:

56

यदि आप इसे निकटतम संख्या तक गोल करना चाहते हैं, तो बस करें:

const roundedUp = Math.ceil(myValue);

और आपको मिलता है:

57

इसके अलावा Math.round, यह उच्च या निम्न संख्या के लिए गोल होता है, जिस पर निर्भर करता है कि कोई फ़्लोट संख्या के करीब है।

इसके अलावा आप ~~फ्लोट नंबर के पीछे का उपयोग कर सकते हैं , जो फ्लोट को पूरी संख्या में बदल देगा।

आप इसका उपयोग कर सकते हैं ~~myValue...

Comments

प्लास सावधान रहें ~~क्योंकि यदि संख्या इंट 32 सीमा से बड़ी है, तो यह मूल्य को इंट 32 सीमा मान में बदल देगा।

— मचाडो

Answer 13

//Convert a float to integer

Math.floor(5.95)
//5

Math.ceil(5.95)
//6

Math.round(5.4)
//5

Math.round(5.5)
//6

Math.trunc(5.5)
//5

//Quick Ways
console.log(5.95| 0)
console.log(~~5.95) 
console.log(5.95 >> 0)
//5

Answer 14

मैं सिर्फ यह बताना चाहता हूं कि आप जिस तरह से गोल करना चाहते हैं, वैसा नहीं है और न ही ट्रंक। एक पैसे से बंद होने की संभावना बहुत कम है, क्योंकि 4.999452 * 100 गोल आपको 5, एक अधिक प्रतिनिधि जवाब देगा।

और इसके शीर्ष पर, बैंकर की गोलाई के बारे में मत भूलना , जो कि थोड़ा सा सकारात्मक पूर्वाग्रह का मुकाबला करने का एक तरीका है जो सीधे गोलाई देता है - आपके वित्तीय आवेदन को इसकी आवश्यकता हो सकती है।

गौसियन / बैंकर की जावास्क्रिप्ट में गोलाई

Answer 15

यदि आप angularjs का उपयोग कर रहे हैं तो सरल समाधान निम्नानुसार है HTML टेम्पलेट बाइंडिंग में

{{val | number:0}}

यह घाटी को पूर्णांक में बदल देगा

इस लिंक docs.angularjs.org/api/ng/filter/number पर जाएं