JavaScript
परिवर्तनीय जबरदस्ती / रूपांतरण

टिप्पणियों

<span id="freezing-point">0</span>

var el = document.getElementById('freezing-point');
var freezingPoint = el.textContent || el.innerText;
var moreHeat = 100;
var boilingPoint = freezingPoint + moreHeat;

var el = document.getElementById('freezing-point');
var freezingPoint = Number(el.textContent || el.innerText);
var boilingPoint = freezingPoint + moreHeat;

एक स्ट्रिंग को एक संख्या में परिवर्तित करना

Number('0') === 0

Number('0') स्ट्रिंग ( '0' ) को संख्या ( 0 ) में परिवर्तित करेगी।

एक छोटा, लेकिन कम स्पष्ट, रूप:

+'0' === 0

Unary + ऑपरेटर संख्याओं के लिए कुछ नहीं करता है, लेकिन किसी भी चीज़ को संख्या में परिवर्तित करता है।
दिलचस्प है, +(-12) === -12 ।

parseInt('0', 10) === 0

parseInt('0', 10) स्ट्रिंग ( '0' ) को संख्या ( 0 ) में बदल देगा, दूसरा तर्क मत भूलना, जो कि मूलांक है। यदि नहीं दिया गया है, तो parseInt स्ट्रिंग को गलत संख्या में बदल सकता है।

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

String(0) === '0'

String(0) संख्या ( 0 ) को एक स्ट्रिंग ( '0' ) में परिवर्तित करेगी।

एक छोटा, लेकिन कम स्पष्ट, रूप:

'' + 0 === '0'

दोहरा नकार (!! x)

दोहरा-नकार !! एक अलग जावास्क्रिप्ट संचालक नहीं है और न ही एक विशेष वाक्यविन्यास, बल्कि केवल दो नकारात्‍मकों का एक क्रम है। यह अपने उचित करने के लिए किसी भी प्रकार का मान परिवर्तित करने के लिए प्रयोग किया जाता है true या false है कि क्या यह truthy या falsy है पर निर्भर करता है बूलियन मान।

!!1            // true
!!0            // false
!!undefined    // false
!!{}           // true
!![]           // true

पहले निषेध के लिए किसी भी मूल्य धर्मान्तरित false अगर यह truthy है और करने के लिए true है, तो falsy है। दूसरा नकार तब सामान्य बूलियन मान पर कार्य करता है। एक साथ वे के लिए किसी भी truthy मूल्य कन्वर्ट true और के लिए किसी भी falsy मूल्य false ।

हालांकि, कई पेशेवर इस तरह के वाक्यविन्यास अस्वीकार्य का उपयोग करने के अभ्यास पर विचार करते हैं और विकल्पों को पढ़ने के लिए सरल सलाह देते हैं, भले ही वे लिखने के लिए हों:

x !== 0        // instead of !!x in case x is a number
x != null      // instead of !!x in case x is an object, a string, or an undefined

निम्न कारणों से !!x का प्रयोग खराब अभ्यास माना जाता है:

1. स्थिर रूप से यह एक विशिष्ट विशेष वाक्यविन्यास की तरह लग सकता है जबकि वास्तव में यह अंतर्निहित प्रकार रूपांतरण के साथ दो लगातार नकारात्मक के अलावा कुछ भी नहीं कर रहा है।
2. कोड के माध्यम से चर और गुणों में संग्रहीत मूल्यों के प्रकार के बारे में जानकारी प्रदान करना बेहतर है। उदाहरण के लिए, x !== 0 कहना है कि x संभवतः एक संख्या है, जबकि !!x कोड के पाठकों को ऐसा कोई लाभ नहीं पहुँचाता है।
3. Boolean(x) का उपयोग समान कार्यक्षमता के लिए अनुमति देता है, और प्रकार का अधिक स्पष्ट रूपांतरण है।

निष्प्राण रूपांतरण

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

"1" + 5 === "15" // 5 got converted to string.
1 + "5" === "15" // 1 got converted to string.
1 - "5" === -4 // "5" got converted to a number.
alert({}) // alerts "[object Object]", {} got converted to string.
!0 === true // 0 got converted to boolean
if ("hello") {} // runs, "hello" got converted to boolean.
new Array(3) === ",,"; // Return true. The array is converted to string - Array.toString();

कुछ पेचीदा हिस्से:

!"0" === false // "0" got converted to true, then reversed.
!"false" === false // "false" converted to true, then reversed.

एक बूलियन को एक नंबर परिवर्तित करना

Boolean(0) === false

Boolean(0) नंबर 0 को बूलियन false में बदल देगा।

एक छोटा, लेकिन कम स्पष्ट, रूप:

!!0 === false

एक स्ट्रिंग को बूलियन में बदलना

एक स्ट्रिंग को बूलियन उपयोग में बदलने के लिए

Boolean(myString)

या छोटा लेकिन कम स्पष्ट रूप

!!myString 

