टाइप कन्वर्ज़न में

टाइप कन्वर्ज़न के बारे में

JavaScript में वैल्यू अलग-अलग टाइप की हो सकती हैं। किसी वेरिएबल का टाइप स्पष्ट टाइप कन्वर्ज़न से बदला जा सकता है। इसके अलावा, जब संदर्भ को इसकी ज़रूरत होती है, तब JavaScript टाइप कोएर्शन (निहित टाइप कन्वर्ज़न) भी करता है।

टाइप कन्वर्ज़न

JavaScript में बहुत सी अन्य भाषाओं की तरह किसी (दूसरे) टाइप में कास्ट करने का कोई तरीका नहीं है, लेकिन इसके बजाय कुछ बिल्ट-इन सहायक इस्तेमाल किए जा सकते हैं। सबसे खास बात यह है कि ग्लोबल ऑब्जेक्ट Boolean, Number और String को फंक्शन की तरह इस्तेमाल करके किसी वैल्यू को संबंधित टाइप में बदला जा सकता है।

बूलियन में बदलना (ट्रूथी/फॉल्सी वैल्यू)

Boolean(value) की मदद से आप किसी भी वैल्यू को बूलियन में बदल सकते हैं। यह कैसे काम करता है?

कुछ वैल्यू एक तय समूह बनाती हैं, जिन्हें फॉल्सी वैल्यू कहते हैं, और जो false में बदल जाती हैं। सबसे ज़रूरी बात, false, 0, खाली स्ट्रिंग, null, undefined और NaN फॉल्सी होती हैं। MDN का "Falsy" पर लेख पूरी सूची दिखाता है।

बाकी सभी वैल्यू के लिए Boolean true लौटाता है। ऐसी वैल्यू को ट्रूथी कहा जाता है।

Boolean(-1);
// => true

Boolean(0);
// => false

Boolean(' ');
// => true

Boolean('');
// => false

ध्यान दीजिए कि बताए गए नियमों की वजह से JavaScript में '0', 'false', [] और {} ट्रूथी होते हैं।

संख्या में बदलना

किसी वैल्यू को संख्या में बदलने के लिए Number(value) इस्तेमाल किया जा सकता है। स्ट्रिंग के शुरू और अंत की खाली जगहों को अनदेखा कर दिया जाता है, और खाली स्ट्रिंग 0 में बदल जाती है। अगर आप किसी नॉन-प्रिमिटिव वैल्यू को या ऐसी स्ट्रिंग को बदलने की कोशिश करते हैं जो किसी संख्या को नहीं दर्शाती, तो कोई एरर नहीं फेंकी जाती। इसके बजाय परिणाम NaN (संख्या नहीं) होता है।

Number('  -12.34  ');
// => -12.34

Number('1,2');
// => NaN

Number('1 2');
// => NaN

Number('');
// => 0

Number('10e3');
// => 10000

Number({ key: '123' });
// => NaN

नीचे आप देख सकते हैं कि बाकी प्रिमिटिव वैल्यू के लिए Number क्या लौटाता है।

Number(true);
// => 1

Number(false);
// => 0

Number(null);
// => 0

Number(undefined);
// => NaN

ध्यान दीजिए कि पिछले उदाहरण के उलट, बिना किसी आर्गुमेंट के कॉल किए जाने पर Number() का परिणाम 0 होना तय है।

JavaScript में parseInt और parseFloat फंक्शन भी हैं। ये इस बारे में ढीले नियम लागू करते हैं कि कौन-सी स्ट्रिंग को संख्या में बदला जा सकता है। इसलिए अनचाहे नतीजों से बचने के लिए कन्वर्ज़न फंक्शन के तौर पर Number को प्राथमिकता देनी चाहिए।

parseInt('123a45');
// => 123

Number('123a45');
// => NaN

स्ट्रिंग में बदलना

String(value) की मदद से आप किसी वैल्यू को स्ट्रिंग में बदल सकते हैं। प्रिमिटिव वैल्यू के लिए परिणाम वैसा ही होता है जैसा आप सोचते हैं।

String(12.34);
// => '12.34'

String(false);
// => 'false'

String(null);
// => 'null'

String(undefined);
// => 'undefined'

ऐरे के लिए String फंक्शन हर एलिमेंट पर स्ट्रिंग कन्वर्ज़न लागू करता है और परिणामों को कॉमा से जोड़ देता है। आप खुद भी join मेथड लगा सकते हैं, जैसे सेपरेटर बदलने के लिए। लेकिन ऐसे मामलों में null और undefined खाली स्ट्रिंग में बदल जाते हैं।

String([42, null, true, 'abc']);
// => '42,,true,abc'

ऑब्जेक्ट के लिए String डिफ़ॉल्ट रूप से ऐसा टेक्स्ट लौटाता है जो किसी काम का नहीं होता।

String({ key: 'value' });
// => '[object Object]'

आप कन्वर्ज़न का व्यवहार बदल सकते हैं, जैसे toString मेथड देकर। javascript.info पर "Object to primitive conversion" वाला हिस्सा इसकी पूरी जानकारी देता है।

ऑब्जेक्ट और ऐरे का बेहतर स्ट्रिंग रूप पाने का एक और आम तरीका JSON एन्कोडिंग इस्तेमाल करना है। आप JSON.stringify से स्ट्रिंग में बदल सकते हैं और JSON.parse से वापस ऑब्जेक्ट या ऐरे में।

