रिक्त स्ट्रिंग के लिए 0 में parseInt से NaN कैसे करें?

Question

क्या NaNजावास्क्रिप्ट में मूल्यों को पार्स करने के बजाय किसी तरह 0 वापस करना संभव है ?

खाली स्ट्रिंग parseIntरिटर्न के मामले में NaN।

क्या जावास्क्रिप्ट में कुछ ऐसा करना संभव है, जिसकी जाँच करें NaN?

var value = parseInt(tbb) == NaN ? 0 : parseInt(tbb)

या हो सकता है कि कोई अन्य फ़ंक्शन या jQuery प्लगइन है जो कुछ समान कर सकता है?

Comments

FYI करें, NaN != NaN। आप की आवश्यकता होगी isNaN(value)।

— pimvdb

हाँ, कोई भी दो नन्नियाँ समान नहीं हैं;)

— जेम्स पी।

parseInt()दो बार फ़ंक्शन को कॉल करना (सफल / सामान्य गैर- NaNमामले में) कभी भी एक अच्छा विचार नहीं है। अक्षमता के अलावा, अनैच्छिक के लिए जो कुछ भी पारित किया tbbजाता है वह साइड-इफेक्ट के साथ एक फ़ंक्शन कॉल है यह भयानक है। मैं यहां किसी भी समाधान का उपयोग नहीं करूंगा जहां मैं parseInt()दो बार देखता हूं ।

— जॉनब्र्वे

Answer 1

var s = '';

var num = parseInt(s) || 0;

जब बूलियन मूल्यों के साथ उपयोग नहीं किया जाता है, तो तार्किक या ( ||) ऑपरेटर पहली अभिव्यक्ति लौटाता है ( parseInt(s)) यदि यह सच है, तो इसका मूल्यांकन किया जा सकता है, अन्यथा यह दूसरी अभिव्यक्ति (0) लौटाता है। का रिटर्न मान parseInt('')NaN है। NaN गलत का मूल्यांकन करता है, इसलिए numअंत में 0 पर सेट किया जा रहा है।

Comments

यह काम नहीं करेगा यदि s = "4s"; (यह 4 लौटता है ... जो कि गलत है ...)

— 15

parseInt फ़ंक्शन js में किसी भी संख्या में स्ट्रिंग को पार्स करें

— अली youhannaei

@markzzz फिर से प्रश्न पढ़ें। ओपी पूछता है: " क्या किसी तरह NaN के बजाय 0 वापस करना संभव है "। ओपी यह जांचना नहीं चाहता है कि क्या विशेष स्ट्रिंग इंट के लिए पार्स करने योग्य है। ओपी 0इसके बदले मिलना चाहता है NaN। यह मैट के कोड द्वारा पूरी तरह से हल किया गया है।

— trejder

@markzzzvar nextIphone = parseInt("4S") + 1; // wow it works!

— शून्य विचलन

@ मैथ्यू कृपया "झूठा" या "सत्य" शब्दों का उपयोग करें । क्योंकि NaN === झूठी झूठी है! लेकिन बुलियन (NaN) === बुलियन (झूठी) सच है। तार्किक या "सत्य" के

— पाब्लो रिकाल्ड

Answer 2

आप isNaN()फ़ंक्शन का उपयोग भी कर सकते हैं :

var s = ''
var num = isNaN(parseInt(s)) ? 0 : parseInt(s)

Comments

parseInt(s)दो बार फोन क्यों ? इसके अलावा यह होना चाहिएparseInt(s, 10)

— Dexygen

@GeorgeJempty "10" का एक मूलांक डिफ़ॉल्ट है; यह पैरामीटर वैकल्पिक है। parseInt()हालांकि दो बार कॉल करने पर अच्छी बात है ।

— शरद ऋतु लियोनार्ड

