बूलियन परिणाम को संख्या / पूर्णांक में बदलें

Question

मेरे पास एक चर है जो स्टोर करता है falseया true, लेकिन मुझे क्रमशः 0या 1इसकी आवश्यकता है। मैं यह कैसे कर सकता हूँ?

Comments

यहां कुछ प्रदान की गई तकनीकों की प्रदर्शन तुलना है: jsperf.com/conversion-from-boolean-to-number ।

— सैम

Node.JS उपयोगकर्ता इसका उपयोग करना चाहेंगे bool === true ? 1 : 0, क्योंकि यह V8 में सबसे तेज़ है।

— किक्स - मोनासा ने

या बसbool ? 1 : 0;

— अतरहास

Answer 1

जावास्क्रिप्ट में एक टर्नरी ऑपरेटर होता है जिसका आप उपयोग कर सकते हैं:

var i = result ? 1 : 0;

Comments

सबसे बढ़िया उत्तर। क्यों? यह सत्यता पर काम करता है जो अधिक सामान्य है और किसी भी प्रकार (स्ट्रिंग, संख्या, वगैरह) को स्वीकार करता है। एकात्मक उत्तर वास्तव में चतुर है, लेकिन अगर मैं इसे एक स्ट्रिंग पास करता हूं तो यह वापस आ जाता है NaN। इसलिए यदि आप L33T चाहते हैं और इनपुट की गारंटी देते हैं, तो यूरिया पर जाएं, अन्यथा टर्नरी + ट्रूथी परीक्षण सबसे अच्छा है।

— गिडिबल

Answer 2

यूनिरी +ऑपरेटर का उपयोग करें , जो अपने ऑपरेंड को एक संख्या में परिवर्तित करता है।

+ true; // 1
+ false; // 0

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

Comments

अल्बेट कूल (मैंने कभी इस बारे में नहीं सोचा था), यह अविश्वसनीय रूप से धीमा है (क्रोम में 97% धीमा, सटीक होना)। सावधान रहने की जरूरत!

— Qix - मोनासा ने

इस संशोधन की जाँच करें । Number()और भी धीमा है।

— क्यूक्स - मोनासा ने 16:17

ऐसा प्रतीत होता bool === true ? 1 : 0है कि यह सबसे तेज़ है, जिसमें से एक दूसरा पास है bool | 0।

— Qix - मोनासा

गुणा करना (उदाहरण के लिए 3 * गलत) कितना गलत लगता है, लेकिन यह काम करता है। :) धन्यवाद!

— Mattsoave

@DerkJanSpeelman तथ्य यह है कि कुछ टाइपस्क्रिप्ट में अनुमति नहीं है इसका मतलब यह नहीं है कि आप इसे जावास्क्रिप्ट में नहीं करना चाहिए। वे अलग-अलग (यद्यपि संबंधित) भाषाएं हैं।

— lonesomeday

Answer 3

Imho सबसे अच्छा समाधान है:

fooBar | 0

इसका उपयोग पूर्णांक प्रकार को बाध्य करने के लिए asm.js में किया जाता है।

Comments

सबसे तेज में से एक; +1।

— Qix - मोनासा

अच्छा है। इसके अलावा आप "बूलियन ^ 0" का उपयोग कर सकते हैं। या XOR काम करता है।

— F8ER

यह एक 1पूर्णांक नहीं लौटाएगा यदि fooBar नहीं है?

— ईएसआर

Answer 4

मैं नंबर फ़ंक्शन का उपयोग करना पसंद करता हूं । यह एक वस्तु लेता है और इसे एक संख्या में परिवर्तित करता है।

उदाहरण:

var myFalseBool = false;
var myTrueBool = true;

var myFalseInt = Number(myFalseBool);
console.log(myFalseInt === 0);

var myTrueInt = Number(myTrueBool);
console.log(myTrueInt === 1);

आप इसे jsFiddle में परीक्षण कर सकते हैं ।

Comments

यह अब तक का सबसे अच्छा जवाब है। बिल्कुल नीचे। केवल "यह एक वस्तु लेता है" सही नहीं है।

— रुडी

Mdn का लिंक w3schools (eeek!) से अधिक बेहतर है: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— Olivvv

मुझे लगता है कि यह सबसे अच्छा तरीका है क्योंकि इसे पढ़ना और इरादा प्रकट करना आसान है।

— सैम

यह सबसे धीमा भी है ।

