मैं जावास्क्रिप्ट में एक स्ट्रिंग को बूलियन में कैसे बदल सकता हूं?

Question

क्या मैं एक बूलियन मान (उदाहरण के लिए, 'सही', 'गलत') का प्रतिनिधित्व करने वाले स्ट्रिंग को जावास्क्रिप्ट में आंतरिक प्रकार में बदल सकता हूं?

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

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

var myValue = document.myForm.IS_TRUE.value;
var isTrueSet = myValue == 'true';

क्या इसे पूरा करने का एक बेहतर तरीका है?

Comments

"क्या इसे पूरा करने का एक बेहतर तरीका है?" - निश्चित रूप से एक बदतर तरीका है: डीstring=(string==String(string?true:false))?(string?true:false):(!string?true:fa‌​lse);

— मार्क के कोवान

आसानी से स्ट्रिंग्स और function parseBool(val) { return val === true || val === "true" }

— बूल्स को

@ मर्कfunction checkBool(x) { if(x) {return true;} else {return false;} }

— सेबी

@ सेबी: आप इसे दस्तावेज़ करना भूल गए:if (checkBool(x) != false) { ... } else { ... }

— मार्क के कोवान

!!(parseInt(value) || value === "true")

— एंड्रयू लुका 3

Answer 1

करना:

var isTrueSet = (myValue == 'true');

आप पहचान ऑपरेटर ( ===) का उपयोग करके इसे कठोर बना सकते हैं , जो कि समानता वाले ऑपरेटर ( ==) के बजाय तुलनात्मक चर के विभिन्न प्रकार होने पर कोई निहित प्रकार रूपांतरण नहीं करता है ।

var isTrueSet = (myValue === 'true');

---

मत करो:

आपको अपनी विशिष्ट आवश्यकताओं के लिए इन दो तरीकों का उपयोग करने के बारे में सावधान रहना चाहिए :

var myBool = Boolean("false");  // == true

var myBool = !!"false";  // == true

कोई भी स्ट्रिंग जो खाली स्ट्रिंग नहीं है, उनका trueउपयोग करके मूल्यांकन करेगा । हालांकि वे सबसे साफ तरीके हैं, जिनके बारे में मैं बूलियन रूपांतरण के बारे में सोच सकता हूं, मुझे लगता है कि वे वे नहीं हैं जो आप खोज रहे हैं।

Comments

myValue === 'true';के बराबर है myValue == 'true';। यहाँ ===पर उपयोग करने में कोई लाभ नहीं ==है।

— टिम डाउन

मैं क्रॉकफोर्ड की सलाह और उपयोग का पालन ​​करता हूं ===और !==जब भी यह समझ में आता है, जो लगभग हमेशा होता है।

— guinaps

उदाहरण के लिए सभी अपरकेस में "सही" के बारे में क्या?

— बीएमएनआर

@guinaps मैं आमतौर पर क्रॉकफोर्ड की सलाह का पालन करता हूं, लेकिन ==बनाम ===परिदृश्य उन कुछ में से एक है जिसमें मैं नहीं करता हूं। मैं पूरी तरह से असहमत हूं कि यह "लगभग हमेशा" उपयोग करने के लिए समझ में आता है ===। ढीली टाइप की भाषाएं मौजूद हैं क्योंकि हम टाइप के बारे में परवाह नहीं करना चाहते हैं; अगर हम किसी चीज की जांच करते हैं, जैसे if (price >= 50)कि अगर वह एक तार के रूप में शुरू हुई तो हमें कोई परवाह नहीं है। मैं कहता हूं, अधिकांश समय, हम चाहते हैं कि प्रकारों को उलझाया जाए। दुर्लभ मामलों में जहां हम प्रकार की बाजीगरी (जैसे if (price === null)) नहीं चाहते हैं , तब हम उपयोग करते हैं ===। यह वही है जो मैंने वर्षों से किया है और मुझे कभी कोई समस्या नहीं हुई।

— JMTyler

@JMTyler रखरखाव प्रोग्रामर की अनदेखी कर सकता है। हमेशा उचित तुलना ऑपरेटर का उपयोग करें! यदि आप दोनों पक्षों के प्रकारों को 'निश्चित रूप से' जानते हैं, लेकिन === का उपयोग नहीं करते हैं, तो मुझे बाद में आपके कोड को देखते समय यह ज्ञान नहीं होगा। यदि आपका कोड पुन: उपयोग किया जाता है तो यह एक बुरा सपना बन सकता है। यदि आप वास्तव में अपने प्रकार के 'जुगाड़' चाहते हैं, जैसा कि आप कहते हैं, तो '==' का उपयोग करें, लेकिन बहुत सारे जेएस देव इस पर भी आसानी से यात्रा करेंगे, अपने कोड को बेहतर बनाने के लिए। बूलियन 'सच' को दर्शाने के लिए मुझे कितनी बार स्ट्रिंग 'झूठी' चाहिए?

— एकेरू

Answer 2

चेतावनी

