ParseInt Array # मैप के साथ NaN क्यों नहीं देता है?

Question

से मोज़िला डेवलपर नेटवर्क :

[1,4,9].map(Math.sqrt)

निकलेगा:

[1,2,3]

फिर ऐसा क्यों होता है:

['1','2','3'].map(parseInt)

इसकी उपज:

[1, NaN, NaN]

मैंने फ़ायरफ़ॉक्स 3.0.1 और क्रोम 0.3 में परीक्षण किया है और सिर्फ एक अस्वीकरण के रूप में, मुझे पता है कि यह क्रॉस-ब्राउज़र कार्यक्षमता (कोई IE) नहीं है।

मुझे पता चला कि निम्नलिखित वांछित प्रभाव को पूरा करेगा। हालाँकि, यह अभी भी के गलत व्यवहार की व्याख्या नहीं करता है parseInt।

['1','2','3'].map(function(i){return +i;}) // returns [1,2,3]

Comments

आलसी के लिए: का उपयोग करें .map(parseFloat)क्योंकि यह ony एक पैरामीटर लेता है।

या उपयोग करें .map(Number)।

— निकोलाई

यदि आप इंटेगर को बिना हाथ के रोल्ड फंक्शन के लिए चाहते हैं, तो आप उसे ला सकते हैं।

— 22

@Nikolai user669677 शानदार सुझाव! मुझे लगता है कि एक anwser

— BiAiB

क्या कोई समझा सकता है कि parseInt पहले नंबर को सही ढंग से क्यों बताता है और पहले सूचकांक के अलावा अन्य के लिए त्रुटि करता है

— बावा जी

Answer 1

में कॉलबैक फ़ंक्शन Array.mapहै तीन पैरामीटर:

उसी मोज़िला पृष्ठ से जिसे आपने लिंक किया था:

कॉलबैक को तीन तर्कों के साथ लागू किया जाता है: तत्व का मूल्य, तत्व का सूचकांक, और ऐरे ऑब्जेक्ट का पता लगाया जा रहा है। "

इसलिए यदि आप एक फ़ंक्शन को कहते हैं parseIntजो वास्तव में दो तर्कों की अपेक्षा करता है, तो दूसरा तर्क तत्व का सूचकांक होगा।

इस स्थिति में, आपने parseIntमूलांक 0, 1 और 2 के साथ कॉल करना समाप्त कर दिया । पहला पैरामीटर आपूर्ति नहीं करने के समान है, इसलिए यह इनपुट (आधार 10, इस मामले में) के आधार पर डिफ़ॉल्ट है। आधार 1 एक असंभव संख्या आधार है, और 3 आधार 2 में मान्य संख्या नहीं है:

parseInt('1', 0); // OK - gives 1
parseInt('2', 1); // FAIL - 1 isn't a legal radix
parseInt('3', 2); // FAIL - 3 isn't legal in base 2 

तो इस मामले में, आपको रैपर फ़ंक्शन की आवश्यकता है:

['1','2','3'].map(function(num) { return parseInt(num, 10); });

या ES2015 + सिंटैक्स के साथ:

['1','2','3'].map(num => parseInt(num, 10));

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

Answer 2

mapएक 2 तर्क के साथ गुजर रहा है, जो (कई मामलों में) parseIntरेडिक्स पैरामीटर को गड़बड़ाने वाला है।

यदि आप अंडरस्कोर का उपयोग कर रहे हैं तो आप कर सकते हैं:

['10','1','100'].map(_.partial(parseInt, _, 10))

या बिना अंडरस्कोर के:

['10','1','100'].map(function(x) { return parseInt(x, 10); });

Answer 3

आप संख्या को इटर्सेट फ़ंक्शन के रूप में उपयोग करके इस समस्या को हल कर सकते हैं :

var a = ['0', '1', '2', '10', '15', '57'].map(Number);

console.log(a);

नए ऑपरेटर के बिना, नंबर का उपयोग टाइप रूपांतरण करने के लिए किया जा सकता है। हालाँकि, यह parseInt से भिन्न है: यह स्ट्रिंग को पार्स नहीं करता है और यदि नंबर परिवर्तित नहीं किया जा सकता है तो NaN लौटाता है। उदाहरण के लिए:

console.log(parseInt("19asdf"));
console.log(Number("19asf"));

Answer 4

मैं दांव लगाने जा रहा हूं कि यह कुछ मजेदार है जो parseInt के 2 पैरामीटर, मूलांक के साथ चल रहा है। यह Array.map के उपयोग के साथ क्यों टूट रहा है और जब आप इसे सीधे कॉल करते हैं, तो मुझे नहीं पता।

//  Works fine
parseInt( 4 );
parseInt( 9 );

//  Breaks!  Why?
[1,4,9].map( parseInt );

//  Fixes the problem
[1,4,9].map( function( num ){ return parseInt( num, 10 ) } );

Comments

यदि आपूर्ति की गई स्ट्रिंग 0 वर्ण से प्रारंभ होती है, तो केवल parseInt अष्टकोणीय होता है।

— अलनीतक 16

ओह हां ... यह सही है। यह इनपुट के आधार पर मूलांक को "अनुमान" करने की कोशिश करता है। उसके लिए माफ़ करना।

— पीटर बैली 16

Answer 5

आप तीर फ़ंक्शन ES2015 / ES6 का उपयोग कर सकते हैं और पार्सइंट पर बस पास नंबर दे सकते हैं। मूलांक के लिए डिफ़ॉल्ट मान 10 होगा

[10, 20, 30].map(x => parseInt(x))

या आप अपने कोड की बेहतर पठनीयता के लिए स्पष्ट रूप से मूलांक बता सकते हैं।

[10, 20, 30].map(x => parseInt(x, 10))

उदाहरण के लिए मूलांक से ऊपर स्पष्ट रूप से 10 पर सेट किया गया है

Answer 6

एक और (काम) जल्दी ठीक:

var parseInt10 = function(x){return parseInt(x, 10);}

['0', '1', '2', '10', '15', '57'].map(parseInt10);
//[0, 1, 2, 10, 15, 57]

Answer 7

parseIntIMHO को इस कारण से बचा जाना चाहिए। आप इसे इस तरह से इन संदर्भों में अधिक सुरक्षित बनाने के लिए इसे लपेट सकते हैं:

const safe = {
  parseInt: (s, opt) => {
    const { radix = 10 } = opt ? opt : {};
    return parseInt(s, radix);
  }
}

console.log( ['1','2','3'].map(safe.parseInt) );
console.log(
  ['1', '10', '11'].map(e => safe.parseInt(e, { radix: 2 }))
);

लॉश / fp इन गोचरों से बचने के लिए डिफ़ॉल्ट रूप से 1 से तर्क वितर्क करता है। व्यक्तिगत रूप से मैंने इन वर्कअराउंड को जितने कीड़े से बचने के लिए बनाया है। parseIntएक सुरक्षित कार्यान्वयन के पक्ष में ब्लैकलिस्ट करना, मुझे लगता है, एक बेहतर दृष्टिकोण है।