— Qix - मोनासा ने 16

Answer 5

मैंने सभी सुझाए गए उत्तरों की एक JSperf तुलना की।

TL, DR - सभी वर्तमान ब्राउज़रों के लिए सबसे अच्छा विकल्प है:

val | 0;

।

अपडेट करें:

ऐसा लगता है कि इन दिनों वे सभी बहुत समान हैं, सिवाय इसके कि Number()फ़ंक्शन सबसे धीमा है, जबकि सबसे अच्छा है val === true ? 1 : 0;।

Comments

मजे की बात यह है कि मैक्रो 10.13.3 पर क्रोम 64.0.3282 में अब टर्नरी सबसे तेज है।

— 2540625

उस समय यह सबसे तेज विकल्प होगा। यह सबसे अच्छा विकल्प होने से अलग है।

— मिकमेकाना

Answer 6

ऐसा करने का टाइप तरीका होगा:

Number(true) // 1
Number(false) // 0

Comments

अंत में कुछ सभ्य जवाब। धन्यवाद।

— एरिक कैम्पोबाडल

Answer 7

मैं आज ही इस शॉर्टकट में आया हूं।

~~ (सही)

~~ (गलत)

मैं जितना समझा सकता हूं उससे कहीं ज्यादा होशियार लोग:

http://james.padolsey.com/javascript/double-bitwise-not/

Comments

दिलचस्प। मैंने आज कुछ नया सीखा। मैं इस तकनीक का उपयोग किसी भी परियोजना में नहीं करूंगा, हालांकि, भविष्य में मुझे या टीम के साथियों को भ्रमित करने की क्षमता है।

— नवंबर को

हैकी जेएस मेरा फेव है। गंभीरता से, +1

— टॉड

Answer 8

जब जावास्क्रिप्ट एक संख्या मान की उम्मीद कर रहा है, लेकिन एक बूलियन प्राप्त करता है इसके बजाय यह बूलियन को एक संख्या में परिवर्तित करता है: सही और गलत क्रमशः 1 और 0 में परिवर्तित होता है। तो आप इसका फायदा उठा सकते हैं;

var t = true;
var f = false;

console.log(t*1); // t*1 === 1
console.log(f*1); // f*1 === 0 

console.log(+t); // 0+t === 1 or shortened to +t === 1
console.log(+f); //0+f === 0 or shortened to +f === 0

आगे पढ़ने के प्रकार जावास्क्रिप्ट के लिए निश्चित गाइड के अध्याय 3.8 अध्याय।

Answer 9

अपर +संचालक इसका ध्यान रखेंगे:

var test = true;
// +test === 1
test = false;
// +test === 0

आप स्वाभाविक रूप से इसे स्टोर करने से पहले सर्वर पर इसे जांचना चाहते हैं, ताकि यह वैसे भी ऐसा करने के लिए अधिक समझदार जगह हो।

Comments

मैंने टिप्पणियों को बदल दिया है ===, क्योंकि true == 1"स्पष्ट रूपांतरण :-)" के true === 1बजाय यह भी सही है कि यह गलत है।

— xanatos

Answer 10

मैं इस मुद्दे से निपट रहा था कुछ कोड में मैं लिख रहा था। मेरा समाधान एक बिटवाइज़ और उपयोग करना था।

var j = bool & 1;

एक निरंतर समस्या से निपटने का एक तेज़ तरीका एक फ़ंक्शन बनाना होगा। यह अन्य लोगों द्वारा अधिक पठनीय है, रखरखाव के स्तर पर समझने के लिए बेहतर है, और कुछ गलत लिखने की क्षमता से छुटकारा दिलाता है।

function toInt( val ) {
    return val & 1;
}

var j = toInt(bool);

संपादित करें - १० सितंबर २०१४

Chrome के ऑपरेटर के समान टर्नरी ऑपरेटर का उपयोग करने वाला कोई भी रूपांतरण किसी कारण से Chrome में तेज़ नहीं है। यह तेज़ क्यों है इसका कोई मतलब नहीं है, लेकिन मुझे लगता है कि यह कुछ निम्न स्तर के अनुकूलन है जो रास्ते में कहीं भी समझ में आता है।

var j = boolValue === true ? 1 : 0;

अपने लिए टेस्ट करें: http://jsperf.com/boolean-int-conversion/2