यह अत्यधिक उत्कीर्ण विरासत का उत्तर तकनीकी रूप से सही है, लेकिन केवल एक बहुत विशिष्ट परिदृश्य को कवर करता है, जब आपका स्ट्रिंग मूल्य बिल्कुल "true"या है "false"।

में अमान्य JSON स्ट्रिंग इन कार्यों में पारित कर दिया नीचे एक अपवाद फेंक देंगे ।

---

मूल उत्तर:

कैसा रहेगा?

JSON.parse("True".toLowerCase());

या jQuery के साथ

$.parseJSON("TRUE".toLowerCase());

Comments

इसके साथ समस्या यह है कि कई संभावित मूल्य एक पार्स त्रुटि उत्पन्न करते हैं जो जेएस निष्पादन को रोक देता है। इसलिए JSON.parse ("FALSE") रन करना जावास्क्रिप्ट को बम बनाता है। मुझे लगता है कि सवाल का मुद्दा सिर्फ इन सटीक मामलों को हल करना नहीं है, बल्कि अन्य मामलों के लिए भी लचीला होना है।

— बिशपज

@ इस समाधान वास्तव में वास्तव में मैं क्या जरूरत है; अच्छी तरह से, यह एक कोशिश में लपेटकर ... हालांकि पकड़। मैं केवल बूल में बदलना चाहता था यदि यह स्ट्रिंग में बूलियन मान था; अन्यथा, बस प्रदान की गई स्ट्रिंग का उपयोग करें। यह काम! धन्यवाद।

— jedmao

यह सिर्फ JSON.parse("TRUE".toLowerCase())इतना कहना सरल है कि यह सही ढंग से पार्स कर सकता है।

— Yuck

इतने अपवित्र क्यों हैं? यह अक्षम्य और भयानक है। आगे क्या है? 'true'.length === 4?

— मक्सीम वी।

@MaksimVi। typeof str==="string"&& str.length===4&& str.charAt(0)==="t" && str.charAt(1)==="r" && str.charAt(2)==="u" && str.charAt(3)==="e"&& true===true && true!==false && false===false// बस सुनिश्चित करें

— Vitim.us

Answer 3

stringToBoolean: function(string){
    switch(string.toLowerCase().trim()){
        case "true": case "yes": case "1": return true;
        case "false": case "no": case "0": case null: return false;
        default: return Boolean(string);
    }
}

Comments

वास्तव में इसे सरल बनाया जा सकता है। 1) के लिए परीक्षण करने की कोई आवश्यकता नहीं है "true", "yes"और "1"। 2) toLowerCaseनहीं लौटता है null। 3) यहाँ के Boolean(string)रूप में ही string!==""है। =>switch(string.toLowerCase()) {case "false": case "no": case "0": case "": return false; default: return true;}

— रॉबर्ट

@ रॉबर्ट, एक अच्छा, लेकिन मैं इसके बजाय डिफ़ॉल्ट falseहोगा।

— drigoangelo

@drigoangelo होने default: return true;निश्चित रूप से संभव है। लेकिन यह फ़ंक्शन के व्यवहार को बदल देगा।

— रॉबर्ट

मैंने सोचा कि यह सबसे अच्छा जवाब था, और यहाँ इस पर विस्तृत करना चाहते थे: stackoverflow.com/questions/263965/…

— BrDaHa

यदि आप .toLowerCase () को कॉल करके डेटा को सामान्य कर रहे हैं, तो आप व्हाट्सएप को ट्रिम () में भी फेंकना चाहते हैं

— jCuga

Answer 4

मुझे लगता है कि यह बहुत सार्वभौमिक है:

if (String(a) == "true") ...

यह जाता है:

String(true) == "true"     //returns true
String(false) == "true"    //returns false
String("true") == "true"   //returns true
String("false") == "true"  //returns false

Comments

जब आप अपरकेस या बूलियन में एक स्ट्रिंग प्राप्त कर सकते हैं, तोString(a).toLowerCase() === 'true'

— पाउलो

String("what about input like this that isn't a bool?") == "true"

— थॉमस एडिंग

@ThomasEding false ... क्या आप इसे वापस करना चाहते हैं?

— स्नोबार्ब

String()कंस्ट्रक्टर का उपयोग नहीं करने से भी छोटा हो सकता है :true+'' === 'true' // true

— टोड

BTW, 1 या 0 के लिए यह गलत या सच के लिए भी डालना चाहिए

— मिगुएल

Answer 5

मैच के मामले को याद रखें:

var isTrueSet = (myValue.toLowerCase() === 'true');

इसके अलावा, अगर यह एक फॉर्म एलिमेंट चेकबॉक्स है, तो आप यह भी पता लगा सकते हैं कि क्या चेकबॉक्स चेक किया गया है:

var isTrueSet = document.myForm.IS_TRUE.checked;

यह मानते हुए कि अगर यह जाँच की जाती है, तो यह सच के बराबर "सेट" है। यह सही / गलत के रूप में मूल्यांकन करता है।

