दिलचस्प पोस्ट
एंड्रॉइड एनीमेशन ड्रेनेबल और एनीमेशन समाप्त होने पर जानना छवियों को रिसाइज़ करने के लिए g.drawImage () विधि के प्रदर्शन में सुधार कैसे करें वेरिएबल और फ़ंक्शन के नामों के लिए पायथन में नेमिंग सम्मेलन क्या है? संपत्ति निर्देशिका से वेबदृश्य लोड HTML window.onload बनाम $ (दस्तावेज़) .ready () मैं कैसे लंबित इरादे के लिए अद्वितीय अतिरिक्त पारित कर सकता हूं? जब जावास्क्रिप्ट में डबल नॉट (!!) ऑपरेटर का उपयोग करें एंड्रॉइड, एक छवि बनाओ ImageView की छवि के बराबर यूआरएल पर विंडोज बैच फ़ाइल (बीएटी) में एक वेरिएबल को घोषित करना और उपयोग करना gulp कमांड नहीं मिला – गुल स्थापित करने के बाद त्रुटि मैं एक आवेदन में विभिन्न गतिविधियों को लॉन्च करने के लिए कई आइकनों कैसे प्राप्त करूं? Sed के साथ पीछे के स्थान को कैसे निकालना है? इंटरनेट एक्सप्लोरर 9 तालिका कोशिकाओं को ठीक से प्रतिपादित नहीं करता है क्लास में 'स्टैटिक' कीवर्ड क्या करता है? स्ट्रिंग के सेट की एक चर संख्या के चौराहे को कुशलतापूर्वक खोजना

जावास्क्रिप्ट में मैं एक बिटवायर ऑपरेटर का उपयोग कहाँ करूँगा?