फ़ायरफ़ॉक्स और इंटरनेट एक्सप्लोरर में, मेरे द्वारा पोस्ट किए गए संस्करण का उपयोग करना आम तौर पर तेज है।

संपादित करें - 14 जुलाई, 2017

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

इसके अलावा, यहाँ एक 'tont' प्रोटोटाइप जोड़ने के लिए एक नई विधि है जिसे ओवरराइट नहीं किया जा सकता है।

Object.defineProperty(Boolean.prototype, "toInt", { value: function()
{
    return this & 1;
}});

Comments

इस पद के लिए मेरे पास दो डाउनवोट हैं। आप यह क्यों नहीं समझाते हैं कि आपने इसे क्यों ठुकरा दिया। अन्यथा यह औचित्य के बिना एक गिरावट है।

— निकोलस आर। ग्रांट

Jsperf के 99 गुना परिणाम सिर्फ आपको समय से पहले अनुकूलन मार्ग का नेतृत्व करते हैं, जब आप उस बदसूरत SQL स्टेटमेंट पर ध्यान केंद्रित किया जाना चाहिए, तो नैनो लूप को बंद कर दें। इस दृष्टिकोण के लिए कुछ अलग तरीके प्रदान करने के लिए धन्यवाद

— RozzA

क्या एसक्यूएल बयान? यहां एक भी क्वेरी नहीं है। यदि आप JSPerf की बात कर रहे हैं, तो मैं इसे किसी और के परीक्षण से लिंक कर रहा था। यह मेरा अपना नहीं है। मैं ईमानदारी से इस के प्रदर्शन के पहलू के बारे में परवाह नहीं है क्योंकि यह एक ऑपरेशन नहीं है। मैंने अपनी खुद की भाषा बनाई जो लगभग जेएस के समान कार्यक्षमता थी और मुझे याद है कि इंट का कास्टिंग एक मूर्खतापूर्ण तेजी से ऑपरेशन था। प्रोटोटाइप चेन चढ़ना नहीं था। यही कारण है कि मैं अभी भी पहले तरीके से यह करने की सिफारिश करूँगा, एक साधारण फ़ंक्शन के साथ जो संकलक द्वारा इनलाइन किया जा सकता है।

— निकोलस आर। ग्रांट

एसक्यूएल बात 'एक सामान्यीकरण twas। अंतर्दृष्टि के लिए धन्यवाद

— RozzA

Answer 11

आप 0 भी जोड़ सकते हैं, शिफ्ट ऑपरेटर या xor का उपयोग कर सकते हैं:

val + 0;
val ^ 0;
val >> 0;
val >>> 0;
val << 0;

इनकी गति भी उतनी ही है जितनी दूसरों के उत्तर की।

Answer 12

मेरे संदर्भ में, रिएक्ट नेटिव जहां मुझे बूलियन से अपारदर्शिता मूल्य मिल रहा है, सबसे आसान तरीका: यूरीरी + ऑपरेटर का उपयोग करें।

+ true; // 1
+ false; // 0

यह बूलियन को संख्या में परिवर्तित करता है;

style={ opacity: +!isFirstStep() }

Answer 13

आप बस बूलियन प्रोटोटाइप को बढ़ाकर ऐसा कर सकते हैं

Boolean.prototype.intval = function(){return ~~this}

यह समझना बहुत आसान नहीं है कि वहाँ क्या चल रहा है इसलिए एक वैकल्पिक संस्करण होगा

Boolean.prototype.intval = function(){return (this == true)?1:0}

किया जा रहा है जो आप की तरह सामान कर सकते हैं

document.write(true.intval());

जब मैं परिस्थितियों को संग्रहीत करने के लिए बूलियन का उपयोग करता हूं तो मैं अक्सर उन्हें बिटफ़िल्ड में परिवर्तित करता हूं जिस स्थिति में मैं प्रोटोटाइप फ़ंक्शन के विस्तारित संस्करण का उपयोग करके समाप्त होता हूं

Boolean.prototype.intval = function(places)
{
 places = ('undefined' == typeof(places))?0:places; 
 return (~~this) << places
}

जिसके साथ आप कर सकते हैं

document.write(true.intval(2))

जो अपने आउटपुट के रूप में 4 का उत्पादन करता है।

Answer 14

let integerVariable = booleanVariable * 1;

Answer 15

प्रयत्न

val*1

let t=true;
let f=false;

console.log(t*1);
console.log(f*1)

Answer 16

