रूबी बिटवाइज़ टूलबॉक्स:ऑपरेटर्स, एप्लिकेशन और मैजिक ट्रिक्स

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

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

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

चूंकि रूबी और कई अन्य भाषाओं का मूल समर्थन है, वे आपके टूलबॉक्स में जोड़ने के लिए एक बेहतरीन टूल हैं, भले ही यह केवल यह समझने के लिए हो कि क्या हो रहा है यदि आप भविष्य में उनका सामना करते हैं।

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

बिटवाइज ऑपरेशन क्या हैं?

किसी भी कंप्यूटर में सबसे निचले स्तर पर, हमारे पास केवल 1s और 0s होते हैं, जिन्हें बिट्स भी कहा जाता है। रूबी या किसी अन्य प्रोग्रामिंग भाषा में उपयोग किए जाने वाले किसी भी अन्य ऑपरेशन को अंततः 1s और 0s के रूप में संग्रहीत किया जाता है, लेकिन हमारे कंप्यूटर में सॉफ़्टवेयर जो हम देखते हैं और जो वास्तव में संग्रहीत होता है, के बीच उन्हें प्रभावी ढंग से बदल देता है। उदाहरण के लिए, हम स्ट्रिंग "हैलो" को 1s और 0s की श्रृंखला के रूप में संग्रहीत करते हैं।

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

बिटवाइज़ संचालन के बारे में अभी दो महत्वपूर्ण पहलू हैं:वे जानकारी संग्रहीत करने में बेहद प्रभावी हैं, क्योंकि हम सीधे बिट्स का उपयोग कर रहे हैं, और वे निष्पादन में बहुत तेज़ हैं।

मूल व्यवहार में बिट्स का एक सेट होता है और इसमें ऑपरेटर को लागू किया जाता है। आप ऑपरेटरों का उपयोग बिट्स के दो सेटों के साथ भी कर सकते हैं। आइए कुछ ऑपरेशन देखें:

बिटवाइज संचालन नहीं

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

~101000 = 010111

और बिटवाइज ऑपरेशन

AND एक ऑपरेशन है जो बिट्स के दो सेटों पर लागू होता है; इसका प्रतीक & . है और यह इस तर्क का अनुसरण करता है:

1 & 1 = 1
1 & 0 = 0
0 & 1 = 0
0 & 0 = 0

इसलिए जब हमारे पास बिट्स के दो समान-लंबाई वाले सेट होते हैं, तो परिणाम केवल इस तर्क को प्रत्येक व्यक्तिगत जोड़ी पर लागू करना होता है:

0110 AND
0111
-----
0110

रूबी में:

25.to_s(2)           # 11001
30.to_s(2)           # 11110
(25 & 30).to_s(2)    # 11000

या बिटवाइज़ ऑपरेशन

AND ऑपरेशन के समान, एक अन्य ऑपरेशन जो बिट्स के दो सेटों पर भी लागू होता है, वह बिटवाइज़ OR है। इसका प्रतीक | . है और इस तर्क का अनुसरण करता है:

1 | 1 = 1
1 | 0 = 1
0 | 1 = 1
0 | 0 = 0

तो अगर हमारे पास दोनों तरफ 1 है, तो परिणाम 1 है, अन्यथा यह 0 है। बहुत आसान! आइए अधिक बिट्स के साथ एक OR ऑपरेशन देखें:

0110 OR
0111
-----
0111

और रूबी में:

25.to_s(2)           # 11001
30.to_s(2)           # 11110
(25 | 30).to_s(2)    # 11111

व्यावहारिक उदाहरण 1:अनुमतियां

इस बिंदु पर, आप सोच रहे होंगे कि ये ऑपरेशन क्यों उपयोगी हैं। आखिरकार, वे बहुत निम्न-स्तर के लगते हैं। हो सकता है कि नेटवर्क प्रोटोकॉल, ग्राफिक्स या क्रिप्टोग्राफी के साथ सीधे काम करने की आपकी कोई योजना न हो।

लेकिन आपने शायद पहले अनुमतियों के साथ काम किया है। अनुमतियाँ एक ऐसा क्षेत्र है जहाँ बिटवाइज़ ऑपरेशन वास्तव में उपयोगी हो सकते हैं। कल्पना कीजिए कि आपके पास एक अनुमति प्रणाली है जहां उपयोगकर्ता दस्तावेज़ में विभिन्न क्रियाएं कर सकते हैं:

• देखें
• संपादित करें
• हटाएं
• अन्य उपयोगकर्ताओं को आमंत्रित करें

और अब हम इन क्रियाओं को विभिन्न भूमिकाओं में मॉडल करना चाहते हैं:

• सहायक: दस्तावेज़ को देख और संपादित कर सकते हैं।
• पर्यवेक्षक: केवल दस्तावेज़ देख सकते हैं।
• लेखक: सभी क्रियाएं कर सकते हैं।

हम इसे कैसे मॉडल कर सकते हैं? हम किसी भी समय कैसे जान सकते हैं कि किसी उपयोगकर्ता की इन भूमिकाओं में से कोई एक है या नहीं? एक उत्तर बिटवाइज़ ऑपरेशंस का उपयोग करना है।

हम प्रत्येक उपयोगकर्ता के लिए बिट्स का केवल एक सेट संग्रहीत करेंगे जो उनकी अनुमतियों का प्रतिनिधित्व करता है:

(Starting from the right side)
1st bit: View
2nd bit: Edit
3rd bit: Delete
4th bit: Invite other users

उदाहरण के लिए:

0001 = Can only view the document.
0011 = Can view and edit the document.
1001 = Can view, can't edit, can't delete and can invite others.

एक बार जब हमारे पास कुछ उपयोगकर्ताओं के लिए ये मान सेट हो जाते हैं, तो हम अपनी इच्छित अनुमति के साथ कुछ वास्तव में तेज़ तुलना कर सकते हैं। आइए कल्पना करें कि हम जांच कर रहे हैं कि कोई उपयोगकर्ता दस्तावेज़ को संपादित कर सकता है या नहीं। हम थोड़ा सा और संचालन का उपयोग कर सकते हैं:

# This is called a bit mask. It contains only the value we want to check, in this case the second bit for editing.
EDIT_PERMISSION_MASK = 0b0010

# We can define a quick method to check this: 
def can_edit_document?(user_permisions)
  (EDIT_PERMISSION_MASK & user_permisions) != 0
end

इसका मतलब है कि अगर बिटवाइज़ और ऑपरेशन हमें 0 से कुछ अलग देता है, तो हमारे पास वह बिट सेट है:

0010 AND
1101
----
0000 == 0 so we don't have the permission

0010 AND
1110
----
0010 != 0 so we have the permission

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

VIEW_PERMISSION_MASK   = 0b0001
EDIT_PERMISSION_MASK   = 0b0010
DELETE_PERMISSION_MASK = 0b0100
INVITE_PERMISSION_MASK = 0b1000

इसके अलावा, हम अनुमतियों को गतिशील रूप से परिभाषित कर सकते हैं और भविष्य में एक त्वरित बिट जांच के साथ नई अनुमतियों को संग्रहीत कर सकते हैं।

उदाहरण के लिए, हमने पहले कहा था कि एक सहायक केवल दस्तावेज़ को देख और संपादित कर सकता है, इसलिए उस उपयोगकर्ता के लिए अनुमतियाँ होंगी:0011 . हम उस मान को अपने डेटाबेस में स्टोर कर सकते हैं और फिर हम आसानी से जांच सकते हैं कि कोई सहायक पहले परिभाषित विधियों के साथ कोई क्रिया कर सकता है या नहीं।

ASSISTANT_MASK = VIEW_PERMISSION_MASK | EDIT_PERMISSION_MASK
# This will be: 0011

# Optionally, we could use this method to check if this user is an assistant. This method could be defined inside the User class.
def is_assistant?(user)
  (user.permissions == ASSISTANT_MASK)
end

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

व्यावहारिक उदाहरण 2:टीम में स्थितियां

आइए बिटवाइज़ ऑपरेशंस का थोड़ा और उपयोग करें ।

हम उन्हें किसी अन्य मामले में लागू कर सकते हैं जो अपेक्षाकृत सामान्य है:किसी स्पोर्ट्स टीम में अलग-अलग पद या किसी कंपनी में नौकरी की स्थिति। आइए सरल बनाने के लिए बास्केटबॉल टीम के साथ चलते हैं।

बास्केटबॉल में, खेल खेलते समय 5 स्थान होते हैं:- पॉइंट गार्ड- शूटिंग गार्ड- स्मॉल फॉरवर्ड- पावर फॉरवर्ड- सेंटर

और हम प्रत्येक स्थिति के लिए बिट्स का एक सेट असाइन कर सकते हैं: 00001 Point guard 00010 Shooting guard 00100 Small forward 01000 Power forward 10000 Center

रूबी में भी ऐसा ही होगा:

POINT_GUARD_POSITION    = 0b00001
SHOOTING_GUARD_POSITION = 0b00010
SMALL_FORWARD_POSITION  = 0b00100
POWER_FORWARD_POSITION  = 0b01000
CENTER_POSITION         = 0b10000

POINT_GUARD_POSITION | SHOOTING_GUARD_POSITION | SMALL_FORWARD_POSITION | POWER_FORWARD_POSITION | CENTER_POSITION # = 31