मैंने इसे पढ़ा है ( https: //stackoverflow.com/quest … ), इसलिए मुझे पता है कि bitwise ऑपरेटर्स क्या हैं, लेकिन मैं अभी भी स्पष्ट नहीं हूं कि उनका उपयोग कैसे किया जा सकता है … क्या कोई वास्तविक दुनिया प्रदान कर सकता है उदाहरण के लिए जहां जावास्क्रिप्ट में एक बिटवाइस ऑपरेटर उपयोगी होगा?

धन्यवाद।

संपादित करें:

बस jQuery के स्रोत में खुदाई के लिए मैंने कुछ जगहें देखी हैं जहां बिटवाइर्स ऑपरेटर उपयोग किया जाता है, उदाहरण के लिए: (केवल ऑपरेटर)

// Line 2756: event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) )); // Line 2101 var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1; 

वेब के समाधान से एकत्रित समाधान "जावास्क्रिप्ट में मैं एक बिटवायर ऑपरेटर का उपयोग कहाँ करूँगा?"

उदाहरण:

आरजीबी रंग मान प्राप्त करने के लिए हेक्सैडेसिमल मान को पार्स करता है

 var hex = 'ffaadd'; var rgb = parseInt(hex, 16); // rgb is 16755421 var red = (rgb >> 16) & 0xFF; // returns 255 var green = (rgb >> 8) & 0xFF; // 170 var blue = rgb & 0xFF; // 221 

मैं उत्पादन लिपियों में संख्यात्मक रूपांतरण के लिए बिटवार ऑपरेटरों का भारी उपयोग करता हूं, क्योंकि कभी-कभी वे अपने Math या parseInt मुकाबले बहुत तेज हो जाते हैं

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

आप jsperf.com पर कुछ प्रदर्शन चाल ढूंढ सकते हैं ।

जैसा कि आप देख सकते हैं, ब्राउज़रों ने Math.ceil और Math.ceil अनुकूल नहीं किया है, इसलिए मैं भविष्यवाणी करता हूं कि Math.ceil तेजी से और छोटी तरह से काम करने के लिए फायर में भी काम करेगा ।

कुछ तो SO पर पढ़ रहे हैं …


बोनस: शीट के लिए | 0 | 0 : पूर्णांक में कुछ भी कन्वर्ट करने का एक आसान और तेज़ तरीका:

 ( 3|0 ) === 3; // it does not change integers ( 3.3|0 ) === 3; // it casts off the fractional part in fractionalal numbers ( 3.8|0 ) === 3; // it does not round, but exactly casts off the fractional part ( -3.3|0 ) === -3; // including negative fractional numbers ( -3.8|0 ) === -3; // which have Math.floor(-3.3) == Math.floor(-3.8) == -4 ( "3"|0 ) === 3; // strings with numbers are typecast to integers ( "3.8"|0 ) === 3; // during this the fractional part is cast off too ( "-3.8"|0 ) === -3; // including negative fractional numbers ( NaN|0 ) === 0; // NaN is typecast to 0 ( Infinity|0 ) === 0; // the typecast to 0 occurs with the Infinity ( -Infinity|0 ) === 0; // and with -Infinity ( null|0 ) === 0; // and with null, ( (void 0)|0 ) === 0; // and with undefined ( []|0 ) === 0; // and with an empty array ( [3]|0 ) === 3; // but an array with one number is typecast to number ( [-3.8]|0 ) === -3; // including the cast off of the fractional part ( [" -3.8 "]|0 ) === -3; // including the typecast of strings to numbers ( [-3.8, 22]|0 ) === 0 // but an Array with several numbers is typecast to 0 ( {}|0 ) === 0; // an empty object is typecast to 0 ( {'2':'3'}|0 ) === 0; // or a not empty object ( (function(){})|0 ) === 0; // an empty function is typecast to 0 too ( (function(){ return 3;})|0 ) === 0; 

और मेरे लिए कुछ जादू:

 3 | '0px' === 3; 

जावास्क्रिप्ट में, आप Math.floor(n) (यदि n एक सकारात्मक संख्या है) या parseInt(n, 10) (यहां तक ​​कि n नकारात्मक है) के लिए प्रतिस्थापन के रूप में एक डबल बिटwise अस्वीकृति ( ~~n ) का उपयोग कर सकते हैं। n|n और n&n हमेशा ~~n रूप में समान परिणाम उत्पन्न करते हैं।

 var n = Math.PI; n; // 3.141592653589793 Math.floor(n); // 3 parseInt(n, 10); // 3 ~~n; // 3 n|n; // 3 n&n; // 3 // ~~n works as a replacement for parseInt() with negative numbers… ~~(-n); // -3 (-n)|(-n); // -3 (-n)&(-n); // -3 parseInt(-n, 10); // -3 // …although it doesn't replace Math.floor() for negative numbers Math.floor(-n); // -4 

एक एकल बिटwise अस्वीकृति ( ~ ) की गणना -(parseInt(n, 10) + 1) , इसलिए दो बिटwise निगमन वापस आ जाएगी -(-(parseInt(n, 10) + 1) + 1)

यह ध्यान दिया जाना चाहिए कि इन तीन विकल्पों में से, n|n सबसे तेजी से प्रतीत होता है

अद्यतन: यहां अधिक सटीक मानदंड: http://jsperf.com/rounding-numbers-down

(जैसा कि अजीब भाषा की सुविधा पर पोस्ट किया गया है)

एक वास्तविक जीवन उदाहरण? :

^ (बीटवाइस XOR) I/O toggler के रूप में

jsBin उदाहरण

value ^= 1 जैसे value ^= 1 प्रत्येक कॉल को 0, 1, 0, 1 ... के value पर बदल जाएगा 0, 1, 0, 1 ...
अगर हम उस value को एक कंडीशनल ऑपरेटर में कथन के रूप में पास करते हैं (?:) जैसे

 statement ? (if true) : (if false) 

और 0=false, 1=true के बूलियन प्रतिनिधित्व के लिए जाँच 0=false, 1=true हम पाठ, कक्षाएं, शैलियों को बदल सकते हैं …. जो कुछ भी जरूरत है जैसे कि: एक बटन पाठ:

 value ? "Close dropdown" : "Open dropdown"; 

एक तत्व के लिए , एक टॉगल फ़ंक्शन ऐसा दिखाई दे सकता है:

 // USING GLOBAL VARIABLE var tog = 0; var btn = document.getElementById('myButton'); function toggler(){ tog ^= 1; this.innerHTML = tog ? "hide" : "show"; } btn.addEventListener('click', toggler, false); 

कई तत्वों के लिए हम tog वैरिएबल स्टेट को सीधे this में रख सकते हैं – ElementHTML ऑब्जेक्ट जैसे:

 // WITHOUT GLOBAL VARIABLE var btns = document.getElementsByClassName('myButton'); function toggler(){ var tog = this.tog ^= 1; // get/set tog value out of this.tog object this.innerHTML = tog ? "hide" : "show"; } for(var i=0; i<btns .length; i++){ btns[i].addEventListener('click', toggler, false); } 

या, अगर आपको this विचार पसंद नहीं है, तो मानक dataset गुण संपत्ति के लिए जाएं;)