Comments

यदि myValueऐसा होता है null, trueया कुछ अन्य प्रकार ...

— mik01aj

Answer 6

आप नियमित अभिव्यक्ति का उपयोग कर सकते हैं:

/*
 * Converts a string to a bool.
 *
 * This conversion will:
 *
 *  - match 'true', 'on', or '1' as true.
 *  - ignore all white-space padding
 *  - ignore capitalization (case).
 *
 * '  tRue  ','ON', and '1   ' will all evaluate as true.
 *
 */
function strToBool(s)
{
    // will match one and only one of the string 'true','1', or 'on' rerardless
    // of capitalization and regardless off surrounding white-space.
    //
    regex=/^\s*(true|1|on)\s*$/i

    return regex.test(s);
}

यदि आप स्ट्रिंग वर्ग का विस्तार करना चाहते हैं, तो आप कर सकते हैं:

String.prototype.bool = function() {
    return strToBool(this);
};

alert("true".bool());

उन लोगों के लिए (टिप्पणियां देखें) जो इसे प्राप्त करने के लिए स्ट्रिंग ऑब्जेक्ट का विस्तार करना चाहते हैं लेकिन गणना करने योग्य होने के बारे में चिंतित हैं और अन्य कोड के साथ टकराव के बारे में चिंतित हैं जो स्ट्रिंग ऑब्जेक्ट का विस्तार करता है:

Object.defineProperty(String.prototype, "com_example_bool", {
    get : function() {
        return (/^(true|1)$/i).test(this);
    }
});
alert("true".com_example_bool);

(कोर्स के पुराने ब्राउज़रों में काम नहीं करेगा और ओपेरा, क्रोम, सफारी और IE सच दिखाते हुए फ़ायरफ़ॉक्स दिखाता है। बग 720760 )

Comments

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

— शैडो २५३१

@DTrejo @Szymon मैं असहमत हूं। यह ठीक उसी तरह है जिस तरह से प्रोटोटाइप को ओवरलोड करने के लिए होता है। यदि आप इसके टूटने (खराब) कोड से डरते हैं, जो for..in पर निर्भर है, तो एन्यूमरेशन से गुण छिपाने के तरीके हैं। देख लो Object.defineProperty।

— devios1

का पालन करना मैं इसे कहेंगेparseBool

— guzart

बुलियन पार्सिंग स्ट्रिंग क्लास में नहीं होता है .. आप किसी भी राशि के पार्सर्स और वहां रूपांतरण के साथ समाप्त हो जाएंगे। -1 आम तौर पर प्रोटोटाइप बदलने के लिए। -1 समाधान जो क्रॉस-ब्राउज़र काम नहीं करता है। -1 खराब डिजाइन के लिए।

— थॉमस डब्ल्यू

यहां सभी उत्तरों की तुलना की गई है। stackoverflow.com/a/28588344/2824333

— sospedra

Answer 7

लकड़ी-आँख सावधान। 500+ upvotes के साथ शीर्ष उत्तर को लागू करने के बाद परिणाम देखने के बाद, मैं कुछ ऐसा पोस्ट करने के लिए बाध्य महसूस करता हूं जो वास्तव में उपयोगी है:

आइए सबसे कम, लेकिन बहुत सख्त तरीके से शुरू करें:

var str = "true";
var mybool = JSON.parse(str);

और एक उचित, अधिक सहिष्णु तरीके से समाप्त करें:

var parseBool = function(str) 
{
    // console.log(typeof str);
    // strict: JSON.parse(str)

    if(str == null)
        return false;

    if (typeof str === 'boolean')
    {
        return (str === true);
    } 

    if(typeof str === 'string')
    {
        if(str == "")
            return false;

        str = str.replace(/^\s+|\s+$/g, '');
        if(str.toLowerCase() == 'true' || str.toLowerCase() == 'yes')
            return true;

        str = str.replace(/,/g, '.');
        str = str.replace(/^\s*\-\s*/g, '-');
    }

    // var isNum = string.match(/^[0-9]+$/) != null;
    // var isNum = /^\d+$/.test(str);
    if(!isNaN(str))
        return (parseFloat(str) != 0);

    return false;
}

परिक्षण:

var array_1 = new Array(true, 1, "1",-1, "-1", " - 1", "true", "TrUe", "  true  ", "  TrUe", 1/0, "1.5", "1,5", 1.5, 5, -3, -0.1, 0.1, " - 0.1", Infinity, "Infinity", -Infinity, "-Infinity"," - Infinity", " yEs");

var array_2 = new Array(null, "", false, "false", "   false   ", " f alse", "FaLsE", 0, "00", "1/0", 0.0, "0.0", "0,0", "100a", "1 00", " 0 ", 0.0, "0.0", -0.0, "-0.0", " -1a ", "abc");


for(var i =0; i < array_1.length;++i){ console.log("array_1["+i+"] ("+array_1[i]+"): " + parseBool(array_1[i]));}