@AutumnLeonard यह केवल एक प्रकार का सच है। यदि आपकी स्ट्रिंग 0 से शुरू होती है, तो मान लिया जाता है कि संख्या अष्टक प्रारूप में है इसलिए parseInt ('077') आपको 63 देता है। इससे बग ढूंढने में बहुत बुरा लग सकता है, इसलिए आपको हमेशा दूसरा पैरामीटर निर्दिष्ट करना चाहिए। उदाहरण के लिए देखें stackoverflow.com/questions/8763396/…

— chuck258

Answer 3

मैं किसी को भी उल्लेख का उपयोग न करते हुए आश्चर्यचकित था Number()। अगर यह प्रदान किया जाता है तो यह दशमलव को बराबर कर देगा, इसलिए इससे अलग कार्य करेगा parseInt(), हालांकि यह पहले से ही आधार 10 मानता है और 0 में "" या "" भी बदल जाएगा।

Comments

हां, लोकलस्टोरेज से पढ़ने के लिए बहुत आसान है: नंबर (localStorage.getItem ('appBanner.count')) + 1

— फिलिप मर्फी

जबकि यह सवाल के लिए काम करता है जैसा कि यह पूछा गया था, यह अभी भी गैर-गैर-व्हाट्सएप पात्रों के लिए NaN लौटाता है

— काइल डेलानी

Answer 4

उन लोगों के लिए जो प्रतिबंधित नहीं हैं parseInt, आप बिटवाइज़ या ऑपरेटर (जो ToInt32इसके ऑपरेंड को कथित रूप से कॉल करते हैं) का उपयोग कर सकते हैं ।

var value = s | 0;

// NaN | 0     ==>> 0
// ''  | 0     ==>> 0
// '5' | 0     ==>> 5
// '33Ab' | 0  ==>> 0
// '0x23' | 0  ==>> 35
// 113 | 0     ==>> 113
// -12 | 0     ==>> -12
// 3.9 | 0     ==>> 3

नोट: ToInt32से अलग है parseInt। (यानी parseInt('33Ab') === 33)

Comments

लेकिन: '10000000000' | 0 === 1410065408।

— त्रिनकोट

@trincot हाँ, किसी भी मूल्य> = Math.pow(2, 31)अतिप्रवाह होगा।

— अहमद इब्राहिम

Answer 5

समस्या

अन्य उत्तर इस बात पर ध्यान नहीं देते हैं कि 0झूठा है, और इस प्रकार 0 के बजाय 20 होगा:

const myNumber = parseInt('0') || 20; // 20

समाधान

मैं एक सहायक कार्य का प्रस्ताव करता हूं, जो अधिकांश मुद्दों को हल करता है:

function getNumber({ value, defaultValue }) {
  const num = parseInt(value, 10);
  return isNaN(num) ? defaultValue : num;
}

सहायक फ़ंक्शन निम्नलिखित परिणाम देगा:

getNumber({ value: "0", defaultValue: 20 }); // 0
getNumber({ value: "2", defaultValue: 20 }); // 2
getNumber({ value: "2.2", defaultValue: 20 }); // 2
getNumber({ value: "any string", defaultValue: 20 }); // 20
getNumber({ value: undefined, defaultValue: 20 }); // 20
getNumber({ value: null, defaultValue: 20 }); // 20
getNumber({ value: NaN, defaultValue: 20 }); // 20
getNumber({ value: false, defaultValue: 20 }); // 20
getNumber({ value: true, defaultValue: 20 }); // 20

Comments

कृपया parseInt को एक मूलांक भेजें: parseInt(string, radix)इस पर विचार करें: parseInt("0x10") === 16इसके अलावा कुछ ब्राउज़रों में parseInt("010")उपज सकता 8है

— andlrc

यदि आप पहले से ही अन्य सामान के लिए लॉश के आधार पर हैं, तो एक आसान defaultToकार्य है जो ऐसा करता है: _.defaultTo(NaN, -1)रिटर्न -1, लेकिन _.defaultTo(0, -1);रिटर्न 0।