जावास्क्रिप्ट की तरफ देखते हुए (विशेष रूप से नोडजे के साथ जो जेएस के साथ सर्वर साइड प्रोग्रामिंग की अनुमति देता है), जेएस में अधिक जटिल कोड है। यहां कुछ ऐसे उदाहरण दिए गए हैं जहां मैंने बिटवार ऑपरेटर्स का उपयोग किया है:

  • आईपी ​​पता ऑपरेशन:

     //computes the broadcast address based on the mask and a host address broadcast = (ip & mask) | (mask ^ 0xFFFFFFFF) //converts a number to an ip adress sprintf(ip, "%i.%i.%i.%i", ((ip_int >> 24) & 0x000000FF), ((ip_int >> 16) & 0x000000FF), ((ip_int >> 8) & 0x000000FF), ( ip_int & 0x000000FF)); 

नोट: यह सी कोड है, लेकिन जेएस लगभग समान है

  • सीआरसी एल्गोरिदम उन्हें बहुत कुछ का उपयोग करता है

इस पर विकिपीडिया प्रविष्टि देखें

  • स्क्रीन रिज़ॉल्यूशन ऑपरेशन

यह बताने के लिए कि कोई संख्या अजीब है:

 function isOdd(number) { return !!(number & 1); } isOdd(1); // true, 1 is odd isOdd(2); // false, 2 is not odd isOdd(357); // true, 357 is odd 

मॉड्यूलस से तेज़ी से – उपयोग करें, जहां प्रदर्शन वास्तव में मायने रखता है!

बिटवर्ड का उपयोग कैसे करें और डबल बिटवर्ड नहीं करने के कुछ अन्य उदाहरण:

तल ऑपरेशन

 ~~2.5 // 2 ~~2.1 // 2 ~~(-2.5) // -2 

जांचें कि क्या अनुक्रमणिका ओफ़ -1 लौटाता है या नहीं

 var foo = 'abc'; !~foo.indexOf('bar'); // true 

आप उन्हें बूलियन मान फ्लिप करने के लिए उपयोग कर सकते हैं:

 var foo = 1; var bar = 0; alert(foo ^= 1); alert(bar ^= 1); 

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

बिटमैस्क

उदाहरण के लिए, जेएस कार्यक्रमों में व्यापक रूप से उपयोग किया गया।

 var arr = ['abc', 'xyz'] 

