IP एड्रेस से बाइनरी कैलकुलेटर क्या है?
कोई भी IPv4 एड्रेस जैसे 192.168.1.1 असल में सिर्फ़ एक 32-बिट संख्या है, जिसे इंसानों की सुविधा के लिए डॉट से अलग किए गए चार डेसिमल नंबरों (ऑक्टेट) के रूप में लिखा जाता है। यह कैलकुलेटर इन चारों ऑक्टेट को उनके बाइनरी रूप में, एक अकेले 32-बिट डेसिमल पूर्णांक में, और हेक्साडेसिमल में बदल देता है — ये वही तीन रूप हैं जिनके बीच नेटवर्क इंजीनियर, प्रोग्रामर और विद्यार्थी सबसे ज़्यादा आते-जाते रहते हैं।
इसका इस्तेमाल कैसे करें
चारों ऑक्टेट में से हर एक को डालें — हर एक 0 से 255 तक का पूर्ण संख्या होना चाहिए। कैलकुलेट पर क्लिक करते ही आपको तुरंत डॉटेड-बाइनरी रूप (हर ऑक्टेट के लिए आठ बिट), लगातार चलने वाली 32-बिट बाइनरी स्ट्रिंग, इसके बराबर का डेसिमल पूर्णांक, और डॉटेड हेक्साडेसिमल रूप मिल जाता है।
फ़ॉर्मूला समझिए
हर ऑक्टेट को बाइनरी में बदला जाता है और उसके आगे ठीक 8 बिट पूरे करने के लिए ज़ीरो जोड़े जाते हैं, इसलिए 1 बन जाता है 00000001 और 255 बन जाता है 11111111। चारों को जोड़ने पर एक 32-बिट वैल्यू मिलती है। डेसिमल पूर्णांक निकालने के लिए हर ऑक्टेट को उसकी जगह के हिसाब से वज़न दिया जाता है:
चूँकि हर ऑक्टेट 8 बिट का है, इसलिए उन्हें 24, 16 और 8 बिट बाईं ओर शिफ़्ट करने से वे 32-बिट शब्द के सही हिस्से में बैठ जाते हैं।
हल किया हुआ उदाहरण
192.168.1.1 को लीजिए। बाइनरी में: \(192 = 11000000\), \(168 = 10101000\), \(1 = 00000001\), \(1 = 00000001\), यानी 11000000.10101000.00000001.00000001। डेसिमल पूर्णांक होगा
हेक्स में: C0.A8.01.01।
IPv4 पते की सामान्य सीमाएँ बाइनरी में
ये विशेष-उद्देश्य वाले IPv4 ब्लॉक IETF मानकों द्वारा परिभाषित हैं और दुनिया भर के IPv4 नेटवर्क पर लागू होते हैं। "स्थिर बिट्स" कॉलम उन प्रीफ़िक्स बिट्स को दिखाता है जो ब्लॉक के हर पते में समान होते हैं।
| सीमा | पता विस्तार | पहला ऑक्टेट (दशमलव / बाइनरी) | स्थिर अग्रणी बिट्स | उद्देश्य |
|---|---|---|---|---|
| 10.0.0.0/8 | 10.0.0.0 – 10.255.255.255 | 10 / 00001010 | 00001010 (8 बिट्स) | निजी उपयोग (RFC 1918) |
| 172.16.0.0/12 | 172.16.0.0 – 172.31.255.255 | 172 / 10101100 | 10101100.0001 (12 बिट्स) | निजी उपयोग (RFC 1918) |
| 192.168.0.0/16 | 192.168.0.0 – 192.168.255.255 | 192 / 11000000 | 11000000.10101000 (16 बिट्स) | निजी उपयोग (RFC 1918), सामान्यतः घरेलू और कार्यालय LAN |
| 127.0.0.0/8 | 127.0.0.0 – 127.255.255.255 | 127 / 01111111 | 01111111 (8 बिट्स) | लूपबैक (स्थानीय होस्ट, जैसे 127.0.0.1) |
| 169.254.0.0/16 | 169.254.0.0 – 169.254.255.255 | 169 / 10101001 | 10101001.11111110 (16 बिट्स) | लिंक-लोकल, स्व-निर्धारित पते (RFC 3927) |
| 224.0.0.0/4 | 224.0.0.0 – 239.255.255.255 | 224 / 11100000 | 1110 (4 बिट्स) | मल्टीकास्ट |
| 0.0.0.0 | एकल पता | 0 / 00000000 | सभी 32 बिट्स 0 हैं | "यह होस्ट" / अनिर्दिष्ट पता; डिफ़ॉल्ट रूट 0.0.0.0/0 के रूप में भी उपयोग होता है |
| 255.255.255.255 | एकल पता | 255 / 11111111 | सभी 32 बिट्स 1 हैं | स्थानीय नेटवर्क पर सीमित ब्रॉडकास्ट |
पूर्ण डॉटेड-बाइनरी रूप: 10.0.0.0 = 00001010.00000000.00000000.00000000, और 192.168.0.0 = 11000000.10101000.00000000.00000000.
बाइनरी स्थानीय मान और ऑक्टेट की दो की घातें
हर IPv4 ऑक्टेट 8 बिट्स का होता है। बिट 7 (सबसे बाईं ओर) का मान 128 है और बिट 0 (सबसे दाईं ओर) का मान 1 है।
| बिट स्थिति | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
|---|---|---|---|---|---|---|---|---|
| दो की घात | 27 | 26 | 25 | 24 | 23 | 22 | 21 | 20 |
| स्थानीय मान | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
32-बिट पूर्णांक प्राप्त करने के लिए, हर ऑक्टेट को एक स्थिति भार से गुणा किया जाता है:
| ऑक्टेट | गुणक | मान |
|---|---|---|
| ऑक्टेट 1 | 224 | 16,777,216 |
| ऑक्टेट 2 | 216 | 65,536 |
| ऑक्टेट 3 | 28 | 256 |
| ऑक्टेट 4 | 20 | 1 |
ऑक्टेट के वे मान जो सबनेट मास्क और पतों में अक्सर आते हैं:
| दशमलव | बाइनरी | हेक्स |
|---|---|---|
| 128 | 10000000 | 80 |
| 192 | 11000000 | C0 |
| 224 | 11100000 | E0 |
| 240 | 11110000 | F0 |
| 248 | 11111000 | F8 |
| 252 | 11111100 | FC |
| 254 | 11111110 | FE |
| 255 | 11111111 | FF |
IP पते को हाथ से बाइनरी में कैसे बदलें
उदाहरण पता: 10.0.0.5।
- चार ऑक्टेट में विभाजित करें। 10.0.0.5 से 10, 0, 0 और 5 मिलते हैं। हर एक 0 और 255 के बीच होना चाहिए।
- हर ऑक्टेट के बिट्स ज्ञात करें। स्थानीय मान 128, 64, 32, 16, 8, 4, 2, 1 से क्रम में जाएँ। यदि मान शेष संख्या में समा जाता है तो 1 लिखें (और उसे घटाएँ), अन्यथा 0 लिखें। 10 के लिए: 128 नहीं, 64 नहीं, 32 नहीं, 16 नहीं, 8 हाँ (शेष 2), 4 नहीं, 2 हाँ (शेष 0), 1 नहीं, जिससे 00001010 मिलता है। 5 के लिए: 4 + 1 से 00000101 मिलता है। (वैकल्पिक रूप से, बार-बार 2 से भाग दें और शेषफल नीचे से ऊपर पढ़ें।)
- हर ऑक्टेट को 8 बिट्स तक भरें। आगे शून्य जोड़ें ताकि हर ऑक्टेट में ठीक 8 अंक हों: 0 बन जाता है 00000000।
- बिंदुओं से जोड़ें। 10.0.0.5 = 00001010.00000000.00000000.00000101.
- हेक्साडेसिमल में बदलें। हर ऑक्टेट को दो 4-बिट निबल्स में बाँटें और हर एक को हेक्स अंक में बदलें। 00001010 = 0000 1010 = 0A, और 00000101 = 0101 = 05, इसलिए 10.0.0.5 = 0A.00.00.05, या 0x0A000005। एक और ऑक्टेट के लिए: 168 = 128 + 32 + 8 = 10101000 = 1010 1000 = A8।
- 32-बिट पूर्णांक की गणना करें। हर ऑक्टेट को उसके स्थिति भार से गुणा करें और जोड़ें:
$$\text{दशमलव} = o_1 \cdot 2^{24} + o_2 \cdot 2^{16} + o_3 \cdot 2^{8} + o_4$$
$$10 \cdot 16777216 + 0 \cdot 65536 + 0 \cdot 256 + 5 = 167772160 + 5$$
10.0.0.5 के लिए 32-बिट पूर्णांक 167772165 है, जो हेक्स में 0x0A000005 से मेल खाता है।
अक्सर पूछे जाने वाले सवाल
हर ऑक्टेट 0–255 के बीच ही क्यों होना चाहिए? हर ऑक्टेट 8 बिट का होता है, और 8 बिट 0 से 255 तक की वैल्यू दिखा सकते हैं (\(2^{8} = 256\) वैल्यू)।
डेसिमल पूर्णांक किस काम आता है? डेटाबेस, जियोलोकेशन टेबल और रूटिंग कोड अक्सर IP को एक अकेले पूर्णांक के रूप में सहेजते हैं, क्योंकि डॉटेड स्ट्रिंग को पार्स करने के मुक़ाबले तुलना और रेंज जाँच करना ज़्यादा तेज़ होता है।
क्या यह IPv6 के लिए काम करता है? नहीं — IPv6 एड्रेस 128 बिट के होते हैं और हेक्स ग्रुप में लिखे जाते हैं। यह टूल सिर्फ़ IPv4 (32-बिट) एड्रेस संभालता है।