— वॉल्ड्रिअस

यह एक उत्कृष्ट मुद्दा है! आप केवल भरोसा कर सकते हैं || जब आपका पसंदीदा डिफ़ॉल्ट ZERO (सही है, तो यह वही है जो ओपी चाहता था) सही डिफ़ॉल्ट प्रदान करने के लिए अंत में। (हो सकता है क्या उम्मीद नहीं थी!) आप '0' इनपुट के falsy प्रकृति के कारण, का उल्लेख किया है, यह इस मामले में अमान्य इनपुट के रूप में व्यवहार किया जाता है, और बयान डिफ़ॉल्ट मान के बजाय वापस आ जाएगी

— JonathanDavidArndt

निश्चित रूप से आपको parseIntदो बार कॉल करने के बजाय एक कास्ट का उपयोग करना चाहिए

— काइल डेलानी

Answer 6

क्या नौकरी मेरी राय में parseInt की तुलना में बहुत अधिक क्लीनर है, + ऑपरेटर का उपयोग करें

var s = '';
console.log(+s);

var s = '1024'
+s
1024

s = 0
+s
0

s = -1
+s
-1

s = 2.456
+s
2.456

s = ''
+s
0

s = 'wtf'
+s
NaN

Comments

बहुत कॉम्पैक्ट है। क्या शर्म की बात है कि आपको अधिक अंक नहीं मिले। मैंने आपको वोट दिया। कृपया म्यूट ट्रोल द्वारा आज अर्जित मेरे -2 को पकड़ने की कोशिश करने के लिए कृपया ... (इस पृष्ठ के अंत में मेरा उत्तर देखें)। धन्यवाद।

— फाबिन हदादी

Answer 7

var value = isNaN(parseInt(tbb)) ? 0 : parseInt(tbb);

Answer 8

एक खाली स्ट्रिंग के लिए एक अलग जाँच करें (क्योंकि यह एक विशिष्ट मामला है) और इसे इस मामले में शून्य पर सेट करें।

आप "0" को शुरू करने के लिए अपील कर सकते हैं, लेकिन फिर आपको यह इंगित करने के लिए एक उपसर्ग जोड़ने की आवश्यकता है कि यह एक दशमलव है और एक अष्टक संख्या नहीं है

Comments

तो आपको लगता है कि खाली होने पर 0 को जोड़ना बेहतर है?

— जोपर

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

— Schroedingers बिल्ली

Answer 9

फ़ंक्शन को ओवरराइड क्यों नहीं किया जाता है? उस स्थिति में आप हमेशा सुनिश्चित कर सकते हैं कि यह 0मामले में लौटे NaN:

(function(original) {
    parseInt = function() {
        return original.apply(window, arguments) || 0;
    };
})(parseInt);

अब, आपके कोड में कहीं भी:

parseInt('') === 0

Comments

इस तरह के समारोह को ओवरराइड करने से विशेषज्ञ जावास्क्रिप्ट प्रोग्रामर को भ्रमित किया जा सकता है जो बग के रूप में देख सकते हैं। आपके ओवरराइड किए गए फ़ंक्शन को कहीं दफनाए जाने की संभावना है, जहां इसे देखने की संभावना नहीं है। यह रचनात्मक है, लेकिन मुझे यकीन नहीं है कि मैं व्यक्तिगत रूप से इस पर विचार करने की सिफारिश करूंगा कि || 0मैट के जवाब में सिर्फ यह जोड़ना कितना आसान है । मैं उन वस्तुओं को ओवरराइड करता हुआ देखता हूं जो आप अंतिम उपाय के रूप में नहीं करते हैं या ऐसा नहीं करने पर समय और जटिलता के मामले में काफी अधिक खर्च होता है।

— jmort253