तो अब हम कुछ दिलचस्प चीजें कर सकते हैं, जैसे जांच लें कि पूरी टीम मौजूद है या नहीं:

# p1...p5 are the positions of each player
is_full_team_present = (p1 | p2 | p3 | p4 | p5 == 31)

क्यों? बिटवाइज़ या ऑपरेशन करने से, अगर हमारे पास सभी पोज़ीशन होते, तो हम पाते:11111.

# OR bitwise operation
00001 |
00010 |
00100 |
01000 |
10000
-----
11111

और 11111 31 है, क्योंकि 2^0 + 2^1 + 2^2 + 2^3 + 2^4 =31.

यह कड़ाई से बिटवाइज संचालन से संबंधित नहीं है, लेकिन इस डेटा मॉडलिंग के साथ हम यह भी जांच सकते हैं कि क्या दो खिलाड़ियों का आदान-प्रदान किया जा सकता है। यह बहुत आसान होगा:

def can_be_exchanged?(player1, player2)
  player1.position == player2.position
end

XOR

एक अन्य ऑपरेशन जो हम बिट्स के दो सेटों के साथ कर सकते हैं, वह है XOR, जिसका प्रतीक ^ . है .

XOR का अर्थ है अनन्य OR और यह इस तर्क का अनुसरण करता है:

1 | 1 = 0
1 | 0 = 1
0 | 1 = 1
0 | 0 = 0

तो परिणाम केवल 1 होगा यदि दो बिट्स में से एक 1 है; अगर दोनों बराबर हैं तो यह 0 होगा।

इस ऑपरेशन का उपयोग कुछ एल्गोरिदम में किसी संख्या की तुलना स्वयं से करने के लिए किया जाता है, क्योंकि x ^ x =0.

शिफ़्ट

यह संचालन का एक दिलचस्प समूह है जहां हम एक सेट के भीतर बिट्स को एक तरफ या दूसरी तरफ "स्थानांतरित" करते हैं। मुझे समझाने दो।

थोड़े बदलाव के साथ, हम बिट्स को एक दिशा में, बाएँ या दाएँ घुमाते या "शिफ्ट" करते हैं:

00010111 left-shift
<-------
00101110

10010111 right-shift
------->
11001011

हम बिट्स को n बार स्थानांतरित या स्थानांतरित कर सकते हैं। रूबी में नंबर 5 पर दो बार बाईं ओर लागू की गई शिफ्ट यहां दी गई है:

5.to_s(2) # 101
(5 << 2).to_s(2) # 10100

जैसा कि आप देख सकते हैं, बाईं पारी को <<द्वारा दर्शाया जाता है। एक दाहिनी पारी>>:

5.to_s(2) # 101
(5 >> 2).to_s(2) # 1

इस मामले में, हमें केवल एक ही मिलता है, क्योंकि 1*01 से बिट्स "0" और "1" * खारिज कर दिया गया है।

राइट शिफ्ट से 2 से भाग दें

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

यदि हम किसी संख्या में सही शिफ्ट लागू करते हैं, तो हमें इसे 2 से विभाजित करने का परिणाम मिलता है:

10.to_s(2)        # 1010
(10 >> 1).to_s(2) # 101
10 >> 1           # 5

बाएं शिफ्ट के साथ 2 से गुणा करें

उसी तरह, हम बाईं ओर की शिफ्ट के साथ 2 से गुणा कर सकते हैं:

10.to_s(2)        # 1010
(10 << 1).to_s(2) # 10100
10 << 1           # 20

जल्दी से जांचें कि कोई संख्या विषम है या सम है

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

कल्पना कीजिए कि हम 1 के साथ एक AND ऑपरेशन करते हैं, बस 1। तो यह उस कंप्यूटर पर निर्भर करता है जिसमें हम हैं, और 1. इसे 2 के साथ करते हैं:

2 = 00000010 &
    00000001
-------------
    00000000

अब 4 के साथ:

4 = 00000100 &
    00000001
-------------
    00000000

5 के बारे में क्या?

5 = 00000101 &
    00000001
-------------
    00000001

अब हमें मिला 1. क्या आप अनुमान लगा सकते हैं कि इसका क्या अर्थ है?

ऐसा करने से और 1 के साथ, यदि संख्या सम है, तो हमें 0 मिलेगा। यदि यह विषम है, तो हमें 1 मिलेगा। हम रूबी में कुछ विधियों को बनाने के लिए इस तथ्य का आसानी से उपयोग कर सकते हैं:

def is_odd?(number)
  number & 1
end

def is_even?(number)
  is_odd?(number) == 0
end
# Or:
def is_even?(number)
  (number & 1) == 0
end

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

निष्कर्ष

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