const obj = {
  name: 'Gilda Guerra',
  address: {
    city: 'Goiânia',
  },
};

JSON.stringify(obj);
// => '{"name":"Gilda Guerra","address":{"city":"Goiânia"}}'

टाइप कोएर्शन

कुछ संदर्भों में JavaScript किसी स्टेटमेंट का मूल्यांकन करने से पहले वैल्यू को अपने आप किसी दूसरे डेटा टाइप में बदल देता है। इस निहित कन्वर्ज़न को टाइप कोएर्शन कहा जाता है।

बूलियन संदर्भ

जब किसी वैल्यू का इस्तेमाल बूलियन संदर्भ में होता है, तो JavaScript वैल्यू को निहित रूप से बदलने के लिए Boolean फंक्शन वाले ही नियम लागू करता है।

• जब if स्टेटमेंट की शर्त बूलियन नहीं होती, तो यह तय करने के लिए कोएर्शन लागू होता है कि शर्त पूरी होती है या नहीं। यही बात टर्नरी ऑपरेटर ? के पहले ऑपरेंड पर भी लागू होती है।

  const num = 0;
  if (num) {
    // this block is NOT executed because 0 is falsy
  }
  
  const name = 'Jin';
  name ? 'name was provided' : 'no name provided';
  // => 'name was provided'
  

• लॉजिकल NOT ऑपरेटर ! के ऑपरेंड का भी NOT क्रिया लागू होने से पहले बूलियन में कोएर्शन हो जाता है।

  const name = '';
  !name;
  // => true
  

  इस बताए गए व्यवहार का एक नतीजा यह है कि !!value का असर Boolean(value) जितना ही होता है। फिर भी, पढ़ने में आसानी के लिए आपको Boolean ही इस्तेमाल करना चाहिए।

• JavaScript लॉजिकल AND (&&) और OR (||) ऑपरेटरों के ऑपरेंड पर भी कोएर्शन लागू करता है। लेकिन ध्यान रखिए कि एक्सप्रेशन का परिणाम ज़रूरी नहीं कि बूलियन ही हो। यह मूल ऑपरेंडों में से एक लौटाता है (MDN पर लॉजिकल ऑपरेटर देखिए)।

  null || 'hello';
  // => 'hello'
  

स्ट्रिंग संदर्भ

अगर प्रिमिटिव वैल्यू पर जोड़ ऑपरेटर + इस्तेमाल होता है और एक ऑपरेंड स्ट्रिंग है, तो दूसरे का भी स्ट्रिंग में कोएर्शन हो जाता है। कन्वर्ज़न का तरीका वही है जो String फंक्शन इस्तेमाल करने पर होता है। इसके बाद दोनों स्ट्रिंग जोड़ दी जाती हैं।

let name;
'hello ' + name;
// => 'hello undefined'

टेम्पलेट स्ट्रिंग के अंदर रखी गैर-स्ट्रिंग वैल्यू के साथ भी यही निहित कन्वर्ज़न होता है।

const degrees = 23;
`It is ${degrees} °C`;
// => 'Is is 23 °C.';

संख्यात्मक संदर्भ

बहुत से ऑपरेटर ऑपरेंडों का (ज़रूरत पड़ने पर) संख्या में कोएर्शन करते हैं, ऊपर बताए गए Number फंक्शन के तरीके के मुताबिक।

• अंकगणितीय ऑपरेटर: + (अगर कोई स्ट्रिंग शामिल न हो), -, *, /, %, **
• यूनरी प्लस और यूनरी निगेशन ऑपरेटर: +, -
• रिलेशनल ऑपरेटर (गैर-स्ट्रिंग ऑपरेंड के लिए): >, >=, <, <=
• बिटवाइज़ ऑपरेटर: |, &, ^, ~

इनमें से किसी भी ऑपरेटर के बारे में ज़्यादा जानकारी के लिए MDN की ऑपरेटर सूची देखिए।

जब कोई ऑपरेंड स्ट्रिंग हो सकता हो, तो गलतियों से बचने के लिए हमेशा Number फंक्शन से स्पष्ट रूप से बदलना ही बेहतर है।

'1' + '2';
// => '12'
// addition operator in string context as explained above

Number('1') + Number('2');
// => 3

कभी-कभी आप देखेंगे कि किसी स्ट्रिंग का संख्या में कोएर्शन करने के लिए यूनरी प्लस ऑपरेटर इस्तेमाल किया जा रहा है। यह सलाह नहीं दी जाती, क्योंकि इसे पढ़ना स्पष्ट Number कॉल की तुलना में कहीं ज़्यादा मुश्किल है।

const value = '42';
+value;
// => 42

Number(value);
// => 42

लूज़ इक्वलिटी और इनइक्वलिटी ऑपरेटर ==/!= इस्तेमाल करने में भी अक्सर संख्या में निहित कन्वर्ज़न होता है। लेकिन इन ऑपरेटरों का ठीक-ठीक तरीका काफी उलझा हुआ है (MDN पर लूज़ इक्वलिटी देखिए)। नतीजों का अनुमान लगाना मुश्किल है, और कभी-कभी वे आपकी सोच के उलट होते हैं। इन निहित कन्वर्ज़नों से बचने के लिए इसके बजाय स्ट्रिक्ट इक्वलिटी/इनइक्वलिटी ऑपरेटर ===/!== इस्तेमाल कीजिए।