मैंने इन सभी उदाहरणों का परीक्षण किया है, मैंने एक बेंचमार्क किया है, और अंत में मैं आपको छोटे को चुनने की सलाह देता हूं, यह प्रदर्शन में प्रभावित नहीं करता है।

उबंटू सर्वर 14.04, नोडज v8.12.0 - 26/10/18 में चलाया गया

    let i = 0;
console.time("TRUE test1")
    i=0;
    for(;i<100000000;i=i+1){
        true ? 1 : 0;
    }
console.timeEnd("TRUE test1")


console.time("FALSE test2")
    i=0;
    for(;i<100000000;i=i+1){
        false ? 1 : 0;
    }
console.timeEnd("FALSE test2")

console.log("----------------------------")

console.time("TRUE test1.1")
    i=0;
    for(;i<100000000;i=i+1){
        true === true ? 1 : 0;
    }
console.timeEnd("TRUE test1.1")


console.time("FALSE test2.1")
    i=0;
    for(;i<100000000;i=i+1){
        false === true ? 1 : 0;
    }
console.timeEnd("FALSE test2.1")

console.log("----------------------------")

console.time("TRUE test3")
    i=0;
    for(;i<100000000;i=i+1){
        true | 0;
    }
console.timeEnd("TRUE test3")

console.time("FALSE test4")
    i=0;
    for(;i<100000000;i=i+1){
        false | 0;
    }
console.timeEnd("FALSE test4")

console.log("----------------------------")

console.time("TRUE test5")
    i=0;
    for(;i<100000000;i=i+1){
        true * 1;
    }
console.timeEnd("TRUE test5")

console.time("FALSE test6")
    i=0;
    for(;i<100000000;i=i+1){
        false * 1;
    }
console.timeEnd("FALSE test6")

console.log("----------------------------")

console.time("TRUE test7")
    i=0;
    for(;i<100000000;i=i+1){
        true & 1;
    }
console.timeEnd("TRUE test7")

console.time("FALSE test8")
    i=0;
    for(;i<100000000;i=i+1){
        false & 1;
    }
console.timeEnd("FALSE test8")

console.log("----------------------------")

console.time("TRUE test9")
    i=0;
    for(;i<100000000;i=i+1){
        +true;
    }
console.timeEnd("TRUE test9")

console.time("FALSE test10")
    i=0;
    for(;i<100000000;i=i+1){
        +false;
    }
console.timeEnd("FALSE test10")

console.log("----------------------------")

console.time("TRUE test9.1")
    i=0;
    for(;i<100000000;i=i+1){
        0+true;
    }
console.timeEnd("TRUE test9.1")

console.time("FALSE test10.1")
    i=0;
    for(;i<100000000;i=i+1){
        0+false;
    }
console.timeEnd("FALSE test10.1")

console.log("----------------------------")

console.time("TRUE test9.2")
    i=0;
    for(;i<100000000;i=i+1){
        -true*-1;
    }
console.timeEnd("TRUE test9.2")

console.time("FALSE test10.2")
    i=0;
    for(;i<100000000;i=i+1){
        -false*-1;
    }
console.timeEnd("FALSE test10.2")

console.log("----------------------------")

console.time("TRUE test9.3")
    i=0;
    for(;i<100000000;i=i+1){
        true-0;
    }
console.timeEnd("TRUE test9.3")

console.time("FALSE test10.3")
    i=0;
    for(;i<100000000;i=i+1){
        false-0;
    }
console.timeEnd("FALSE test10.3")

console.log("----------------------------")

console.time("TRUE test11")
    i=0;
    for(;i<100000000;i=i+1){
        Number(true);
    }
console.timeEnd("TRUE test11")

console.time("FALSE test12")
    i=0;
    for(;i<100000000;i=i+1){
        Number(false);
    }
console.timeEnd("FALSE test12")

console.log("----------------------------")

console.time("TRUE test13")
    i=0;
    for(;i<100000000;i=i+1){
        true + 0;
    }
console.timeEnd("TRUE test13")

console.time("FALSE test14")
    i=0;
    for(;i<100000000;i=i+1){
        false + 0;
    }
console.timeEnd("FALSE test14")

console.log("----------------------------")

console.time("TRUE test15")
    i=0;
    for(;i<100000000;i=i+1){
        true ^ 0;
    }
console.timeEnd("TRUE test15")

