स्विफ्ट बिटवाइज़ और बिट शिफ्ट ऑपरेटर्स (उदाहरण के साथ)

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

एक बिट का उपयोग द्विआधारी अंक को दर्शाने के लिए किया जाता है। एक बाइनरी अंक में 0 या 1 दो संभावित मान हो सकते हैं। शुरुआती स्तर के प्रोग्रामर के रूप में, आपको बिट स्तर पर संचालन के साथ काम करने की आवश्यकता नहीं है।

आदिम डेटा प्रकारों जैसे: पूर्णांक, फ्लोट, बूलियन, स्ट्रिंग आदि के साथ काम करना पर्याप्त है। जब आप निम्न स्तर की प्रोग्रामिंग के साथ काम कर रहे हों तो आपको बिट स्तर पर काम करने की आवश्यकता हो सकती है।

स्विफ्ट बिट्स में हेरफेर करने के लिए, बुनियादी ऑपरेटरों के अलावा ऑपरेटरों का एक समृद्ध सेट प्रदान करता है। ये ऑपरेटर तार्किक ऑपरेटरों के समान हैं, सिवाय इसके कि वे डेटा (बिट्स) के द्विआधारी प्रतिनिधित्व पर काम करते हैं।

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

स्विफ्ट में उपलब्ध सभी बिटवाइज़ ऑपरेटर नीचे सूचीबद्ध हैं:

1. बिटवाइज़ ऑपरेटर नहीं

यह टिल्ड ~साइन द्वारा दर्शाया गया है और इसे एक ही ऑपरेंड पर लगाया जा सकता है। यह सभी बिट्स को निष्क्रिय करता है। अर्थात 1 से 0 और 0 से 1 में परिवर्तन होता है।

यदि x एक वैरिएबल / स्थिरांक है जो बाइनरी वैल्यू यानी 0 या 1 रखता है। x वेरिएबल पर बिटवाइज़ नहीं ऑपरेशन को नीचे दी गई तालिका में दर्शाया जा सकता है:

नहीं

एक्स	~ x
०	1 है
1 है	०

उदाहरण 1: अहस्ताक्षरित पूर्णांक के लिए बिटवाइज़ संचालक नहीं

 let initalNumber:UInt8 = 1 let invertedNumber = ~initalNumber print(invertedNumber) 

जब आप उपरोक्त कार्यक्रम चलाते हैं, तो आउटपुट होगा:

 254

उपरोक्त कार्यक्रम में, स्टेटमेंट let initalNumber:UInt8 = 18 बिट्स के अनसाइन्टेड int प्रकार का है। तो, दशमलव में 1 00000001को बाइनरी के रूप में दर्शाया जा सकता है ।

बिटवाइज़ नहीं ऑपरेटर एक बिट चर या स्थिर के सभी बिट को बदलता है, बिट 0 को 1 और 1 से 0. में बदल दिया जाता है 11111110। इसे दशमलव में परिवर्तित करने के बाद इसे 254 के रूप में दर्शाया जाता है। इसलिए, स्टेटमेंट print(invertedNumber)स्क्रीन में 254 आउटपुट करता है।

आप सीधे बिट्स ऑपरेटर को बिट्स में भी कर सकते हैं:

उदाहरण 2: बिटवाइज़ बिट्स में ऑपरेटर नहीं

 let initialBits: UInt8 = 0b11111111 let invertedBits = ~initialBits print(invertedBits) 

जब आप उपरोक्त कार्यक्रम चलाते हैं, तो आउटपुट होगा:

 ०

initialBits में बाइनरी वैल्यू होती है 11111111जो दशमलव में 255 से मेल खाती है। बाइनरी में संख्या का प्रतिनिधित्व करने के लिए हमारे पास 0bशाब्दिक रूप में एक उपसर्ग है। 0bउपसर्ग के बिना , यह इसे एक सामान्य पूर्णांक के रूप में मानेगा और आपको एक अतिप्रवाह त्रुटि मिलेगी (UInt8 केवल 0 से 255 तक संख्याओं को संग्रहीत कर सकता है)।

चूंकि, हमने बिटवाइज़र नहीं ऑपरेटर का उपयोग किया है, यह सभी 1 से 0. को बदलता है, इसलिए, निरंतर उलटा होता है, 00000000जिसमें 0 के बराबर होता है UInt8।

उदाहरण 3: हस्ताक्षरित पूर्णांक के लिए बिटवाइज़ संचालक नहीं

 let initalNumber:Int = 1 let invertedNumber = ~initalNumber print(invertedNumber) 