मैं @ jmort253 से सहमत हूं ... यह खतरनाक है क्योंकि फ़ंक्शन बहुत अधिक स्मार्ट है। यह ठीक उसी कार्य को करने के लिए बेहतर है, लेकिन getSafeNumberValue जैसे नाम के साथ या ऐसा कुछ।

— सैमुअल

Answer 10

मुझे एक समान समस्या थी (फ़ायरफ़ॉक्स v34) जैसे साधारण तारों से:

var myInt = parseInt("b4");

तो मैं एक त्वरित हैक के साथ आया:

var intVal = ("" + val).replace(/[^0-9]/gi, "");

और फिर गैर-साधारण सामान के लिए फ्लोट्स + इनट्स से निपटने के लिए सभी बेवकूफ जटिल हो गए:

var myval = "12.34";

function slowParseNumber(val, asInt){
    var ret = Number( ("" + val).replace(/[^0-9\.]/gi, "") );
    return asInt ? Math.floor(ret) : ret;
}
var floatVal = slowParseNumber(myval);

var intVal = slowParseNumber(myval, true);
console.log(floatVal, intVal);

यह चीजों की तरह 0 लौटाएगा:

var intVal = slowParseNumber("b"); // yeilds 0

Answer 11

//////////////////////////////////////////////////////
function ToInt(x){x=parseInt(x);return isNaN(x)?0:x;}
//////////////////////////////////////////////////////
var x = ToInt('');   //->  x=0
    x = ToInt('abc') //->  x=0
    x = ToInt('0.1') //->  x=0
    x = ToInt('5.9') //->  x=5
    x = ToInt(5.9)   //->  x=5
    x = ToInt(5)     //->  x=5

Comments

क्या आप इसका समाधान बता सकते हैं?

— रामेनशेफ

अगर आप किसी भी संख्या (जैसे’123 ’या 123) को पूर्णांक में बदलना चाहते हैं, यदि आप parseInt (, abc’) का उपयोग करेंगे,

— अब्दुलरहमान अलशमीरी

अगर आप parseInt ('abc') का उपयोग करेंगे तो u को NaN मिल जाएगा लेकिन यह फ़ंक्शन NaN को 0 में बदल देगा

— अब्दुलरहमान अलशमीरी

बिंगो, ||दृष्टिकोण के स्पष्ट विकल्प के रूप में । मुझे पता है कि यह एक पुराना प्रश्न और उत्तर है, लेकिन यह उत्तर दो बार parseInt को कॉल करने से बचता है, और isNa का सही उपयोग करता है। यह सिर्फ मूलांक parseInt(x, 10)को पूरी तरह से होना चाहिए। (मेरी प्राथमिकता पुन: उपयोग करने के बजाय एक अलग आंतरिक चर है x।)

— २२:०४ पर goodeye

Answer 12

मैंने इसे संभालने के लिए एक 2 प्रोटोटाइप बनाया, एक नंबर के लिए, और एक स्ट्रिंग के लिए।

// This is a safety check to make sure the prototype is not already defined.
Function.prototype.method = function (name, func) {
    if (!this.prototype[name]) {
        this.prototype[name] = func;
        return this;
    }
};

// returns the int value or -1 by default if it fails
Number.method('tryParseInt', function (defaultValue) {
    return parseInt(this) == this ? parseInt(this) : (defaultValue === undefined ? -1 : defaultValue);
});

// returns the int value or -1 by default if it fails
String.method('tryParseInt', function (defaultValue) {
    return parseInt(this) == this ? parseInt(this) : (defaultValue === undefined ? -1 : defaultValue);
});

यदि आप सुरक्षा जांच का उपयोग नहीं करना चाहते हैं, तो उपयोग करें

String.prototype.tryParseInt = function(){
    /*Method body here*/
};
Number.prototype.tryParseInt = function(){
     /*Method body here*/
};

उदाहरण का उपयोग:

var test = 1;
console.log(test.tryParseInt()); // returns 1

var test2 = '1';
console.log(test2.tryParseInt()); // returns 1