for(var i =0; i < array_2.length;++i){ console.log("array_2["+i+"] ("+array_2[i]+"): " + parseBool(array_2[i]));}

for(var i =0; i < array_1.length;++i){ console.log(parseBool(array_1[i]));}
for(var i =0; i < array_2.length;++i){ console.log(parseBool(array_2[i]));}

Comments

बस याद रखें कि यदि आप पहली विधि का उपयोग करते हैं तो पुराने ब्राउज़र को JSON पॉलीफ़िल की आवश्यकता हो सकती है।

— DRaehal

कितनी तेजी से "झूठी" स्ट्रिंग के falseसाथ बूलियन मान डालना है JSON.parse? सीपीयू के संदर्भ में, मेमोरी प्रदर्शन

— ग्रीन

क्या यह आसान नहीं होगा कि अगर (str) {...} के साथ शुरू किया जाए तो पहले से ही गलत है? और इस शर्त के अंदर, अगर आपको सच लौटने के बारे में चिंता करनी है, क्योंकि आप पहले से ही झूठे के साथ अंत करते हैं!

— लारोफाइड

ध्यान रखें कि आप (["सच", "हाँ", "1") के साथ कई स्ट्रिंग परीक्षणों को छोटा कर सकते हैं। indexOf (str.toLowerCase () ट्रिम ())! = -1) और एक कमबैक का उपयोग करें। बूलियन (str) 'नल' जैसी चीजों को कवर करने के लिए

— स्कॉट

Answer 8

मुझे लगा कि @Steven का जवाब सबसे अच्छा था, और आने वाले मूल्य सिर्फ एक स्ट्रिंग की तुलना में बहुत अधिक मामलों का ख्याल रखा। मैं इसे थोड़ा विस्तार देना चाहता था और निम्नलिखित की पेशकश करता था:

function isTrue(value){
    if (typeof(value) === 'string'){
        value = value.trim().toLowerCase();
    }
    switch(value){
        case true:
        case "true":
        case 1:
        case "1":
        case "on":
        case "yes":
            return true;
        default: 
            return false;
    }
}

falseयदि आप पहले से ही उन सभी trueमामलों को जानते हैं जिनके लिए आपको हिसाब देना होगा, तो सभी मामलों को कवर करना आवश्यक नहीं है । आप इस विधि में कुछ भी पारित कर सकते हैं जो trueमूल्य के लिए पारित कर सकते हैं (या दूसरों को जोड़ सकते हैं, यह बहुत सीधा है), और बाकी सब पर विचार किया जाएगाfalse

Comments

मैं इसे एक का उपयोग करता हूं क्योंकि यह XML / HTML एलिमेंटनोड्स से प्राप्त होने वाली चीजों को कवर करता हैautocomplete="on"

— jk

मैं .trimCase () से पहले .trim () जोड़ूंगा

— लुइस लोबो

Answer 9

JSON पार्स के साथ सार्वभौमिक समाधान:

function getBool(val) {
    return !!JSON.parse(String(val).toLowerCase());
}

getBool("1"); //true
getBool("0"); //false
getBool("true"); //true
getBool("false"); //false
getBool("TRUE"); //true
getBool("FALSE"); //false

अद्यतन (बिना JSON):

function getBool(val){ 
    var num = +val;
    return !isNaN(num) ? !!num : !!String(val).toLowerCase().replace(!!0,'');
}

मैंने इसका परीक्षण करने के लिए फिडेल भी बनाया है। http://jsfiddle.net/remunda/2GRhG/

Comments

'JSON के बिना' संस्करण में कुछ दोष हैं: val = "0"; कंसोल.लॉग (!! (+ वैल || स्ट्रिंग (वैल) .toLowerCase) ()। रिप्लेस (!! 0, ''))। सच पैदा करता है

— एटिने