जब आप उपरोक्त कार्यक्रम चलाते हैं, तो आउटपुट होगा:

 -2

उपरोक्त कार्यक्रम में, दशमलव में 1 00000001को बाइनरी के रूप में दर्शाया जा सकता है । बिटवाइज़ नहीं ऑपरेटर सभी बिट को एक वैरिएबल या कंटीन्यू में बदलता है, बिट 0 को 1 और 1 से 0. में बदल दिया जाता है, इसलिए इनवर्टेडनंबर में बिट्स होते हैं 11111110। यह स्क्रीन में 254 आउटपुट होना चाहिए। लेकिन इसके बदले -2 देता है। अजीब बात है, है ना ?? आइए नीचे देखें कि यह कैसे हुआ।

let initalNumber:Int = 1एक हस्ताक्षरित इंट है जो सकारात्मक और नकारात्मक दोनों पूर्णांकों को पकड़ सकता है। इसीलिए जब हमने एक हस्ताक्षरित पूर्णांक के लिए ऑपरेटर नहीं लगाया, तो लौटा हुआ बाइनरी भी एक ऋणात्मक संख्या का प्रतिनिधित्व कर सकता है।

संकलक ने 11111110 द्विआधारी के रूप में -2 की व्याख्या कैसे की ?

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

दो का पूरक पता लगाने के लिए चरण -2 :

1. बाइनरी फॉर्म में 2 लिखें: 00000010
2. अंकों को उल्टा करें। ० १ हो जाता है और १ बन जाता है ०:11111101
3. 1 जोड़ें: 11111110

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

इसे समझने के लिए, आइए नीचे एक उदाहरण देखें:

 print(Int8(bitPattern: 0b11111110)) print(0b11111110)

जब आप उपरोक्त कार्यक्रम चलाते हैं, तो आउटपुट होगा:

 -2 254

उपरोक्त उदाहरण में, कंपाइलर ने केवल हस्ताक्षरित 8-बिट इंटेगर के लिए द्विआधारी संख्या -2 को दशमलव में इलाज किया। इसलिए स्टेटमेंट print(Int8(bitPattern: 0b11111110))स्क्रीन में -2 आउटपुट करता है।

लेकिन सामान्य पूर्णांक प्रकार के लिए जिसका आकार 32/64 बिट है और बड़े मानों को पकड़ सकता है, यह मान की व्याख्या करता है 254। इसलिए, स्टेटमेंट स्क्रीन में 254print(0b11111110) आउटपुट करता है।

2. बिटवाइज़ और ऑपरेटर

इसका प्रतिनिधित्व किया जाता है &और इसे दो ऑपरेंड पर लागू किया जा सकता है। AND ऑपरेटर दो बिट्स और रिटर्न 1 की तुलना करता है यदि दोनों बिट्स 1 हैं, अन्यथा रिटर्न 0 है।

यदि x और y वैरिएबल / स्थिर हैं जो बाइनरी वैल्यू को 0 या 1 रखता है। x और y पर बिटवाइज़ और ऑपरेशन को नीचे दी गई तालिका में दर्शाया जा सकता है:

तथा

एक्स	य	x & y
०	०	०
०	1 है	०
1 है	1 है	1 है
1 है	०	०

उदाहरण 5: बिटवाइज़ और ऑपरेशन

 let xBits = 0b10000011 let yBits = 0b11111111 let result = xBits & yBits print("Binary:",String(result, radix: 2)) print(result)

जब आप उपरोक्त कार्यक्रम चलाते हैं, तो आउटपुट होगा:

 बाइनरी: 10000011 131 

उपरोक्त कार्यक्रम में, कथन let result = xBits & yBitsदो ऑपरेंड xBits और yBits के बिट्स को जोड़ता है। यह 1 रिटर्न देता है यह दोनों बिट्स 1 है अन्यथा यह 0 देता है।

String(value , radix: )initializer का उपयोग विभिन्न संख्या प्रणाली में संख्या का प्रतिनिधित्व करने के लिए किया जाता है। यदि हम मूलांक 2 की आपूर्ति करते हैं। यह संख्या को द्विआधारी संख्या प्रणाली में परिवर्तित करता है। इसी तरह, हम हेक्स के लिए 16 और दशमलव के लिए 10 का उपयोग कर सकते हैं।

कथन बाइनरीprint("Binary:",String(result, radix: 2)) आउटपुट करता है : स्क्रीन में 10000011 । 10000011दशमलव में 131 के बराबर है, कथन print(result)कंसोल में 131 आउटपुट करता है।