console.time("FALSE test16")
    i=0;
    for(;i<100000000;i=i+1){
        false ^ 0;
    }
console.timeEnd("FALSE test16")

console.log("----------------------------")

console.time("TRUE test17")
    i=0;
    for(;i<100000000;i=i+1){
        true ^ 0;
    }
console.timeEnd("TRUE test17")

console.time("FALSE test18")
    i=0;
    for(;i<100000000;i=i+1){
        false ^ 0;
    }
console.timeEnd("FALSE test18")

console.log("----------------------------")

console.time("TRUE test19")
    i=0;
    for(;i<100000000;i=i+1){
        true >> 0;
    }
console.timeEnd("TRUE test19")

console.time("FALSE test20")
    i=0;
    for(;i<100000000;i=i+1){
        false >> 0;
    }
console.timeEnd("FALSE test20")

console.log("----------------------------")

console.time("TRUE test21")
    i=0;
    for(;i<100000000;i=i+1){
        true >>> 0;
    }
console.timeEnd("TRUE test21")

console.time("FALSE test22")
    i=0;
    for(;i<100000000;i=i+1){
        false >>> 0;
    }
console.timeEnd("FALSE test22")

console.log("----------------------------")

console.time("TRUE test23")
    i=0;
    for(;i<100000000;i=i+1){
        true << 0;
    }
console.timeEnd("TRUE test23")

console.time("FALSE test24")
    i=0;
    for(;i<100000000;i=i+1){
        false << 0;
    }
console.timeEnd("FALSE test24")

console.log("----------------------------")

console.time("TRUE test25")
    i=0;
    for(;i<100000000;i=i+1){
        ~~true;
    }
console.timeEnd("TRUE test25")

console.time("FALSE test26")
    i=0;
    for(;i<100000000;i=i+1){
        ~~false;
    }
console.timeEnd("FALSE test26")

console.log("----------------------------")

console.time("TRUE test25.1")
    i=0;
    for(;i<100000000;i=i+1){
        ~true*-1-1;
    }
console.timeEnd("TRUE test25.1")

console.time("FALSE test26.1")
    i=0;
    for(;i<100000000;i=i+1){
        ~false*-1-1;
    }
console.timeEnd("FALSE test26.1")

console.log("----------------------------")

console.time("TRUE test27")
    i=0;
    for(;i<100000000;i=i+1){
        true/1;
    }
console.timeEnd("TRUE test27")

console.time("FALSE test28")
    i=0;
    for(;i<100000000;i=i+1){
        false/1;
    }
console.timeEnd("FALSE test28")

परिणाम

TRUE test1: 93.301ms
FALSE test2: 102.854ms
----------------------------
TRUE test1.1: 118.979ms
FALSE test2.1: 119.061ms
----------------------------
TRUE test3: 97.265ms
FALSE test4: 108.389ms
----------------------------
TRUE test5: 85.854ms
FALSE test6: 87.449ms
----------------------------
TRUE test7: 83.126ms
FALSE test8: 84.992ms
----------------------------
TRUE test9: 99.683ms
FALSE test10: 87.080ms
----------------------------
TRUE test9.1: 85.587ms
FALSE test10.1: 86.050ms
----------------------------
TRUE test9.2: 85.883ms
FALSE test10.2: 89.066ms
----------------------------
TRUE test9.3: 86.722ms
FALSE test10.3: 85.187ms
----------------------------
TRUE test11: 86.245ms
FALSE test12: 85.808ms
----------------------------
TRUE test13: 84.192ms
FALSE test14: 84.173ms
----------------------------
TRUE test15: 81.575ms
FALSE test16: 81.699ms
----------------------------
TRUE test17: 81.979ms
FALSE test18: 81.599ms
----------------------------
TRUE test19: 81.578ms
FALSE test20: 81.452ms
----------------------------
TRUE test21: 115.886ms
FALSE test22: 88.935ms
----------------------------
TRUE test23: 82.077ms
FALSE test24: 81.822ms
----------------------------
TRUE test25: 81.904ms
FALSE test26: 82.371ms
----------------------------
TRUE test25.1: 82.319ms
FALSE test26.1: 96.648ms
----------------------------
TRUE test27: 89.943ms
FALSE test28: 83.646ms

Answer 17

यदि आप पूर्णांक x मान को बदलना चाहते हैं तो 1 से 0 और यदि 0 से 1 का उपयोग कर सकते हैं (x + 1)% 2