खाली स्ट्रिंग (लंबाई शून्य के) को छोड़कर सभी स्ट्रिंग को बूलियन के रूप में true करने के लिए मूल्यांकन किया जाता true ।

Boolean('') === false   // is true
Boolean("") === false   // is true
Boolean('0') === false  // is false
Boolean('any_nonempty_string') === true // is true

फ्लोट करने के लिए पूर्णांक

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

इंटेगर को फ्लोट

एक फ्लोट को पूर्णांक में बदलने के लिए, जावास्क्रिप्ट कई तरीके प्रदान करता है।

floor फ़ंक्शन फ़्लोट से कम या उसके बराबर पहला पूर्णांक लौटाता है।

Math.floor(5.7); // 5

ceil फ़ंक्शन फ्लोट की तुलना में पहले या उससे अधिक पूर्णांक देता है।

Math.ceil(5.3); // 6

round फंक्शन फ्लोट को राउंड करता है।

Math.round(3.2); // 3
Math.round(3.6); // 4

Math.trunc(3.7); // 3

Math.floor(-3.1); // -4
Math.trunc(-3.1); // -3

स्ट्रिंग को फ्लोट में बदलें

parseFloat एक स्ट्रिंग को एक तर्क के रूप में स्वीकार करता है जिसे वह एक फ्लोट में परिवर्तित करता है /

parseFloat("10.01") // = 10.01

बूलियन में परिवर्तित

Boolean(...) किसी भी डेटा प्रकार को true या false में बदल देगा।

Boolean("true") === true
Boolean("false") === true
Boolean(-1) === true
Boolean(1) === true
Boolean(0) === false
Boolean("") === false
Boolean("1") === true
Boolean("0") === true
Boolean({}) === true
Boolean([]) === true

खाली तार और संख्या 0 को गलत में बदल दिया जाएगा, और अन्य सभी सच में बदल जाएंगे।

एक छोटा, लेकिन कम स्पष्ट, रूप:

!!"true" === true
!!"false" === true
!!-1 === true
!!1 === true
!!0 === false
!!"" === false
!!"1" === true
!!"0" === true
!!{} === true
!![] === true

यह छोटा रूप दो बार तार्किक नहीं ऑपरेटर का उपयोग करके अंतर्निहित प्रकार के रूपांतरण का लाभ उठाता है, जैसा कि http://www.riptutorial.com/javascript/example/3047/double-negation.com/x- में वर्णित है ।

यहाँ ECMAScript विनिर्देश से बूलियन रूपांतरणों की पूरी सूची दी गई है

• यदि myArg का प्रकार undefined या null तो Boolean(myArg) === false
• अगर myArg टाइप की boolean तो Boolean(myArg) === myArg
• यदि myArg प्रकार की number तो Boolean(myArg) === false अगर myArg है +0 , ‑0 , या NaN ; अन्यथा true
• यदि myArg प्रकार की string तो Boolean(myArg) === false अगर myArg खाली स्ट्रिंग है (इसकी लंबाई शून्य है); अन्यथा true
• यदि myArg प्रकार का symbol या object तो Boolean(myArg) === true

मान कि परिवर्तित हो false बूलियन्स रूप falsy कहा जाता है (और अन्य सभी truthy कहा जाता है)। तुलना संचालन देखें।

एक सरणी को एक स्ट्रिंग में बदलें

Array.join(separator) का उपयोग एक विन्यासकर्ता के साथ एक स्ट्रिंग को स्ट्रिंग के रूप में आउटपुट करने के लिए किया जा सकता है।

डिफ़ॉल्ट (विभाजक = ","):

["a", "b", "c"].join() === "a,b,c"

एक स्ट्रिंग विभाजक के साथ:

[1, 2, 3, 4].join(" + ") === "1 + 2 + 3 + 4"

रिक्त विभाजक के साथ:

["B", "o", "b"].join("") === "Bob"

सरणी विधियों का उपयोग करके स्ट्रिंग में आएँ

इस तरह से uselss प्रतीत हो सकता है क्योंकि आप अनाम फ़ंक्शन का उपयोग कुछ ऐसा करने के लिए कर रहे हैं जिसे आप इसे () के साथ कर सकते हैं; लेकिन अगर आपको स्ट्रिंग्स के लिए कुछ बनाने की ज़रूरत है, जबकि आप ऐरे को स्ट्रिंग में परिवर्तित कर रहे हैं, तो यह उपयोगी हो सकता है।

var  arr = ['a', 'á', 'b', 'c']

function upper_lower (a, b, i) {
  //...do something here
  b = i & 1 ? b.toUpperCase() : b.toLowerCase();
  return a + ',' + b
}
arr = arr.reduce(upper_lower); // "a,Á,b,C"

आदिम से आदिम रूपांतरण तालिका

बोल्ड मान रूपांतरण को उजागर करते हैं जो प्रोग्रामर को आश्चर्यचकित कर सकते हैं

स्पष्ट रूप से मूल्यों को परिवर्तित करने के लिए आप स्ट्रिंग () नंबर () बूलियन () का उपयोग कर सकते हैं