3. बिटवाइज या ऑपरेटर

इसे |दो ऑपरेंड पर लागू किया जा सकता है। बिटवाइज़ या ऑपरेटर दो बिट्स की तुलना करता है और 1 का परिणाम उत्पन्न करता है यदि एक या अधिक इनपुट 1 या अन्यथा 0 हो।

यदि x और y वैरिएबल / स्थिर हैं जो बाइनरी वैल्यू यानी 0 या 1 रखते हैं। x और y पर बिटवाइज़ या ऑपरेशन को नीचे दी गई तालिका में दर्शाया जा सकता है:

या

एक्स	य	x | य
०	०	०
०	1 है	1 है
1 है	1 है	1 है
1 है	०	1 है

उदाहरण 6: बिटवाइज या ऑपरेशन

 let xBits = 0b10000011 let yBits = 0b11111111 let result = xBits | yBits print("Binary:", String(result, radix: 2)) print(result) 

जब आप उपरोक्त कार्यक्रम चलाते हैं, तो आउटपुट होगा:

 बाइनरी: 11111111 255 

उपरोक्त कार्यक्रम में, स्टेटमेंट let result = xBits | yBitsदो स्थिरांक xBits और yBits के बिट्स को जोड़ता है। यदि बिट्स में से कोई 1 है तो यह 1 रिटर्न देता है अन्यथा यह 0 देता है।

बयान बाइनरीprint("Binary:",String(result, radix: 2)) आउटपुट : स्क्रीन में 11111111 । चूंकि, दशमलव में 11111111समतुल्य है 255, कथन स्क्रीन में 255print(result) आउटपुट करता है।

4. बिटवाइज XOR ऑपरेटर

इसे ^दो ऑपरेंड पर लागू किया जा सकता है। XOR ऑपरेटर दो बिट्स की तुलना करता है और 1 का परिणाम उत्पन्न करता है, यदि वास्तव में इसका एक इनपुट 1 है अन्यथा यह 0 देता है।

यदि x और y वैरिएबल / स्थिरांक हैं जो बाइनरी वैल्यू यानी 0 या 1 रखते हैं। x और y पर बिटवाइज़ XOR ऑपरेशन को टेबल में दर्शाया जा सकता है:

XOR

एक्स	य	x य
०	०	०
०	1 है	1 है
1 है	1 है	०
1 है	०	1 है

उदाहरण 7: बिटवाइज़ XOR ऑपरेशन

 let xBits = 0b10000011 let yBits = 0b11111111 let result = xBits yBits print("Binary:", String(result, radix: 2)) print(result) 

जब आप उपरोक्त कार्यक्रम चलाते हैं, तो आउटपुट होगा:

 बाइनरी: 1111100 124 

उपरोक्त कार्यक्रम में, स्टेटमेंट let result = xBits yBitsदो स्थिरांक xBits और yBits के बिट्स को जोड़ता है। यदि 1 बिट में से एक है तो यह 1 रिटर्न देता है अन्यथा यह 0 देता है।

स्टेटमेंट बाइनरीprint("Binary:",String(result, radix: 2)) आउटपुट करता है : स्क्रीन में 1111100 ( 01111100 के बराबर)। चूंकि, दशमलव में 1111100समतुल्य है 124, कथन स्क्रीन में 124print(result) आउटपुट करता है।

5. बिटवाइज़ शिफ्ट ऑपरेटर

इस ऑपरेटर का उपयोग एक निश्चित संख्या में सभी बिट्स को एक संख्या में बाईं या दाईं ओर ले जाने के लिए किया जाता है और इसे सिंगल ऑपरेंड पर लागू किया जा सकता है। इसे <<या के रूप में दर्शाया गया है >>।

दो प्रकार के शिफ्ट ऑपरेटर हैं:

बिटवाइज़ लेफ्ट शिफ्ट ऑपरेटर

• इस रूप में घोषित किया गया <<
• यह बिट्स को उसके द्वारा निर्दिष्ट संख्या द्वारा बाईं ओर स्थानांतरित करने का कारण बनता है <<।
• शिफ्ट ऑपरेशन द्वारा खाली किए गए बिट पद शून्य-भरे हुए हैं।
• एक पूर्णांक के बिट्स को एक स्थिति से बाईं ओर स्थानांतरित करने से इसका मूल्य दोगुना हो जाता है