getBool(undefined)मूल JSON संस्करण का उपयोग करते समय क्रैश हो जाएगा और दूसरे संस्करण के लिए सही वापस आ जाएगा। यहाँ एक 3 संस्करण है जो गलत रिटर्न करता है: फ़ंक्शन getBool (वैल) {var num; रिटर्न वैल! = null && ((! isna (num = + val)! !! num: !! स्ट्रिंग (वैल) .toLowerCase ()। प्रतिस्थापित करें (!! 0, ''))। }

— रॉन मार्टिनेज

Answer 10

आपका समाधान ठीक है।

का उपयोग ===करना इस मामले में सिर्फ मूर्खतापूर्ण होगा, क्योंकि क्षेत्र की valueइच्छा हमेशा एक होगी String।

Comments

आपको क्यों लगता है कि इसका इस्तेमाल करना मूर्खतापूर्ण होगा ===? यदि दोनों प्रकार के स्ट्रिंग्स हैं तो प्रदर्शन के मामले में यह बिल्कुल समान होगा। वैसे भी, मैं उपयोग के ===बाद से मैं हमेशा के उपयोग से बचें ==और !=। औचित्य: stackoverflow.com/questions/359494/…

— Mariano Desanze

चूँकि valueहमेशा stringन तो कोई मूर्ख होगा ==और न ही ===मूर्ख। दोनों ही इस काम के लिए सही उपकरण हैं। वे केवल भिन्न होते हैं जब प्रकार समान नहीं होते हैं । उस मामले में, तुलना के पहले एक जटिल प्रकार के जबरदस्ती एल्गोरिथ्म को निष्पादित करते समय ===बस वापस आ जाता है। false==

— रॉबर्ट

Answer 11

var falsy = /^(?:f(?:alse)?|no?|0+)$/i;
Boolean.parse = function(val) { 
    return !falsy.test(val) && !!val;
};

यह रिटर्न falseहर falsy मूल्य के लिए और trueके लिए छोड़कर हर truthy मूल्य के लिए 'false', 'f', 'no', 'n', और '0'(केस-संवेदी)।

// False
Boolean.parse(false);
Boolean.parse('false');
Boolean.parse('False');
Boolean.parse('FALSE');
Boolean.parse('f');
Boolean.parse('F');
Boolean.parse('no');
Boolean.parse('No');
Boolean.parse('NO');
Boolean.parse('n');
Boolean.parse('N');
Boolean.parse('0');
Boolean.parse('');
Boolean.parse(0);
Boolean.parse(null);
Boolean.parse(undefined);
Boolean.parse(NaN);
Boolean.parse();

//True
Boolean.parse(true);
Boolean.parse('true');
Boolean.parse('True');
Boolean.parse('t');
Boolean.parse('yes');
Boolean.parse('YES');
Boolean.parse('y');
Boolean.parse('1');
Boolean.parse('foo');
Boolean.parse({});
Boolean.parse(1);
Boolean.parse(-1);
Boolean.parse(new Date());

Answer 12

बूलियन ऑब्जेक्ट में 'पार्स' विधि नहीं है। Boolean('false')सच है, ताकि काम नहीं करेगा। !!'false'यह भी रिटर्न true, ताकि काम भी नहीं करेगा।

आप स्ट्रिंग चाहते हैं 'true'बूलियन वापस जाने के लिए trueऔर स्ट्रिंग 'false'वापसी बूलियन के लिए falseहै, तो सबसे आसान समाधान के उपयोग करने के लिए है eval()। eval('true')सच लौटाता है और eval('false')झूठा लौटता है। eval()हालांकि उपयोग करते समय प्रदर्शन के निहितार्थ को ध्यान में रखें ।

Comments

यह समझने के लिए कि क्या "गलत" (या सही) eval के साथ है - javascriptweblog.wordpress.com/2010/04/19/how-evil-is-eval जैसे लेख देखें या 'जावास्क्रिप्ट विकास मैलवेयर' के लिए

— स्टैकओवरफ़्लो पर खोजें

मैं सहमत हूं कि var isTrueSet = (myValue === 'true');सबसे अच्छा जवाब है।

— 30

मुझे यह पसंद है कि यह संक्षिप्त है। लेकिन यह मूल मामले के लिए शानदार ढंग से विफल रहता है eval('TRUE'); एक बार फिर साबित करना, कि eval()बुराई है।

— स्नोमैन

@Area 51 डिटेक्टिव फिक्शन, उसी अंदाज में, JSON.parse('TRUE')नीचे से जवाब भी शानदार तरीके से फेल हो जाता है। जावास्क्रिप्ट में त्रुटि की स्थिति (या किसी भी भाषा, उस मामले के लिए) को लागू करना काफी आसान है। इस पर ध्यान देने के लिए, आपको पहले स्ट्रिंग को सामान्य करना चाहिए, उदाहरण के लिए,var myValue = document.myForm.IS_TRUE.value.toLowerCase(); var isTrueSet = (myValue==='true' || myValue==='false') ? eval(myValue) : false;

— thdoan

@ 10basetom: काफी सही। आपको .toLowerCase()जवाब में शामिल होना चाहिए मेरी बात है। मैं कुछ भी जबरदस्ती करने की कोशिश नहीं कर रहा हूं। Uppercase TRUEकई UI विजेट्स द्वारा लौटाया जाने वाला एक सामान्य पर्याप्त मूल्य है।

— स्नोमैन

Answer 13

मैं निम्नलिखित का उपयोग करता हूं:

function parseBool(b) {
    return !(/^(false|0)$/i).test(b) && !!b;
}

यह फ़ंक्शन स्ट्रिंग्स "झूठे" (असंवेदनशील) और "0" के अपवाद के साथ सामान्य बूलियन जबरदस्ती करता है।

Answer 14

बहुत सारे उत्तर हैं और इनमें से एक को चुनना कठिन है। मेरे मामले में, मैं चयन करते समय प्रदर्शन को प्राथमिकता देता हूं, इसलिए मैं यह jsPerf बनाता हूं कि मुझे आशा है कि यहां कुछ प्रकाश फेंक सकते हैं।

परिणामों का संक्षिप्त विवरण (उच्चतर बेहतर):

1. सशर्त कथन : 2,826,922
2. बूल ऑब्जेक्ट पर स्विच केस : 2,825,469
3. JSON पर कास्टिंग : 1,867,774
4. !! रूपांतरण : 805,322
5. स्ट्रिंग का प्रोटोटाइप : 713,637

वे संबंधित उत्तर से जुड़े हैं जहां आप प्रत्येक के बारे में अधिक जानकारी (पेशेवरों और विपक्ष) को पा सकते हैं; टिप्पणियों में विशेष रूप से।

Comments

jsPerf परीक्षण देखने की कोशिश करते समय "कुछ गलत हुआ"

— स्पॉटमाहन

Answer 15

यह स्वीकार किए गए उत्तर से लिया गया है, लेकिन वास्तव में इसका बहुत कमजोर बिंदु है, और मैं हैरान हूं कि यह कैसे मिला है कि यह ऊपर की ओर जाता है, इसके साथ समस्या यह है कि आपको स्ट्रिंग के मामले पर विचार करना होगा क्योंकि यह मामला संवेदनशील है

var isTrueSet = (myValue.toLowerCase() === 'true');

Answer 16

Boolean.parse = function (str) {
  switch (str.toLowerCase ()) {
    case "true":
      return true;
    case "false":
      return false;
    default:
      throw new Error ("Boolean.parse: Cannot convert string to boolean.");
  }
};

Comments

आप "सही" के बजाय true.toString (उपयोग कर सकते हैं) और भी अधिक साफ :-) होने के लिए