var test3 = '1a';
console.log(test3.tryParseInt()); // returns -1 as that is the default

var test4 = '1a';
console.log(test4.tryParseInt(0));// returns 0, the specified default value

Answer 13

// implicit cast
var value = parseInt(tbb*1); // see original question

स्पष्टीकरण, उन लोगों के लिए जो इसे तुच्छ नहीं पाते हैं:

एक से गुणा करके, "निहित कास्ट" नामक एक विधि, अज्ञात प्रकार के ऑपरेंड को आदिम प्रकार 'संख्या' में बदलने का प्रयास करती है। विशेष रूप से, एक खाली स्ट्रिंग संख्या 0 बन जाएगी, जो इसे parseInt () के लिए एक योग्य प्रकार बनाती है ...

ऊपर एक बहुत अच्छा उदाहरण भी दिया गया था PirateApp द्वारा, जिन्होंने + साइन प्रीपेंड करने का सुझाव दिया था, जिससे जावास्क्रिप्ट ने नंबर निहित कलाकारों का उपयोग करने के लिए मजबूर किया।

Comments

यह मूल प्रश्न मेरे प्रिय का सीधा जवाब है।

— फाबिन हदादी

इसके लिएparseInt('str'*1)

— रोडियन बसकोकोव

क्यों parseIntपहले से ही एक नंबर पर कॉल करें ? यह फिर से संख्या में बदलने के लिए केवल स्ट्रिंग में एक और रूपांतरण वापस आएगा।

— 20

Answer 14

इस तरह से, क्यों नहीं एक फ़ंक्शन लिखें और इसे कॉल करें जहां कभी आवश्यक हो। मैं मान रहा हूं कि यह गणना करने के लिए फॉर्म फ़ील्ड में प्रविष्टि है।

var Nanprocessor = function (entry) {
    if(entry=="NaN") {
        return 0;
    } else {
        return entry;
    }
}

 outputfield.value = Nanprocessor(x); 

// where x is a value that is collected from a from field
// i.e say x =parseInt(formfield1.value); 

यह क्या गलत कर रहा है?

Comments

नमस्ते, वाट हमें उपरोक्त विधि का पालन करने से रोक रहा है। जानना चाहेंगे n सीखना।

— नरेश

आपको परीक्षण करने के लिए NNN का उपयोग करना चाहिए NaN।

— मैथ्यू

धन्यवाद मैट :) मुझे नहीं पता है कि javascrip में NNN () नाम का एक फंक्शन है! मुझे बताने के लिए धन्यवाद...!

— नरेश

Answer 15

यहाँ एक TryParseInt विधि है जिसका मैं उपयोग कर रहा हूं, यह डिफ़ॉल्ट मान को दूसरे पैरामीटर के रूप में लेता है इसलिए यह आपके लिए आवश्यक कुछ भी हो सकता है।

function tryParseInt(str, defaultValue) {
    return parseInt(str) == str ? parseInt(str) : defaultValue;
}

tryParseInt("", 0);//0 
tryParseInt("string", 0);//0 
tryParseInt("558", 0);//558

Answer 16

एक सहायक कार्य जो अभी भी मूलांक का उपयोग करने की अनुमति देता है

function parseIntWithFallback(s, fallback, radix) {
    var parsed = parseInt(s, radix);
    return isNaN(parsed) ? fallback : parsed;
}

Answer 17

आपके पास बहुत ही साफ कोड हो सकता है, मुझे ऐसी ही समस्याएं थीं और मैंने इसका उपयोग करके हल किया:

var a="bcd";
~~parseInt(a);

Answer 18

इस समाधान की तलाश में अन्य लोगों के लिए, बस का उपयोग करें: ~~ बिना parseInt, यह सबसे साफ मोड है।

var a = 'hello';
var b = ~~a;

यदि NaN, यह बदले 0 देगा।

Obs। यह समाधान केवल पूर्णांकों के लिए लागू होता है