उदाहरण 8: बिटवाइज़ लेफ्ट शिफ्ट ऑपरेटर

 let someBits:UInt8 = 0b11000100 print(someBits << 1) 

जब आप उपरोक्त कार्यक्रम चलाते हैं, तो आउटपुट होगा:

 136

उपरोक्त कार्यक्रम में, हमने बाएं शिफ्ट ऑपरेटर का उपयोग किया है। <<1 का उपयोग करने का अर्थ है कि बिट को 1 से बाईं ओर शिफ्ट करना। अंक एक स्थिति से बाईं ओर स्थानांतरित हो जाते हैं, और दाईं ओर अंतिम अंक एक शून्य से भर जाता है।

आप वह अंक भी देख सकते हैं जो बाईं ओर से "ऑफ द एंड" शिफ्ट हो जाता है। यह फिर से दाईं ओर से नहीं लपेटता है। इसे बाईं ओर एक बिट में शिफ्ट करने से बाइनरी से 1 को हटा दिया जाता है और शिफ्ट वैल्यू को भरने के लिए दाईं ओर 0 जोड़ दिया जाता है, साथ ही बाकी के बिट्स को 1 से बाईं स्थिति में स्थानांतरित कर दिया जाता है।

यह रिटर्न 10001000जो के बराबर है 136में UInt8। इसलिए, print(someBits << 1)स्टेटमेंट स्क्रीन में 136 आउटपुट करता है।

बिटवाइज़ राइट शिफ्ट ऑपरेटर

• इस रूप में घोषित किया गया >>
• इसके कारण बिट्स को दाईं ओर शिफ्ट किया जा सकता है >>
• अहस्ताक्षरित संख्याओं के लिए, शिफ्ट ऑपरेशन द्वारा खाली किए गए बिट पदों को शून्य से भरा जाता है।
• हस्ताक्षरित संख्याओं (संख्याएँ जो ऋणात्मक भी हो सकती हैं) के लिए, साइन बिट का उपयोग रिक्त बिट पदों को भरने के लिए किया जाता है। दूसरे शब्दों में, यदि संख्या सकारात्मक है, तो 0 का उपयोग किया जाता है, और यदि संख्या नकारात्मक है, तो 1 का उपयोग किया जाता है।
• इसे एक स्थान पर दाईं ओर ले जाने से इसका मूल्य आधा हो जाता है।

उदाहरण 9: अहस्ताक्षरित पूर्णांक के लिए बिटवाइज़ राइट शिफ्ट ऑपरेटर

 let someBits: UInt8 = 4 print(someBits>> 1) 

जब आप उपरोक्त कार्यक्रम चलाते हैं, तो आउटपुट होगा:

 २

उपरोक्त कार्यक्रम में, हमने अहस्ताक्षरित पूर्णांक पर सही शिफ्ट ऑपरेटर का उपयोग किया है। >>1 का उपयोग करने का अर्थ है कि बिट को 1 से दाईं ओर शिफ्ट करना। शिफ्ट ऑपरेशन द्वारा खाली किए गए बिट पदों को हमेशा अहस्ताक्षरित पूर्णांक पर शून्य-भरा जाता है।

चूंकि, 4 को 00000100बाइनरी के रूप में दर्शाया गया है। यह सही, रिटर्न के लिए एक बिट स्थानांतरण 00000010जो के बराबर है 2में UInt8। इसलिए, print(someBits>> 1)स्टेटमेंट स्क्रीन में 2 आउटपुट करता है।

उदाहरण 10: हस्ताक्षरित पूर्णांक के लिए बिटवाइज़ राइट शिफ्ट ऑपरेटर

 let someBits:Int = -4 print(someBits>> 1) 

जब आप उपरोक्त कार्यक्रम चलाते हैं, तो आउटपुट होगा:

 -2

उपरोक्त कार्यक्रम में, हमने अहस्ताक्षरित पूर्णांक पर सही शिफ्ट ऑपरेटर का उपयोग किया है। सकारात्मक संख्याओं के विपरीत, >>ऋणात्मक संख्याओं के लिए, 1 का उपयोग रिक्त स्थान को भरने के लिए किया जाता है, 0 के बजाय।

चूंकि, बाइनरी में -4दर्शाया गया 11111100है। यह सही करने के लिए एक बिट स्थानांतरण और रिक्त पद, रिटर्न में 1 रखकर 11111110जो के बराबर है -2के लिए Int8लिखें। इसलिए, print(someBits>> 1)स्टेटमेंट स्क्रीन में -2 आउटपुट करता है।