लिखने से नाराज

 if (arr.indexOf('abc') > -1) { // 'abc' is in arr } if (arr.indexOf('def') === -1) { // 'def' is not in arr } 

जांचने के लिए कि क्या कोई सरणी के अंदर है?

आप bitwise ऑपरेटर का उपयोग कर सकते हैं जैसे:

 if (~arr.indexOf('abc')) { // 'abc' is in arr } if (! ~arr.indexOf('def')) { // 'def' is not in arr } 

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

मैं उन्हें यूआईटी 16 एरे में बहुआयामी arrays के भंडारण के एक तरीके के रूप में 1 में तीन नंबरों को समतल करने के लिए उपयोग कर रहा हूं। यहां एक voxel खेल का स्निपेट है जिसे मैं विकसित कर रहा हूं:

 function Chunk() { this._blocks = new Uint16Array(32768); this._networkUpdates = []; } Chunk.prototype.getBlock = function(x, y, z) { return this._blocks[y + (x << 5) + (z << 10)]; }; Chunk.prototype.setBlock = function(x, y, z, value) { this._blocks[y + (x << 5) + (z << 10)] = value; this._networkUpdates.push(value + (y << 15) + (x << 20) + (z << 25)); }; Chunk.prototype.getUpdates = function() { return this._networkUpdates; }; Chunk.prototype.processUpdate = function(update) { // this._blocks[Math.floor(update / 65536)] = update % 65536; this._blocks[update >> 16] = update & 65535; }; var chunk = new Chunk(); chunk.setBlock(10, 5, 4); alert(chunk.getBlock(10, 5, 4)); alert(chunk.getUpdates()[0]); 

जब आप हेक्स मूल्यों और बिट्स के साथ काम करते हैं तो वे बहुत उपयोगी होते हैं। चूंकि 4 बिट्स 0 से एफ का प्रतिनिधित्व कर सकते हैं।

1111 = एफ 1111 1111 = एफएफ

Node.js का प्रयोग करते हुए उदाहरण

मान लीजिए कि आप इन सामग्रियों के साथ फाइल (मल्टीप्ली.जेएस) कहते हैं, तो आप चला सकते हैं

 `node multiply <number> <number>` 

और एक ही दो नंबरों पर गुणा ऑपरेटर का उपयोग करने के अनुरूप आउटपुट प्राप्त करें। Mulitply फ़ंक्शन में चलते हुए Mulitply एक उदाहरण है कि कैसे बिट मास्क को एक नंबर का प्रतिनिधित्व करने के लिए और तेजी से संचालन के लिए किसी दूसरे नंबर में बिट्स को फ्लिप करने के लिए इसका उपयोग करना है।

 var a, b, input = process.argv.slice(2); var printUsage = function() { console.log('USAGE:'); console.log(' node multiply <number> <number>'); } if(input[0] === '--help') {+ printUsage(); process.exit(0); } if(input.length !== 2) { printUsage(); process.exit(9); } if(isNaN(+input[0]) || isNaN(+input[1])) { printUsage(); process.exit(9); } // Okay, safe to proceed a = parseInt(input[0]), b = parseInt(input[1]); var Multiply = function(a,b) { var x = a, y = b, z = 0; while( x > 0 ) { if(x % 2 === 1) { z = z + y; } y = y << 1; x = x >> 1; } return z; } var result = Multiply(a,b); console.log(result); 

मैं बस इस प्रश्न की पुष्टि करने की कोशिश कर रहा हूं कि क्या बिटवर्ड AND ऑपरेटर जावास्क्रिप्ट में भी था।

चूंकि आपने एक उदाहरण पूछा:

 if ($('input[id="user[privileges]"]').length > 0) { $('#privileges button').each(function () { if (parseInt($('input[id="user[privileges]"]').val()) & parseInt($(this).attr('value'))) { $(this).button('toggle'); } }); } 

यह एक छिपे हुए फ़ील्ड के बिटमैस्क मान को दिया गया jQuery के साथ बटनों की स्थिति को पॉप्युलेट करता है:

  • none = 0
  • user = 1
  • administrator = 2
  • user + administrator = 3