— tillda

ग्लोबल्स को न बदलें, अपने परिवर्तनों को अलग-थलग रखने की कोशिश करें, हो सकता है कि function parseBooleanइसके बजाय एक नया निर्माण करें

— स्टील ब्रेन

Answer 17

जिस अभिव्यक्ति की आपको तलाश है, वह है

/^true$/i.test(myValue)

जैसे की

var isTrueSet = /^true$/i.test(myValue);

यह myValueएक नियमित अभिव्यक्ति, केस-असंवेदनशील के खिलाफ परीक्षण करता है, और प्रोटोटाइप को संशोधित नहीं करता है।

उदाहरण:

/^true$/i.test("true"); // true
/^true$/i.test("TRUE"); // true
/^true$/i.test("tRuE"); // true
/^true$/i.test(" tRuE"); // false (notice the space at the beginning)
/^true$/i.test("untrue"); // false (some other solutions here will incorrectly return true
/^true$/i.test("false");// returns false
/^true$/i.test("xyz");  // returns false

Answer 18

दोनों स्ट्रिंग ("सच", "झूठे") और बूलियन को बूलियन में बदलने के लिए

('' + flag) === "true"

कहां flagहो सकता है

 var flag = true
 var flag = "true"
 var flag = false
 var flag = "false"

Answer 19

पहले से ही बहुत सारे उत्तर उपलब्ध हैं। लेकिन निम्नलिखित कुछ परिदृश्यों में उपयोगी हो सकता है।

// One can specify all values against which you consider truthy
var TRUTHY_VALUES = [true, 'true', 1];

function getBoolean(a) {
    return TRUTHY_VALUES.some(function(t) {
        return t === a;
    });
}

यह उपयोगी हो सकता है जहां गैर-बूलियन मूल्यों के साथ एक उदाहरण है।

getBoolean('aa'); // false
getBoolean(false); //false
getBoolean('false'); //false

getBoolean('true'); // true
getBoolean(true); // true
getBoolean(1); // true

Answer 20

मैं इस एक का उपयोग कर रहा हूँ

String.prototype.maybeBool = function(){

    if ( ["yes", "true", "1", "on"].indexOf( this.toLowerCase() ) !== -1 ) return true;
    if ( ["no", "false", "0", "off"].indexOf( this.toLowerCase() ) !== -1 ) return false;

    return this;

}

"on".maybeBool(); //returns true;
"off".maybeBool(); //returns false;
"I like js".maybeBool(); //returns "I like js"

Comments

यह अच्छा है, लेकिन केवल स्ट्रिंग प्रकार के साथ काम करता है। कल्पना कीजिए कि इस जरूरत का उपयोग एक चर द्वारा किया जा सकता है जो शायद है "true"या true। यदि दूसरा आता है, तो यह काम नहीं करेगा। क्या document.prototypeहम इसे जहाँ चाहें उपयोग करना संभव है?

— MarceloBarbosa

यह सुरुचिपूर्ण दिखता है। अच्छा काम! हालाँकि, मैंने देखा कि बड़े जेएस ऐप्स (जिसमें यूनिट टेस्टिंग की भी ज़रूरत होती है) में मूल प्रोटोटाइप को ओवरलोड करने के परिणामस्वरूप कुछ अनपेक्षित व्यवहार हो सकता है (जैसे, जब आप एक सरणी के माध्यम से "के लिए" के साथ पुनरावृति करना चाहते हैं, जिसमें प्रोटोटाइप ओवरलोड होता है, तो आपको मिलेगा) कुछ गुण जो आप सामान्य रूप से उम्मीद नहीं करेंगे)। आपको चेतावनी दी गई है। ;)

