javascript - सरण - व्हाट डू यू मीन बि जावास्क्रिप्ट




मैं जावास्क्रिप्ट में एक फ्लोट नंबर को एक पूर्ण संख्या में कैसे परिवर्तित करूं? (9)

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


बिटवाई या ऑपरेटर

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

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

परिणाम

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

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

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

  • Math.floor(val)
  • val | 0 val | 0 बिटवाई या
  • ~~val bitwise नहीं
  • parseInt(val)

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

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

ध्यान दें

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

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

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

var intValue = parseInt(floatValue, 10);

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

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/ पर https://jsfiddle.net/au51uj3r/


छंटनी के लिए:

var intvalue = Math.floor(value);

दौर के लिए:

var intvalue = Math.round(value);


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

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

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


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

intval = floatval - floatval%1;

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

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

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

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

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 = 5.5

Math.floor(value) //  5
Math.ceil(value)  //  6
Math.round(value) //  6
Math.trunc(value) //  5
parseInt(value)   //  5
~~value           //  5
value | 0         //  5
value >> 0        //  5
value >>> 0       //  5
value - value % 1 //  5
नकारात्मक
value = -5.5

Math.floor(value) // -6
Math.ceil(value)  // -5
Math.round(value) // -5
Math.trunc(value) // -5
parseInt(value)   // -5
value | 0         // -5
~~value           // -5
value >> 0        // -5
value >>> 0       // 4294967291
value - value % 1 // -5
सकारात्मक - बड़ी संख्याएं
value = Number.MAX_SAFE_INTEGER/10 // 900719925474099.1

Math.floor(value) //  900719925474099
Math.ceil(value)  //  900719925474100
Math.round(value) //  900719925474099
Math.trunc(value) //  900719925474099
parseInt(value)   //  900719925474099
value | 0         //  858993459
~~value           //  858993459
value >> 0        //  858993459
value >>> 0       //  858993459
value - value % 1 //  900719925474099
नकारात्मक - बड़ी संख्याएं
value = Number.MAX_SAFE_INTEGER/10 * -1 // -900719925474099.1

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





syntax