नियमित अभिव्यक्ति जो कि वैध IPv6 पतों से मेल खाती है

Question

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

क्या कोई नियमित अभिव्यक्ति का सुझाव दे सकता है जो आवश्यकता को पूरा करेगा?

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

Comments

की जाँच करें intermapper.com/ipv6validator .. यह इस के लिए लिंक पर्ल परीक्षण स्क्रिप्ट

— Mottie

मैंने नीचे दिए गए सभी उत्तरों की कोशिश की है और वे मेरे सभी परीक्षण मामलों के लिए काम नहीं करते हैं और / या उनमें आईपीवी 4 भी शामिल है जो कि नहीं मांगे गए थे। मैंने इसे अब तक का सबसे साफ समाधान पाया है: stackoverflow.com/a/21944928/3112803

— gfrobenius

Answer 1

मैं POSIX नियमित अभिव्यक्ति के साथ काम करने के लिए @Factor रहस्यवादी का जवाब पाने में असमर्थ था, इसलिए मैंने एक लिखा जो POSIX नियमित अभिव्यक्ति और PERL नियमित अभिव्यक्ति के साथ काम करता है।

यह मेल खाना चाहिए:

• IPv6 पते
• शून्य संकुचित IPv6 पते ( rfc5952 की धारा 2.2 )
• ज़ोन इंडेक्स के साथ लिंक-स्थानीय IPv6 पते ( rfc4007 की धारा 11 )
• IPv4- एंबेडेड IPv6 पता ( rfc6052 का अनुभाग 2 )
• IPv4- मैप किया गया IPv6 पता ( rfc2765 का खंड 2.1 )
• IPv4- अनुवादित पते ( rfc2765 का खंड 2.1 )

IPv6 नियमित अभिव्यक्ति:

(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))

पढ़ने में आसानी के लिए, निम्नलिखित नियमित अभिव्यक्ति प्रमुख या अलग लाइनों में बिंदुओं पर विभाजित है:

# IPv6 RegEx
(
([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|          # 1:2:3:4:5:6:7:8
([0-9a-fA-F]{1,4}:){1,7}:|                         # 1::                              1:2:3:4:5:6:7::
([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|         # 1::8             1:2:3:4:5:6::8  1:2:3:4:5:6::8
([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|  # 1::7:8           1:2:3:4:5::7:8  1:2:3:4:5::8
([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|  # 1::6:7:8         1:2:3:4::6:7:8  1:2:3:4::8
([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|  # 1::5:6:7:8       1:2:3::5:6:7:8  1:2:3::8
([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|  # 1::4:5:6:7:8     1:2::4:5:6:7:8  1:2::8
[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|       # 1::3:4:5:6:7:8   1::3:4:5:6:7:8  1::8  
:((:[0-9a-fA-F]{1,4}){1,7}|:)|                     # ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8 ::8       ::     
fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|     # fe80::7:8%eth0   fe80::7:8%1     (link-local IPv6 addresses with zone index)
::(ffff(:0{1,4}){0,1}:){0,1}
((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}
(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|          # ::255.255.255.255   ::ffff:255.255.255.255  ::ffff:0:255.255.255.255  (IPv4-mapped IPv6 addresses and IPv4-translated addresses)
([0-9a-fA-F]{1,4}:){1,4}:
((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}
(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])           # 2001:db8:3:4::192.0.2.33  64:ff9b::192.0.2.33 (IPv4-Embedded IPv6 Address)
)

# IPv4 RegEx
((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])

ऊपर समझने में आसान बनाने के लिए, निम्नलिखित "छद्म" कोड ऊपर की प्रतिकृति देता है:

IPV4SEG  = (25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])
IPV4ADDR = (IPV4SEG\.){3,3}IPV4SEG
IPV6SEG  = [0-9a-fA-F]{1,4}
IPV6ADDR = (
           (IPV6SEG:){7,7}IPV6SEG|                # 1:2:3:4:5:6:7:8
           (IPV6SEG:){1,7}:|                      # 1::                                 1:2:3:4:5:6:7::
           (IPV6SEG:){1,6}:IPV6SEG|               # 1::8               1:2:3:4:5:6::8   1:2:3:4:5:6::8
           (IPV6SEG:){1,5}(:IPV6SEG){1,2}|        # 1::7:8             1:2:3:4:5::7:8   1:2:3:4:5::8
           (IPV6SEG:){1,4}(:IPV6SEG){1,3}|        # 1::6:7:8           1:2:3:4::6:7:8   1:2:3:4::8
           (IPV6SEG:){1,3}(:IPV6SEG){1,4}|        # 1::5:6:7:8         1:2:3::5:6:7:8   1:2:3::8
           (IPV6SEG:){1,2}(:IPV6SEG){1,5}|        # 1::4:5:6:7:8       1:2::4:5:6:7:8   1:2::8
           IPV6SEG:((:IPV6SEG){1,6})|             # 1::3:4:5:6:7:8     1::3:4:5:6:7:8   1::8
           :((:IPV6SEG){1,7}|:)|                  # ::2:3:4:5:6:7:8    ::2:3:4:5:6:7:8  ::8       ::       
           fe80:(:IPV6SEG){0,4}%[0-9a-zA-Z]{1,}|  # fe80::7:8%eth0     fe80::7:8%1  (link-local IPv6 addresses with zone index)
           ::(ffff(:0{1,4}){0,1}:){0,1}IPV4ADDR|  # ::255.255.255.255  ::ffff:255.255.255.255  ::ffff:0:255.255.255.255 (IPv4-mapped IPv6 addresses and IPv4-translated addresses)
           (IPV6SEG:){1,4}:IPV4ADDR               # 2001:db8:3:4::192.0.2.33  64:ff9b::192.0.2.33 (IPv4-Embedded IPv6 Address)
           )

मैंने GitHub पर एक स्क्रिप्ट पोस्ट की जो नियमित अभिव्यक्ति का परीक्षण करती है: https://gist.github.com/syzdek/6086792

Comments

आप IPv4 regex IPs से मेल नहीं खाते जैसे127.000.000.001

— केंटोज़ो

IPv4 खंडों में अग्रणी शून्य शामिल नहीं होना चाहिए। यदि एक प्रमुख शून्य मौजूद है, तो IPv4 सेगमेंट की व्याख्या ऑक्टल में की जानी चाहिए। तो ऊपर IPV4SEG '000' की अनुमति नहीं देने में सही है। हालाँकि यह '00' को अनुमति देता है जो इसे नहीं करना चाहिए।

— बराबर

ब्राउज़र में मेरे लिए काम नहीं किया जैसा कि मैं उम्मीद करूंगा। मान्य भी reg.test ('3zzzzffe: 1900: 4545: 3: 200: f8ff: fe21: 67cf') जो स्पष्ट रूप से एक मान्य IPv6 एड्रेस नहीं है। यहाँ regex के साथ बहुत बेहतर परिणाम थे: nbviewer.ipython.org/github/rasbt/python_reference/blob/master/…

— Capaj

शानदार ipv6 regex। लिंक स्थानीय अनुभाग के साथ एक छोटा बग मिला। आपके पास fe80ऐसा कुछ कहाँ होना चाहिए [fF][eE]80और एक ffffऐसा होना चाहिए जैसे[fF]{4}

— user2831628

+1 यह दर्शाने के लिए कि regexes (किसी भी स्रोत कोड के समान तरीके से) वास्तव में पठनीय हो सकते हैं यदि आप देखभाल करते हैं और उन्हें प्रारूपित करते हैं।

— नटिक्स डेस

Answer 2

निम्नलिखित IPv4, IPv6 (पूर्ण और संपीड़ित), और IPv6v4 (पूर्ण और संपीड़ित) पते को मान्य करेगा:

'/^(?>(?>([a-f0-9]{1,4})(?>:(?1)){7}|(?!(?:.*[a-f0-9](?>:|$)){8,})((?1)(?>:(?1)){0,6})?::(?2)?)|(?>(?>(?1)(?>:(?1)){5}:|(?!(?:.*[a-f0-9]:){6,})(?3)?::(?>((?1)(?>:(?1)){0,4}):)?)?(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?>\.(?4)){3}))$/iD'

Comments

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

— ग्युरि

नमस्ते, मैंने इस RegExp का परीक्षण किया और मेरे लिए काम नहीं किया। यह कहता है कि D एक अवैध ध्वज है और जब मैं इसे हटाता हूं तो यह कहता है "SyntaxError: अमान्य क्वांटिफायर"

— diosney

जावास्क्रिप्ट Perl शैली के नियमित भावों के सबसेट को लागू करता है, PCRE की संपूर्णता को नहीं। मेरा regex PCRE की कुछ उन्नत विशेषताओं के बिना काम नहीं करेगा।

— माइकलशर्टन

यह मेरे लिए C #

— सैराट

असफल परीक्षण का मामला: FE80: 0000: 0000: 0000: 0202: B3FF: FE1E: 8329 इस तिथि पर अमृत के नवीनतम संस्करण का उपयोग करना, जो पीसीआरई का उपयोग करता है।

— पनचक्की

Answer 3

ऐसा लगता है कि आप पायथन का उपयोग कर रहे हैं। यदि हां, तो आप इस तरह से कुछ का उपयोग कर सकते हैं:

import socket

def check_ipv6(n):
    try:
        socket.inet_pton(socket.AF_INET6, n)
        return True
    except socket.error:
        return False

print check_ipv6('::1') # True
print check_ipv6('foo') # False
print check_ipv6(5)     # TypeError exception
print check_ipv6(None)  # TypeError exception

मुझे नहीं लगता कि आपके पास पाने के लिए पाइथन में IPv6 संकलित होना चाहिए inet_pton, जो socket.AF_INETपहले पैरामीटर के रूप में पास होने पर IPv4 पतों को भी पार्स कर सकता है । नोट: यह गैर-यूनिक्स प्रणालियों पर काम नहीं कर सकता है।

Comments

आपको exceptक्लॉज़ में अपवाद प्रकार निर्दिष्ट करना चाहिए । अन्यथा, exceptसब कुछ पकड़ लेगा और असंबंधित त्रुटियों को मुखौटा कर सकता है। यहां का प्रकार होना चाहिए socket.error।

— अयमान होउरीह

ए) inet_pton अन्य अपवादों को नहीं फेंकता है, जब तक कि डॉक्स गलत नहीं हैं, और बी) भले ही उसने किया हो, आप और क्या करेंगे लेकिन गलत?

— जो हिल्डेब्रांड

पुन :: अन्य त्रुटियाँ ... यदि उपयोगकर्ता एक गैर-स्ट्रिंग में गुजरता है, तो टाइप-ईयर खाया जाता है। स्पष्ट रूप से एक सूची एक ipv6 नहीं है, लेकिन मैं शायद यह चाहूंगा कि मैं गलत प्रकार से गुजर रहा था।

— ग्रिज लिंड

+1 इससे मुझे बहुत मदद मिली। कुछ अतिरिक्त बिंदु जो जोड़े जाने चाहिए: 1) socket.inet_pton का उपयोग आईपी पते (आईपी और आईपीवी 6) के दोनों परिवारों की वैधता का परीक्षण करने के लिए किया जा सकता है। 2) डॉक्स यहां ( docs.python.org/2/library/socket.html ) सुझाव देते हैं कि यह रीक्स प्लेटफार्मों पर उपलब्ध है। यह विन-प्लेटफॉर्म पर उपलब्ध नहीं हो सकता है।

— मोकिस्टीनन

django और यह मदद करता है का उपयोग कर!

— इलाद चांदी

Answer 4

" IPv6 regex " से:

(\A([0-9a-f]{1,4}:){1,1}(:[0-9a-f]{1,4}){1,6}\Z)|
(\A([0-9a-f]{1,4}:){1,2}(:[0-9a-f]{1,4}){1,5}\Z)|
(\A([0-9a-f]{1,4}:){1,3}(:[0-9a-f]{1,4}){1,4}\Z)|
(\A([0-9a-f]{1,4}:){1,4}(:[0-9a-f]{1,4}){1,3}\Z)|
(\A([0-9a-f]{1,4}:){1,5}(:[0-9a-f]{1,4}){1,2}\Z)|
(\A([0-9a-f]{1,4}:){1,6}(:[0-9a-f]{1,4}){1,1}\Z)|
(\A(([0-9a-f]{1,4}:){1,7}|:):\Z)|
(\A:(:[0-9a-f]{1,4}){1,7}\Z)|
(\A((([0-9a-f]{1,4}:){6})(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3})\Z)|
(\A(([0-9a-f]{1,4}:){5}[0-9a-f]{1,4}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3})\Z)|
(\A([0-9a-f]{1,4}:){5}:[0-9a-f]{1,4}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A([0-9a-f]{1,4}:){1,1}(:[0-9a-f]{1,4}){1,4}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A([0-9a-f]{1,4}:){1,2}(:[0-9a-f]{1,4}){1,3}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A([0-9a-f]{1,4}:){1,3}(:[0-9a-f]{1,4}){1,2}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A([0-9a-f]{1,4}:){1,4}(:[0-9a-f]{1,4}){1,1}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A(([0-9a-f]{1,4}:){1,5}|:):(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A:(:[0-9a-f]{1,4}){1,5}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)

Comments

इस तरह की नियमित अभिव्यक्ति एक "कोड गंध" होनी चाहिए कि शायद नियमित अभिव्यक्ति यहां सबसे अच्छा अनुकूल समाधान नहीं है। (हालांकि, मुझे लगता है कि ऑप ने इसके लिए पूछा था ...)

— थानाटोस

@ user712092 - जिन लोगों ने आंखों के साथ कोड बेस देखा है, जैसे

— danielpops

यह आरईएस के लिए एक पूरी तरह से अनावश्यक आघात है। इसे उत्पन्न करने वाले कार्यक्रम को समझ में नहीं आया कि यह क्या कर रहा है। एक इंसान इस तरह से कभी नहीं करेगा। स्पष्ट जटिलता से मूर्ख मत बनो - आरईएस वास्तव में कई लोगों के लिए "काला जादू" है, लेकिन उन्हें किसी अन्य ग्रह पर रखने का कोई कारण नहीं है!

— चक कोलार

+1 लेकिन OMG को ऐसा करने का एक बेहतर तरीका होना चाहिए: P संदर्भ के लिए: रेल के लिए यह मदद कर सकता है: stackoverflow.com/questions/16965697/…

— Tilo

यह वास्तव में एक कोड गंध है; हालाँकि, एक बार देखने के बाद आप देखेंगे कि प्रत्येक regex काफी संक्षिप्त है। समस्या यह है कि IPv6 के 'कम्प्रेशन' द्वारा बनाए गए अलग-अलग पैटर्न हैं - कॉलन की शुरुआत, मध्य और अंत, यदि आपने अपने दोहरे कोलन का उपयोग किया है तो आप इसे फिर से उपयोग नहीं कर सकते हैं, कुल के ऊपर। डबल से पहले और बाद के कॉलोन को जोड़ना होगा। पर्ल 6 इससे निपटने में सक्षम हो सकता है, लेकिन यह PCRE सिंटैक्स से परे है। (पुनश्च - मैं अंत में एम्बेडेड ipv4 की गिनती नहीं करता, जो कि ipv6 अनुभाग की तुलना में लंबा है!)

— जेरार्ड ओनेइल

Answer 5

मुझे फ्रैंक क्रुएगर के जवाब का दृढ़ता से जवाब देना होगा ।

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

यह जांचने के लिए एक से अधिक तरीके हैं कि क्या दिए गए स्ट्रिंग एक मान्य IPv6 पता है और नियमित अभिव्यक्ति मिलान केवल एक समाधान है।

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

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

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

एक नियमित अभिव्यक्ति का उपयोग करते समय सावधानी के साथ कार्य करें जिसकी कार्यक्षमता आप किसी और को नहीं समझा सकते हैं।

Comments

दो रेग्युलर एक्सप्रेशंस, एक लिबरल एक्सप्रेशन और एक एक्सप्रेशन एक्सप्रेशन को फॉलो करने के लिए पहले द्वारा दिए गए अमान्य पतों को फँसाने के लिए, एक एक्सप्रेशन ( return ex1.match(S) && ! ex2.match(S)) की तुलना में आसान हो सकता है ।

— रायडवल

आप मान रहे हैं कि वह व्यक्तिगत आईपी को मान्य कर रहा है जब वह लगभग निश्चित रूप से पाठ के एक बड़े ब्लॉक में आईपी की खोज कर रहा है।

— नवीन

Answer 6

मैं एक Ipv6 विशेषज्ञ नहीं हूँ, लेकिन मुझे लगता है कि आप इस एक के साथ एक बहुत अच्छा परिणाम प्राप्त कर सकते हैं:

^([0-9A-Fa-f]{0,4}:){2,7}([0-9A-Fa-f]{1,4}$|((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4})$

जवाब देने के लिए "एक वैध ipv6 है" यह मुझे ठीक लगता है। इसे भागों में तोड़ने के लिए ... इसे भूल जाओ। मैंने अनिर्दिष्ट एक को छोड़ दिया है: (:) क्योंकि मेरे डेटाबेस में "अनिर्दिष्ट एड्रेस" का कोई उपयोग नहीं है।

शुरुआत: ^([0-9A-Fa-f]{0,4}:){2,7}<- संपीड़ित भाग से मेल खाते हैं, हम इसका अनुवाद इस तरह कर सकते हैं: 2 और 7 बृहदान्त्र के बीच जिनके पास हेक्साडेसिमल संख्या हो सकती है।

इसके बाद: [0-9A-Fa-f]{1,4}$<- एक हेक्साडेसिमल नंबर (प्रमुख 0 छोड़ा गया) या ((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4}<- एक आईपीवी 4 एड्रेस

Comments

+1 वास्तव में OPs प्रश्न से चिपके रहते हैं और कुछ हद तक काम करने वाले अपेक्षाकृत सुंदर रेक्स को प्रस्तुत करते हैं।

— xebeche

यह

— lsalamon

है ना? जावा रेगेक्स सिंटेक्स में यह मेल खाता है:start() = 0, end() = 3 group(0) = "::1" group(1) = ":" group(2) = "1" group(3) = "null" group(4) = "null" group(5) = "null"

— रेमी मोरिन

कहीं और किसी ने मुझे मेरे रेगेक्स के साथ एक समस्या की सूचना दी, संकुचित भाग "::" केवल एक बार दिखाई दे सकता है। इसलिए ":: 1 :: 2" मेरे रेगेक्स के साथ मेल खाएगा लेकिन यह एक वैध आईपीवी 6 नहीं है। एक दूसरा रेगेक्स इस मामले को मान्य कर सकता है। पूर्ण अनुशंसा को मान्य करने के लिए एक स्टेटफुल पार्सर का उपयोग करना था। मैं सहमत हूं कि परिणामी कोड को पढ़ना और बनाए रखना आसान होगा (और किसी ने शायद पहले से ही इसे एक खुले स्रोत में कहीं कोडित किया है)।

— रेमी मोरिन

Answer 7

यह लूपबैक (# 1) के साथ-साथ आईपीवी 6 पतों को भी पकड़ता है। परिवर्तित {} से + और डाल: पहले वर्ग ब्रैकेट के अंदर।

([a-f0-9:]+:+)+[a-f0-9]+

ifconfig -a आउटपुट http://regexr.com/ के साथ परीक्षण किया गया

यूनिक्स या मैक ओएसएक्स टर्मिनल ओ विकल्प केवल मिलान आउटपुट (IPv6) सहित :: 1 देता है

ifconfig -a | egrep -o '([a-f0-9:]+:+)+[a-f0-9]+'

सभी आईपी पते (आईपीवी 4 या आईपीवी 6) प्राप्त करें और यूनिक्स ओएसएक्स शब्द पर मैच प्रिंट करें

ifconfig -a | egrep -o '([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}) | (([a-f0-9:]+:+)+[a-f0-9]+)'

Comments

मुझे सादगी पसंद है। यह अंततः मेरे लिए काम किया:ip a | grep -Po '[\w:]+:+[\w:]+'

— नोआम मानोस

हास्य की सराहना की!

— सौम्य कांति

जब मैं ipconfig / all चलाता हूं, तो मेरा आईपी पता 10% के साथ समाप्त हो जाता है, यह अभिव्यक्ति इस भाग से मेल नहीं खाती है?

— पीटर

Answer 8

यह नियमित अभिव्यक्ति वैध IPv6 और IPv4 पतों का मिलान GNU C ++ के अनुसार रेगेक्स के कार्यान्वयन के साथ किया जाएगा, जिसका उपयोग किया गया REGULAR EXTENDED मोड के साथ होगा:

"^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:)))(%.+)?\s*$"

Answer 9

सावधान रहें! जावा में, InetAddress और संबंधित वर्गों (Inet4Address, Inet6Address, URL) के उपयोग से नेटवर्क ट्रैफ़िक शामिल हो सकता है! जैसे DNS रिज़ॉल्यूशन (URL.equals, स्ट्रिंग से InetAddress!)। यह कॉल लंबा हो सकता है और अवरुद्ध हो रहा है!

IPv6 के लिए मेरे पास कुछ ऐसा है। यह निश्चित रूप से IPv6 के बहुत सूक्ष्म विवरणों को नहीं संभालता है जैसे कि IPv6 पतों के कुछ वर्गों पर उस क्षेत्र के सूचकांकों की अनुमति है। और यह रेगेक्स ग्रुप कैप्चरिंग के लिए नहीं लिखा गया है, यह केवल एक "माचिस" है जो रेगेक्सपी है।

S - आईपीवी 6 खंड = [0-9a-f]{1,4}

I - आईपीवी 4 = (?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})

योजनाबद्ध (पहला भाग IPv4 पतों के साथ IPv6 पतों से मेल खाता है, दूसरा भाग IPv6 पतों से मेल खाता है, अंतिम बार जोन इंडेक्स सूचकांक:

(
(
::(S:){0,5}|
S::(S:){0,4}|
(S:){2}:(S:){0,3}|
(S:){3}:(S:){0,2}|
(S:){4}:(S:)?|
(S:){5}:|
(S:){6}
)
I

|

:(:|(:S){1,7})|
S:(:|(:S){1,6})|
(S:){2}(:|(:S){1,5})|
(S:){3}(:|(:S){1,4})|
(S:){4}(:|(:S){1,3})|
(S:){5}(:|(:S){1,2})|
(S:){6}(:|(:S))|
(S:){7}:|
(S:){7}S
)

(?:%[0-9a-z]+)?

और यहाँ रेगेक्स (केस असंवेदनशील हो सकता है, चारों ओर से जो कभी जरूरत हो जैसे लाइन की शुरुआत / समाप्ति, आदि):

(?:
(?:
::(?:[0-9a-f]{1,4}:){0,5}|
[0-9a-f]{1,4}::(?:[0-9a-f]{1,4}:){0,4}|
(?:[0-9a-f]{1,4}:){2}:(?:[0-9a-f]{1,4}:){0,3}|
(?:[0-9a-f]{1,4}:){3}:(?:[0-9a-f]{1,4}:){0,2}|
(?:[0-9a-f]{1,4}:){4}:(?:[0-9a-f]{1,4}:)?|
(?:[0-9a-f]{1,4}:){5}:|
(?:[0-9a-f]{1,4}:){6}
)
(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})\.){3}
(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})|

:(?::|(?::[0-9a-f]{1,4}){1,7})|
[0-9a-f]{1,4}:(?::|(?::[0-9a-f]{1,4}){1,6})|
(?:[0-9a-f]{1,4}:){2}(?::|(?::[0-9a-f]{1,4}){1,5})|
(?:[0-9a-f]{1,4}:){3}(?::|(?::[0-9a-f]{1,4}){1,4})|
(?:[0-9a-f]{1,4}:){4}(?::|(?::[0-9a-f]{1,4}){1,3})|
(?:[0-9a-f]{1,4}:){5}(?::|(?::[0-9a-f]{1,4}){1,2})|
(?:[0-9a-f]{1,4}:){6}(?::|(?::[0-9a-f]{1,4}))|
(?:[0-9a-f]{1,4}:){7}:|
(?:[0-9a-f]{1,4}:){7}[0-9a-f]{1,4}
)

(?:%[0-9a-z]+)?

Answer 10

Regex का अनुसरण केवल IPv6 के लिए है। समूह 1 आईपी के साथ मेल खाता है।

(([0-9a-fA-F]{0,4}:){1,7}[0-9a-fA-F]{0,4})

Comments

+1 यह हमेशा सही सुपर कॉम्प्लेक्स रेगेक्स होने के लिए आवश्यक नहीं है जो एक मानव समझ नहीं सकता है। मैं इसका उपयोग करूंगा क्योंकि मैं समझता हूं कि यह क्या करता है और मेरे मामले में, मुझे यकीन है कि अगर मुझे कुछ ऐसा मिला है जो एक मान्य आईपीवी 6 जैसा दिखता है, तो यह एक मान्य आईपीवी 6 है।

— डेविड एल।

यह मैच नहीं कहेगा: fe80 :: 1 या 2342: 32fd :: 2d32

— जेम्स

Answer 11

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

([A-Fa-f0-9]{1,4}::?){1,7}[A-Fa-f0-9]{1,4}

ध्यान दें कि यह पते में कहीं भी संपीड़न से मेल खाता है, हालांकि यह लूपबैक पते से मेल नहीं खाएगा :: 1। रीजेक्स को सरल रखने के लिए मुझे यह एक उचित समझौता लगता है।

मैं सफलतापूर्वक IPv6 पतों को क्लिक करने के लिए iTerm2 स्मार्ट चयन नियमों में इसका उपयोग करता हूं ।

Comments

तुम्हारा मतलब था A-F, नहीं A-Z! यह भी ध्यान दें कि आप डॉटेड-क्वाड नोटेशन को छोड़ रहे हैं।

— xebeche

Answer 12

यदि आप Perl try Net :: IPv6Addr का उपयोग करते हैं

use Net::IPv6Addr;

if( defined Net::IPv6Addr::is_ipv6($ip_address) ){
  print "Looks like an ipv6 address\n";
}

NetAddr :: आईपी

use NetAddr::IP;

my $obj = NetAddr::IP->new6($ip_address);

मान्य :: आईपी

use Validate::IP qw'is_ipv6';

if( is_ipv6($ip_address) ){
  print "Looks like an ipv6 address\n";
}

Comments

या डेटा :: मान्य :: IP search.cpan.org/~neely/Data-Validate-IP-0.11/lib/Data/Validate/… ।

— कैलिमो

Answer 13

में स्काला अच्छी तरह से ज्ञात अपाचे कॉमन्स प्रमाणकों का उपयोग करें।

http://mvnrepository.com/artifact/commons-validator/commons-validator/1.4.1

libraryDependencies += "commons-validator" % "commons-validator" % "1.4.1"


import org.apache.commons.validator.routines._

/**
 * Validates if the passed ip is a valid IPv4 or IPv6 address.
 *
 * @param ip The IP address to validate.
 * @return True if the passed IP address is valid, false otherwise.
 */  
 def ip(ip: String) = InetAddressValidator.getInstance().isValid(ip)

विधि की परीक्षा के बाद ip(ip: String):

"The `ip` validator" should {
  "return false if the IPv4 is invalid" in {
    ip("123") must beFalse
    ip("255.255.255.256") must beFalse
    ip("127.1") must beFalse
    ip("30.168.1.255.1") must beFalse
    ip("-1.2.3.4") must beFalse
  }

  "return true if the IPv4 is valid" in {
    ip("255.255.255.255") must beTrue
    ip("127.0.0.1") must beTrue
    ip("0.0.0.0") must beTrue
  }

  //IPv6
  //@see: http://www.ronnutter.com/ipv6-cheatsheet-on-identifying-valid-ipv6-addresses/
  "return false if the IPv6 is invalid" in {
    ip("1200::AB00:1234::2552:7777:1313") must beFalse
  }

  "return true if the IPv6 is valid" in {
    ip("1200:0000:AB00:1234:0000:2552:7777:1313") must beTrue
    ip("21DA:D3:0:2F3B:2AA:FF:FE28:9C5A") must beTrue
  }
}

Comments

दिलचस्प है, यह जांचने का दावा करता है कि यह एक वैध पता है, " यदि आईपी एक वैध आईपीवी 4 या वीवी 6 एड्रेस है तो वैध है। ", लेकिन यह वास्तव में केवल यह जांचता है कि यह वैध पते के रूप में स्वरूपित है। उदाहरण के लिए, 1200:0000:AB00:1234:0000:2552:7777:1313IPv6 पते के लिए एक मान्य प्रारूप है, लेकिन यह परीक्षण विधि के रिटर्न के रूप में मान्य IPv6 पता नहीं है। मुझे यकीन है कि 241.54.113.65यह एक मान्य IPv4 पता है।

— रॉन मूपिन

Answer 14

अन्य उत्तरों में शामिल पैटर्न को देखते हुए कई अच्छे पैटर्न हैं जिन्हें समूहों को संदर्भित करके और लुकाहेड्स का उपयोग करके सुधार किया जा सकता है। यहां एक पैटर्न का उदाहरण दिया गया है जो कि स्वयं संदर्भित है कि मैं PHP में उपयोग करूंगा यदि मुझे करना है:

^(?<hgroup>(?<hex>[[:xdigit:]]{0,4}) # grab a sequence of up to 4 hex digits
                                     # and name this pattern for usage later
     (?<!:::):{1,2})                 # match 1 or 2 ':' characters
                                     # as long as we can't match 3
 (?&hgroup){1,6} # match our hex group 1 to 6 more times
 (?:(?:
    # match an ipv4 address or
    (?<dgroup>2[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3}(?&dgroup)
    # match our hex group one last time
    |(?&hex))$

नोट: PHP में इसके लिए एक फ़िल्टर बनाया गया है जो इस पैटर्न की तुलना में बेहतर समाधान होगा।

Regex101 विश्लेषण

Answer 15

मैंने अजगर का उपयोग करके निम्नलिखित उत्पन्न किया और पुनः मॉड्यूल के साथ काम करता है। लुक-फ़ॉर फॉरवर्ड दावे यह सुनिश्चित करते हैं कि पते में डॉट्स या कॉलोन की सही संख्या दिखाई दे। यह IPv6 अंकन में IPv4 का समर्थन नहीं करता है।

pattern = '^(?=\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$)(?:(?:25[0-5]|[12][0-4][0-9]|1[5-9][0-9]|[1-9]?[0-9])\.?){4}$|(?=^(?:[0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}$)(?![^:]*::.+::[^:]*$)(?:(?=.*::.*)|(?=\w+:\w+:\w+:\w+:\w+:\w+:\w+:\w+))(?:(?:^|:)(?:[0-9a-f]{4}|[1-9a-f][0-9a-f]{0,3})){0,8}(?:::(?:[0-9a-f]{1,4}(?:$|:)){0,6})?$'
result = re.match(pattern, ip)
if result: result.group(0)

Answer 16

IPv6 के लिए Regexes वास्तव में मुश्किल हो सकता है जब आप एम्बेडेड ipv4 के पते और संपीड़ित होने वाले पते पर विचार करते हैं, जैसा कि आप इनमें से कुछ उत्तरों से देख सकते हैं।

ओपन-सोर्स IPAddress Java लाइब्रेरी IPv6 और IPv4 के सभी मानक अभ्यावेदन को मान्य करेगा और उपसर्ग-लंबाई (और इस तरह के सत्यापन) का भी समर्थन करता है। डिस्क्लेमर: मैं उस लाइब्रेरी का प्रोजेक्ट मैनेजर हूं।

कोड उदाहरण:

        try {
            IPAddressString str = new IPAddressString("::1");
            IPAddress addr = str.toAddress();
            if(addr.isIPv6() || addr.isIPv6Convertible()) {
                IPv6Address ipv6Addr = addr.toIPv6();
            }
            //use address
        } catch(AddressStringException e) {
            //e.getMessage has validation error
        }

Answer 17

जावा में, आप लाइब्रेरी क्लास का उपयोग कर सकते हैं sun.net.util.IPAddressUtil:

IPAddressUtil.isIPv6LiteralAddress(iPaddress);

Comments

sun.net। * निजी एपीआई है।

— डेविड कोचर

Answer 18

एक नियमित अभिव्यक्ति ढूंढना मुश्किल है जो सभी आईपीवी 6 मामलों के लिए काम करता है। वे आमतौर पर बनाए रखने के लिए कठिन होते हैं, आसानी से पठनीय नहीं होते हैं और प्रदर्शन समस्याओं का कारण बन सकते हैं। इसलिए, मैं एक वैकल्पिक समाधान साझा करना चाहता हूं जिसे मैंने विकसित किया है: IPv6 के लिए नियमित अभिव्यक्ति (RegEx) IPv4 से अलग

अब आप पूछ सकते हैं कि "यह विधि केवल IPv6 को ढूंढती है, मैं किसी पाठ या फ़ाइल में IPv6 कैसे ढूँढ सकता हूँ?" यहाँ इस मुद्दे के लिए तरीके भी हैं।

नोट : यदि आप .NET में IPAddress क्लास का उपयोग नहीं करना चाहते हैं, तो आप इसे मेरी विधि से भी बदल सकते हैं । यह मैप किए गए IPv4 और विशेष मामलों को भी कवर करता है, जबकि IPAddress कवर नहीं करता है।

class IPv6
{
    public List<string> FindIPv6InFile(string filePath)
    {
        Char ch;
        StringBuilder sbIPv6 = new StringBuilder();
        List<string> listIPv6 = new List<string>();
        StreamReader reader = new StreamReader(filePath);
        do
        {
            bool hasColon = false;
            int length = 0;

            do
            {
                ch = (char)reader.Read();

                if (IsEscapeChar(ch))
                    break;

                //Check the first 5 chars, if it has colon, then continue appending to stringbuilder
                if (!hasColon && length < 5)
                {
                    if (ch == ':')
                    {
                        hasColon = true;
                    }
                    sbIPv6.Append(ch.ToString());
                }
                else if (hasColon) //if no colon in first 5 chars, then dont append to stringbuilder
                {
                    sbIPv6.Append(ch.ToString());
                }

                length++;

            } while (!reader.EndOfStream);

            if (hasColon && !listIPv6.Contains(sbIPv6.ToString()) && IsIPv6(sbIPv6.ToString()))
            {
                listIPv6.Add(sbIPv6.ToString());
            }

            sbIPv6.Clear();

        } while (!reader.EndOfStream);
        reader.Close();
        reader.Dispose();

        return listIPv6;
    }

    public List<string> FindIPv6InText(string text)
    {
        StringBuilder sbIPv6 = new StringBuilder();
        List<string> listIPv6 = new List<string>();

        for (int i = 0; i < text.Length; i++)
        {
            bool hasColon = false;
            int length = 0;

            do
            {
                if (IsEscapeChar(text[length + i]))
                    break;

                //Check the first 5 chars, if it has colon, then continue appending to stringbuilder
                if (!hasColon && length < 5)
                {
                    if (text[length + i] == ':')
                    {
                        hasColon = true;
                    }
                    sbIPv6.Append(text[length + i].ToString());
                }
                else if (hasColon) //if no colon in first 5 chars, then dont append to stringbuilder
                {
                    sbIPv6.Append(text[length + i].ToString());
                }

                length++;

            } while (i + length != text.Length);

            if (hasColon && !listIPv6.Contains(sbIPv6.ToString()) && IsIPv6(sbIPv6.ToString()))
            {
                listIPv6.Add(sbIPv6.ToString());
            }

            i += length;
            sbIPv6.Clear();
        }

        return listIPv6;
    }

    bool IsEscapeChar(char ch)
    {
        if (ch != ' ' && ch != '\r' && ch != '\n' && ch!='\t')
        {
            return false;
        }

        return true;
    }

    bool IsIPv6(string maybeIPv6)
    {
        IPAddress ip;
        if (IPAddress.TryParse(maybeIPv6, out ip))
        {
            return ip.AddressFamily == AddressFamily.InterNetworkV6;
        }
        else
        {
            return false;
        }
    }

}

Answer 19

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

private static final String IPV4_BASIC_PATTERN_STRING =
        "(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){3}" + // initial 3 fields, 0-255 followed by .
         "([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])"; // final field, 0-255

private static final Pattern IPV4_PATTERN =
    Pattern.compile("^" + IPV4_BASIC_PATTERN_STRING + "$");

private static final Pattern IPV4_MAPPED_IPV6_PATTERN = // TODO does not allow for redundant leading zeros
        Pattern.compile("^::[fF]{4}:" + IPV4_BASIC_PATTERN_STRING + "$");

private static final Pattern IPV6_STD_PATTERN =
    Pattern.compile(
            "^[0-9a-fA-F]{1,4}(:[0-9a-fA-F]{1,4}){7}$");

private static final Pattern IPV6_HEX_COMPRESSED_PATTERN =
    Pattern.compile(
            "^(([0-9A-Fa-f]{1,4}(:[0-9A-Fa-f]{1,4}){0,5})?)" + // 0-6 hex fields
             "::" +
             "(([0-9A-Fa-f]{1,4}(:[0-9A-Fa-f]{1,4}){0,5})?)$"); // 0-6 hex fields 

Answer 20

रूबी का उपयोग कर? इसे इस्तेमाल करे:

/^(((?=.*(::))(?!.*\3.+\3))\3?|[\dA-F]{1,4}:)([\dA-F]{1,4}(\3|:\b)|\2){5}(([\dA-F]{1,4}(\3|:\b|$)|\2){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})\z/i

Answer 21

अपनी आवश्यकताओं के आधार पर, एक अनुमान:

[0-9a-f:]+

पर्याप्त हो सकता है (उदाहरण के लिए, सरल लॉग फ़ाइल ग्रीपिंग के साथ)

Answer 22

PHP के लिए 5.2+ उपयोगकर्ता filter_varबहुत अच्छा काम करते हैं।

मुझे पता है कि यह मूल प्रश्न (विशेष रूप से एक रेगेक्स समाधान) का जवाब नहीं देता है, लेकिन मैं इसे इस उम्मीद में पोस्ट करता हूं कि यह भविष्य में किसी और की मदद कर सकता है।

$is_ip4address = (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) !== FALSE);
$is_ip6address = (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) !== FALSE);

Answer 23

यह IPv4 और IPv6 के लिए काम करेगा:

^(([0-9a-f]{0,4}:){1,7}[0-9a-f]{1,4}|([0-9]{1,3}\.){3}[0-9]{1,3})$

Comments

यह 2 उदाहरणों के साथ अमान्य पतों से मेल खाता है ::। जैसे2404:6800::4003:c02::8a

— नाहद

मैच अवैध IPv4 666.666.666.666

— रयान विलियम्स

Answer 24

यहाँ जो मैंने देखा, वह थोड़ा सा लुकहेड और नामित समूहों का उपयोग करके आया है। यदि आप IPv4 जोड़ना चाहते हैं, तो यह निश्चित रूप से सिर्फ IPv6 है, लेकिन इसे अतिरिक्त पैटर्न में हस्तक्षेप नहीं करना चाहिए:

(?=([0-9a-f]+(:[0-9a-f])*)?(?P<wild>::)(?!([0-9a-f]+:)*:))(::)?([0-9a-f]{1,4}:{1,2}){0,6}(?(wild)[0-9a-f]{0,4}|[0-9a-f]{1,4}:[0-9a-f]{1,4})

Answer 25

आप इस उद्देश्य के लिए मेरे द्वारा बनाए गए ipextract खोल उपकरण का उपयोग कर सकते हैं । वे regexp और grep पर आधारित हैं।

उपयोग:

$ ifconfig | ipextract6
fe80::1%lo0
::1
fe80::7ed1:c3ff:feec:dee1%en0

Answer 26

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

^\[([0-9a-fA-F]{1,4})(\:{1,2})([0-9a-fA-F]{1,4})(\:{1,2})([0-9a-fA-F]{1,4})(\:{1,2})([0-9a-fA-F]{1,4})(\:{1,2})([0-9a-fA-F]{1,4})\]

जिंको का संस्करण सरल और बेहतर है जो मैं देख रहा हूं।

Answer 27

जैसा कि ऊपर कहा गया है, एक और तरीका है IPv6 पाठात्मक प्रतिनिधित्व को सत्यापित करने वाला पार्सर प्रोग्रामिंग का उपयोग करना है। यहाँ एक है जो RFC-4291 और RFC-5952 के साथ पूरी तरह से अनुपालन करता है। मैंने यह कोड ANSI C में लिखा है (GCC के साथ काम करता है, लिनक्स पर टेस्ट पास किया है - क्लैंग के साथ काम करता है, FreeBSD पर टेस्ट पास किया है)। इस प्रकार, यह केवल एएनएसआई सी मानक पुस्तकालय पर निर्भर करता है, इसलिए इसे हर जगह संकलित किया जा सकता है (मैंने इसका उपयोग आईपीवी 6 के लिए कर्नेल मॉड्यूल के अंदर पार्सिंग के लिए किया है)।

// IPv6 textual representation validating parser fully compliant with RFC-4291 and RFC-5952
// BSD-licensed / Copyright 2015-2017 Alexandre Fenyo

#include <string.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>

typedef enum { false, true } bool;

static const char hexdigits[] = "0123456789abcdef";
static int digit2int(const char digit) {
  return strchr(hexdigits, digit) - hexdigits;
}

// This IPv6 address parser handles any valid textual representation according to RFC-4291 and RFC-5952.
// Other representations will return -1.
//
// note that str input parameter has been modified when the function call returns
//
// parse_ipv6(char *str, struct in6_addr *retaddr)
// parse textual representation of IPv6 addresses
// str:     input arg
// retaddr: output arg
int parse_ipv6(char *str, struct in6_addr *retaddr) {
  bool compressed_field_found = false;
  unsigned char *_retaddr = (unsigned char *) retaddr;
  char *_str = str;
  char *delim;

  bzero((void *) retaddr, sizeof(struct in6_addr));
  if (!strlen(str) || strchr(str, ':') == NULL || (str[0] == ':' && str[1] != ':') ||
      (strlen(str) >= 2 && str[strlen(str) - 1] == ':' && str[strlen(str) - 2] != ':')) return -1;

  // convert transitional to standard textual representation
  if (strchr(str, '.')) {
    int ipv4bytes[4];
    char *curp = strrchr(str, ':');
    if (curp == NULL) return -1;
    char *_curp = ++curp;
    int i;
    for (i = 0; i < 4; i++) {
      char *nextsep = strchr(_curp, '.');
      if (_curp[0] == '0' || (i < 3 && nextsep == NULL) || (i == 3 && nextsep != NULL)) return -1;
      if (nextsep != NULL) *nextsep = 0;
      int j;
      for (j = 0; j < strlen(_curp); j++) if (_curp[j] < '0' || _curp[j] > '9') return -1;
      if (strlen(_curp) > 3) return -1;
      const long val = strtol(_curp, NULL, 10);
      if (val < 0 || val > 255) return -1;
      ipv4bytes[i] = val;
      _curp = nextsep + 1;
    }
    sprintf(curp, "%x%02x:%x%02x", ipv4bytes[0], ipv4bytes[1], ipv4bytes[2], ipv4bytes[3]);
  }

  // parse standard textual representation
  do {
    if ((delim = strchr(_str, ':')) == _str || (delim == NULL && !strlen(_str))) {
      if (delim == str) _str++;
      else if (delim == NULL) return 0;
      else {
        if (compressed_field_found == true) return -1;
        if (delim == str + strlen(str) - 1 && _retaddr != (unsigned char *) (retaddr + 1)) return 0;
        compressed_field_found = true;
        _str++;
        int cnt = 0;
        char *__str;
        for (__str = _str; *__str; ) if (*(__str++) == ':') cnt++;
        unsigned char *__retaddr = - 2 * ++cnt + (unsigned char *) (retaddr + 1);
        if (__retaddr <= _retaddr) return -1;
        _retaddr = __retaddr;
      }
    } else {
      char hexnum[4] = "0000";
      if (delim == NULL) delim = str + strlen(str);
      if (delim - _str > 4) return -1;
      int i;
      for (i = 0; i < delim - _str; i++)
        if (!isxdigit(_str[i])) return -1;
        else hexnum[4 - (delim - _str) + i] = tolower(_str[i]);
      _str = delim + 1;
      *(_retaddr++) = (digit2int(hexnum[0]) << 4) + digit2int(hexnum[1]);
      *(_retaddr++) = (digit2int(hexnum[2]) << 4) + digit2int(hexnum[3]);
    }
  } while (_str < str + strlen(str));
  return 0;
}

Answer 28

इस छोटे से एक-लाइनर का प्रयास करें। यह केवल वैध असम्पीडित / संकुचित IPv6 पतों (कोई IPv4 संकर) से मेल खाना चाहिए

/(?!.*::.*::)(?!.*:::.*)(?!:[a-f0-9])((([a-f0-9]{1,4})?[:](?!:)){7}|(?=(.*:[:a-f0-9]{1,4}::|^([:a-f0-9]{1,4})?::))(([a-f0-9]{1,4})?[:]{1,2}){1,6})[a-f0-9]{1,4}/

Comments

वास्तव में, मान्य IPv6 पतों में असम्पीडित, संपीड़ित, असम्पीडित-संकर और संपीड़ित हाइब्रिड शामिल हैं। यह वास्तव में एक बहुत कुछ लेता है जो आपको वास्तव में आईपीवी 6 पते के किसी भी मान्य पाठ प्रतिनिधित्व से मेल खाता है।

— रॉन मौपिन

Answer 29

रेगेक्स IPv4 भागों में अग्रणी शून्य के उपयोग की अनुमति देता है।

कुछ यूनिक्स और मैक डिस्ट्रो उन सेगमेंट को ऑक्टल्स में बदल देते हैं।

मैं 25[0-5]|2[0-4]\d|1\d\d|[1-9]?\dIPv4 सेगमेंट के रूप में उपयोग करने का सुझाव देता हूं ।

Answer 30

यदि आप केवल सामान्य IP-s (कोई स्लैश) नहीं चाहते हैं, तो यहां:

^(?:[0-9a-f]{1,4}(?:::)?){0,7}::[0-9a-f]+$

मैं मेजबान फ़ाइल संपादक अनुप्रयोग में अपने सिंटैक्स हाइलाइटर के लिए इसका उपयोग करता हूं। आकर्षण के रूप में काम करता है।

Comments

कोई तरीका नहीं है कि यह कभी भी शालीनता से काम करता है, यह एक एकल कोलोन के साथ एक एकल ipv6 पते से मेल नहीं खा सकता है, आपके सभी मैच डबल कॉलन पर हैं, और आपको स्पष्ट रूप से अपने अंतिम समूह के लिए एक डबल कोलन की आवश्यकता है, सारांश कहीं भी हो सकता है .. ।

— किलियनड्स

(?: [0-9a-f] {1,4} (? :::?)? {0,7} ... -? [0-9a-f] {1,4}

— हैरी

फिर भी गलत है, लेकिन फिर भी आप जिन्नाको के जवाब को दोहराएंगे, जो सरल उद्देश्यों के लिए काफी अच्छा है, लेकिन फिर भी खामियां हैं (दोहरे सारांश को नहीं पकड़ता है और न ही बिंदीदार quads, और न ही लोकलहोस्ट, और न ही :: समाप्ति) की अनुमति देता है। ..)

— किलियनडीएस