— cassi.lup

तुम्हारा एक प्रकार है जो बूलियन को भी स्वीकार करता है फ़ंक्शन StringOrElse2Bool (sob) {if (टाइपोफ़ सोब === "स्ट्रिंग") {वापसी ["नहीं", "झूठा", "0", "1%"। indexOf (sob.toLowerCase) ())! == -1? सच्चा झूठा; } और {वापसी !!

— sob

Answer 21

आप कुछ इस तरह की कोशिश क्यों नहीं करते

Boolean(JSON.parse((yourString.toString()).toLowerCase()));

यह एक त्रुटि वापस कर देगा जब मामले की परवाह किए बिना सही या गलत के बजाय कुछ अन्य पाठ दिया जाता है और यह संख्याओं को भी कैप्चर करेगा

// 0-> false
// any other number -> true

Answer 22

यह फ़ंक्शन स्ट्रिंग के साथ-साथ बूलियन सच / गलत को भी संभाल सकता है।

function stringToBoolean(val){
    var a = {
        'true':true,
        'false':false
    };
    return a[val];
}

नीचे प्रदर्शन:

function stringToBoolean(val) {
  var a = {
    'true': true,
    'false': false
  };
  return a[val];
}

console.log(stringToBoolean("true"));

console.log(typeof(stringToBoolean("true")));

console.log(stringToBoolean("false"));

console.log(typeof(stringToBoolean("false")));

console.log(stringToBoolean(true));

console.log(typeof(stringToBoolean(true)));

console.log(stringToBoolean(false));

console.log(typeof(stringToBoolean(false)));

console.log("=============================================");
// what if value was undefined? 
console.log("undefined result:  " + stringToBoolean(undefined));
console.log("type of undefined result:  " + typeof(stringToBoolean(undefined)));
console.log("=============================================");
// what if value was an unrelated string?
console.log("unrelated string result:  " + stringToBoolean("hello world"));
console.log("type of unrelated string result:  " + typeof(stringToBoolean(undefined)));

Answer 23

सबसे आसान तरीका नीचे हाथ करें (आप स्ट्रिंग को 'सही' या 'गलत' मानेंगे) है:

var z = 'true';
var y = 'false';
var b = (z === 'true'); // will evaluate to true
var c = (y === 'true'); // will evaluate to false

इस प्रकार के रूपांतरणों के लिए हमेशा == ऑपरेटर के बजाय === ऑपरेटर का उपयोग करें!

Comments

आप किस रूपांतरण की बात कर रहे थे? :-)

— YMMD

जब जावास्क्रिप्ट में स्ट्रिंग की तुलना करते हैं तो रूपांतरण का उपयोग नहीं करने पर == या === ऑपरेटरों का उपयोग करने के बीच कोई अंतर नहीं होता है। यहां आप स्ट्रिंग्स की तुलना कर रहे हैं, इसलिए किसी भी प्रकार के रूपांतरण नहीं हैं। देखें stackoverflow.com/questions/359494/...

— ars265

Answer 24

@ Shadow2531 की तरह, आप सीधे इसे परिवर्तित नहीं कर सकते। मैं यह भी सुझाव दूंगा कि आप "सत्य" और "असत्य" के अलावा स्ट्रिंग इनपुटों पर विचार करें जो कि 'सत्य' और 'गलत' हैं यदि आपका कोड दूसरों द्वारा पुन: उपयोग / उपयोग किया जा रहा है। यही है वह जो मेरे द्वारा उपयोग किया जाता है:

function parseBoolean(string) {
  switch (String(string).toLowerCase()) {
    case "true":
    case "1":
    case "yes":
    case "y":
      return true;
    case "false":
    case "0":
    case "no":
    case "n":
      return false;
    default:
      //you could throw an error, but 'undefined' seems a more logical reply
      return undefined;
  }
}

Answer 25

आपको अपने चयनों के मूल्य और उस मूल्य के प्रतिनिधित्व को अलग करने की आवश्यकता है।

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

दूसरे शब्दों में, हां, आपको स्ट्रिंग के मूल्य पर निर्भर होने की आवश्यकता है। :-)

Answer 26

मेरा यह प्रश्न है कि इसका उद्देश्य तीन उद्देश्यों को पूरा करना है:

• सत्य और असत्य मूल्यों के लिए सत्य / असत्य पर लौटें, लेकिन कई स्ट्रिंग मानों के लिए भी सत्य / असत्य को लौटाएं जो सत्य या गलत होंगे यदि वे तार के बजाय बूलियन थे।
• दूसरा, एक लचीला इंटरफ़ेस प्रदान करें ताकि निर्दिष्ट लोगों के अलावा अन्य मान विफल न हों, बल्कि एक डिफ़ॉल्ट मान लौटाएं
• तीसरा, जितना संभव हो उतना कम कोड के साथ यह सब करें।

JSON का उपयोग करने में समस्या यह है कि यह जावास्क्रिप्ट त्रुटि के कारण विफल हो जाता है। यह समाधान लचीला नहीं है (हालांकि यह 1 और 3 को संतुष्ट करता है):

JSON.parse("FALSE") // fails

यह समाधान पर्याप्त नहीं है:

if(value === "TRUE" || value === "yes" || ...) { return true; }

मैं Typecast.js के लिए इस सटीक समस्या को हल करने पर काम कर रहा हूं । और तीनों उद्देश्यों का सबसे अच्छा समाधान यह है:

return /^true$/i.test(v);

यह कई मामलों के लिए काम करता है, तब विफल नहीं होता है जब {} जैसे मूल्यों को पारित किया जाता है, और बहुत संक्षिप्त होता है। इसके अलावा, यह अपरिभाषित या किसी त्रुटि को फेंकने के बजाय डिफ़ॉल्ट मान के रूप में गलत है, जो शिथिल टाइप के जावास्क्रिप्ट विकास में अधिक उपयोगी है। ब्रावो ने जो अन्य उत्तर सुझाए थे!

Comments

बस अपने उद्देश्यों पर वापस जाने के लिए, आपके तीसरे और सबसे अच्छे समाधान के साथ एकमात्र समस्या यह है कि यह उद्देश्य # 1 को पूरा नहीं करता है - यह केवल के मूल्य के लिए सही लौटेगा 'true', लेकिन किसी भी सत्य इनपुट के लिए नहीं। उद्देश्य # 1 को पूरा करने के लिए, यह केवल समाधान # 2 की तुलना में थोड़ा अधिक संक्षिप्त है, और बहुत कम पठनीय है।

— JMTyler

return /^(true|yes|1|t|y)$/i.test(str);

— केविन बाउचर

Answer 27

मुझे थोड़ी देर हो गई है, लेकिन मुझे ऐसा करने के लिए थोड़ा स्निपेट है, यह अनिवार्य रूप से जेस्क्रिप्शंस ट्रूथी / फाल्सी / गंदी -नेस के सभी को बनाए रखता है लेकिन इसमें शामिल है"false" झूठे के लिए एक स्वीकार्य मूल्य के रूप में ।

मैं इस विधि का उल्लेख करने के लिए पसंद करता हूं क्योंकि यह कोड पार्स करने के लिए एक 3 पार्टी पर भरोसा नहीं करता है (यानी: eval / JSON.parse), जो मेरे दिमाग में ओवरकिल है, यह एक उपयोगिता फ़ंक्शन और रखरखाव की आवश्यकता नहीं है अन्य truthey / फसे सम्मेलनों।

var value = "false";
var result = (value == "false") != Boolean(value);

// value = "true"  => result = true
// value = "false" => result = false
// value = true    => result = true
// value = false   => result = false
// value = null    => result = false
// value = []      => result = true
// etc..

Answer 28

एक और समाधान। jsFiddle

var toBoolean = function(value) {
    var strValue = String(value).toLowerCase();
    strValue = ((!isNaN(strValue) && strValue !== '0') &&
        strValue !== '' &&
        strValue !== 'null' &&
        strValue !== 'undefined') ? '1' : strValue;
    return strValue === 'true' || strValue === '1' ? true : false
};

परीक्षण के मामले नोड में चलते हैं

> toBoolean(true)
true
> toBoolean(false)
false
> toBoolean(undefined)
false
> toBoolean(null)
false
> toBoolean('true')
true
> toBoolean('True')
true
> toBoolean('False')
false
> toBoolean('false')
false
> toBoolean('0')
false
> toBoolean('1')
true
> toBoolean('100')
true
> 

Answer 29

पवित्र परमेश्वर इनमें से कुछ उत्तर सिर्फ जंगली हैं। मुझे जेएस से प्यार है और इसके कई तरीके हैं जो एक त्वचा को चमकाते हैं।

मेरी प्राथमिकता, जिसे मैं पहले से ही नहीं देख कर हैरान था:

testVar = testVar.toString().match(/^(true|[1-9][0-9]*|[0-9]*[1-9]+|yes)$/i) ? true : false;

Answer 30

function parseBool(value) {
    if (typeof value === "boolean") return value;

    if (typeof value === "number") {
        return value === 1 ? true : value === 0 ? false : undefined;
    }

    if (typeof value != "string") return undefined;

    return value.toLowerCase() === 'true' ? true : false;
}

Comments

एक स्ट्रिंग के लिए, मैं व्यक्तिगत रूप से true"सच" के लिए वापस आ गया होगा जैसे आपने किया था, लेकिन falseकेवल "झूठे" के लिए, और undefinedअन्यथा। पूर्णांक मामले के साथ आपने पहले जो बनाया था, उसे छाँटें।

— पियरे-एड्रियन ब्यूसॉन