DNS होस्टनाम या आईपी एड्रेस से मिलान करने के लिए नियमित अभिव्यक्ति?

Question

क्या किसी के पास एक नियमित अभिव्यक्ति कार्य है जो किसी भी कानूनी DNS होस्टनाम या आईपी पते से मेल खाएगा?

यह लिखना आसान है जो 95% काम करता है, लेकिन मैं कुछ ऐसा पाने की उम्मीद कर रहा हूं जो DNS होस्टनाम के लिए नवीनतम RFC चश्मा से पूरी तरह मेल खाता हो।

Answer 1

आप निम्नलिखित नियमित अभिव्यक्तियों को अलग-अलग या संयुक्त या अभिव्यक्ति में जोड़कर उपयोग कर सकते हैं।

ValidIpAddressRegex = "^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$";

ValidHostnameRegex = "^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$";

ValidIpAddressRegex मान्य IP पते और ValidHostnameRegex मान्य होस्ट नामों से मेल खाता है । आपके द्वारा उपयोग की जाने वाली भाषा के आधार पर \ _ के साथ भाग जाना पड़ सकता है।

---

ValidHostnameRegex RFC 1123 के अनुसार मान्य है । मूल रूप से, RFC 952 ने निर्दिष्ट किया कि hostname सेगमेंट एक अंक से शुरू नहीं हो सकता है।

http://en.wikipedia.org/wiki/Hostname

RFC 952 में होस्टनामों का मूल विनिर्देश , यह अनिवार्य है कि लेबल एक अंक या एक हाइफ़न के साथ शुरू नहीं कर सकते हैं, और एक हाइफ़न के साथ समाप्त नहीं होना चाहिए। हालाँकि, बाद के विनिर्देशन ( RFC 1123 ) ने होस्टनाम लेबल को अंकों के साथ शुरू करने की अनुमति दी।

Valid952HostnameRegex = "^(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])$";

Comments

यहाँ: stackoverflow.com/questions/4645126/… - मैं समझाता हूँ कि एक अंक से शुरू होने वाले नामों को भी मान्य माना जाता है। इसके अलावा, केवल एक बिंदु ही संदिग्ध मुद्दा है। उस पर और अधिक प्रतिक्रिया के लिए बहुत अच्छा होगा।

— ब्रेकफ्रीक

आप IPv6 जोड़ना चाह सकते हैं। ओपी ने यह नहीं बताया कि किस प्रकार का पता है। (वैसे, यह यहाँ पाया जा सकता है )

— new123456

इससे पहले कि लोग नेत्रहीन अपने कोड में इसका उपयोग करें, ध्यान दें कि यह पूरी तरह से सही नहीं है। यह RFC2181 को नजरअंदाज करता है: "DNS स्वयं विशेष लेबल पर केवल एक प्रतिबंध लगाता है जिसका उपयोग संसाधन रिकॉर्ड की पहचान करने के लिए किया जा सकता है। यह प्रतिबंध लेबल की लंबाई और पूर्ण नाम से संबंधित है। किसी एक लेबल की लंबाई के बीच सीमित है। 1 और 63 ऑक्टेट। एक पूर्ण डोमेन नाम 255 ऑक्टेट (विभाजकों सहित) तक सीमित है। "

— रूबल

@UserControl: गैर-लैटिन (पुनर्नवीनीकरण) होस्टनाम को पहले ASCII रूप में परिवर्तित किया जाना चाहिए ( éxämplè.com= xn--xmpl-loa1ab.com) और फिर मान्य किया गया।

— एलिक्स एक्सल

आपकी होस्टनाम अभिव्यक्ति कुछ अमान्य मूल्यों से मेल खा रही है: मैंने कोशिश की 123.456.789.0और यह कहता है कि यह एक मान्य होस्टनाम है।

— लबरेरा

Answer 2

स्मिंक के होस्टनाम रेगेक्स एक होस्टनाम के भीतर व्यक्तिगत लेबल की लंबाई पर सीमा का निरीक्षण नहीं करता है। एक मान्य होस्टनाम के भीतर प्रत्येक लेबल 63 ओकटेट्स से अधिक लंबा नहीं हो सकता है।

ValidHostnameRegex = "^ ([एक-zA-Z0-9] | [एक-zA-Z0-9] [एक-zA-Z0-9 \ -] {0,61} [एक-zA-Z0-9]) \
(\ ([एक-zA-Z0-9] |। [एक-zA-Z0-9] [एक-zA-Z0-9 \ -] {0,61} [एक-zA-Z0-9])) * $ "

ध्यान दें कि पहली पंक्ति के अंत में (ऊपर) बैकस्लैश लंबी लाइन को विभाजित करने के लिए यूनिक्स शेल सिंटैक्स है। यह स्वयं नियमित अभिव्यक्ति का हिस्सा नहीं है।

यहाँ एक लाइन पर केवल नियमित अभिव्यक्ति है:

^ ([एक-zA-Z0-9] | [एक-zA-Z0-9] [एक-zA-Z0-9 \ -] {0,61} [एक-zA-Z0-9]) (\। ([एक-zA-Z0-9] | [एक-zA-Z0-9] [एक-zA-Z0-9 \ -] {0,61} [एक-zA-Z0-9])) * $

आपको अलग से यह भी जांचना चाहिए कि होस्टनाम की कुल लंबाई 255 वर्णों से अधिक नहीं होनी चाहिए । अधिक जानकारी के लिए, कृपया RFC-952 और RFC-1123 से परामर्श करें।

Comments

उत्कृष्ट मेजबान पैटर्न। यह शायद किसी की भाषा के रेगेक्स कार्यान्वयन पर निर्भर करता है, लेकिन जेएस के लिए इसे कुछ भी खोए बिना संक्षिप्त किया जा सकता है:/^[a-z\d]([a-z\d\-]{0,61}[a-z\d])?(\.[a-z\d]([a-z\d\-]{0,61}[a-z\d])?)*$/i

— सेमीकॉलन

Answer 3

मान्य IP पते से मिलान करने के लिए निम्नलिखित regex का उपयोग करें:

(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}

के बजाय:

([01]?[0-9][0-9]?|2[0-4][0-9]|25[0-5])(\.([01]?[0-9][0-9]?|2[0-4][0-9]|25[0-5])){3}

व्याख्या

कई रेगेक्स इंजन ORअनुक्रम में पहली संभावना से मेल खाते हैं । उदाहरण के लिए, निम्न regex का प्रयास करें:

10.48.0.200

परीक्षा

अच्छे बनाम बुरे के बीच अंतर का परीक्षण करें

Comments

स्टार्ट ^ और एंड $ को मत भूलना या 0.0.0.999 या 999.0.0.0 जैसी कोई चीज भी मेल खाएगी। ;)

— एंड्रियास

हाँ एक स्ट्रिंग प्रारंभ को मान्य करने के लिए ^ और अंत $ की आवश्यकता होती है, लेकिन यदि आप एक आईपी को एक पाठ में खोज रहे हैं तो इसका उपयोग न करें।

— अल्बान

अनजाने में 'गैर-लालची' जिसे आप पहचानते हैं, दूसरे होस्ट नाम समाधानों पर भी लागू होता है। यह आपके उत्तर में जोड़ने के लायक होगा क्योंकि अन्य पूर्ण होस्टनाम से मेल नहीं खाएंगे। जैसे ([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])(\.([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]))*बनाम([a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]|[a-zA-Z0-9])(\.([a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])|[a-zA-Z0-9]))*

— ergohack

EDIT: उपरोक्त में, विफलता को देखने के +बजाय अंत में उपयोग करें *।

— इगोरहॉक

Answer 4

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

Hostname के लिए - आसान जवाब, egrep उदाहरण पर यहाँ - http: //www.linuxinsight.com/how_to_grep_for_ip_addresses_using_the_gnu_egrep_utility.html

egrep '([[:digit:]]{1,3}\.){3}[[:digit:]]{1,3}'

हालांकि मामला मुट्ठी ओक्टेट में 0 जैसे मूल्यों के लिए जिम्मेदार नहीं है, और 254 (आईपी एडरेस) या 255 (नेटमास्क) से अधिक मूल्य है। शायद एक अतिरिक्त अगर बयान में मदद मिलेगी।

जैसा कि कानूनी डीएनएस होस्टनाम के लिए है, बशर्ते कि आप केवल इंटरनेट होस्टनाम के लिए जाँच कर रहे हैं (और इंट्रानेट नहीं), मैंने निम्नलिखित स्निप, शेल / पीएचपी का मिश्रण लिखा है लेकिन यह किसी भी नियमित अभिव्यक्ति के रूप में लागू होना चाहिए।

पहले ietf वेबसाइट पर जाएं, कानूनी स्तर 1 डोमेन नामों की सूची डाउनलोड करें और पार्स करें:

tld=$(curl -s http://data.iana.org/TLD/tlds-alpha-by-domain.txt |  sed 1d  | cut -f1 -d'-' | tr '\n' '|' | sed 's/\(.*\)./\1/')
echo "($tld)"

आपको आपको एक अच्छा कोड देना चाहिए जो कि टॉप डोमेन नाम की वैधानिकता के लिए जाँच करता है, जैसे .com .org या .ca

फिर यहां मिले दिशानिर्देशों के अनुसार अभिव्यक्ति का पहला भाग जोड़ें - http: //www.domainit.com/support/faq.mhtml?category=Domain_FAQ&question=9 (कोई भी अल्फ़ान्यूमेरिक संयोजन और '-' प्रतीक, डैश में नहीं होना चाहिए एक ओकटेट की शुरुआत या अंत।

(([a-z0-9]+|([a-z0-9]+[-]+[a-z0-9]+))[.])+

फिर इसे एक साथ रखें (PHP preg_match उदाहरण):

$pattern = '/^(([a-z0-9]+|([a-z0-9]+[-]+[a-z0-9]+))[.])+(AC|AD|AE|AERO|AF|AG|AI|AL|AM|AN|AO|AQ|AR|ARPA|AS|ASIA|AT|AU|AW|AX|AZ|BA|BB|BD|BE|BF|BG|BH|BI|BIZ|BJ|BM|BN|BO|BR|BS|BT|BV|BW|BY|BZ|CA|CAT|CC|CD|CF|CG|CH|CI|CK|CL|CM|CN|CO|COM|COOP|CR|CU|CV|CX|CY|CZ|DE|DJ|DK|DM|DO|DZ|EC|EDU|EE|EG|ER|ES|ET|EU|FI|FJ|FK|FM|FO|FR|GA|GB|GD|GE|GF|GG|GH|GI|GL|GM|GN|GOV|GP|GQ|GR|GS|GT|GU|GW|GY|HK|HM|HN|HR|HT|HU|ID|IE|IL|IM|IN|INFO|INT|IO|IQ|IR|IS|IT|JE|JM|JO|JOBS|JP|KE|KG|KH|KI|KM|KN|KP|KR|KW|KY|KZ|LA|LB|LC|LI|LK|LR|LS|LT|LU|LV|LY|MA|MC|MD|ME|MG|MH|MIL|MK|ML|MM|MN|MO|MOBI|MP|MQ|MR|MS|MT|MU|MUSEUM|MV|MW|MX|MY|MZ|NA|NAME|NC|NE|NET|NF|NG|NI|NL|NO|NP|NR|NU|NZ|OM|ORG|PA|PE|PF|PG|PH|PK|PL|PM|PN|PR|PRO|PS|PT|PW|PY|QA|RE|RO|RS|RU|RW|SA|SB|SC|SD|SE|SG|SH|SI|SJ|SK|SL|SM|SN|SO|SR|ST|SU|SV|SY|SZ|TC|TD|TEL|TF|TG|TH|TJ|TK|TL|TM|TN|TO|TP|TR|TRAVEL|TT|TV|TW|TZ|UA|UG|UK|US|UY|UZ|VA|VC|VE|VG|VI|VN|VU|WF|WS|XN|XN|XN|XN|XN|XN|XN|XN|XN|XN|XN|YE|YT|YU|ZA|ZM|ZW)[.]?$/i';

    if (preg_match, $pattern, $matching_string){
    ... do stuff
    }

आप उस स्ट्रिंग को जाँचने के लिए एक स्टेटमेंट जोड़ना चाह सकते हैं, जिसे आप चेक कर रहे हैं जो 256 अक्षरों से छोटा है - http://www.ops.ietf.org/lists/ameroppers/ameroppers.2003/msg00964.html

Comments

-1 क्योंकि यह "999.999.999.999" जैसे फर्जी आईपी पते से मेल खाता है।

— ब्रेडशाम

"हालांकि मामला मुट्ठी ओक्टेट में 0 जैसे मूल्यों के लिए जिम्मेदार नहीं है, और 254 (आईपी एडरेस) या 255 (नेटमास्क) से अधिक मूल्य है।"

— एलेक्स वोल्कोव

मैंने देखा कि आपने अपना उत्तर प्राप्त कर लिया है, हाँ। मैंने अस्वीकार कर दिया क्योंकि आपके उत्तर का वह भाग अभी भी उपयोगी नहीं है।

— bdesham

Answer 5

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

उदाहरण के लिए, (POSIX) C में IPv4 का पता लगाना और पार्स करना:

#include <arpa/inet.h>
#include <stdio.h>

int main(int argc, char *argv[]) {
  for (int i=1; i!=argc; ++i) {
    struct in_addr addr = {0};
    printf("%s: ", argv[i]);
    if (inet_pton(AF_INET, argv[i], &addr) != 1)
      printf("invalid\n");
    else
      printf("%u\n", addr.s_addr);
  }
  return 0;
}

---

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

उदाहरण के लिए, पायथन में:

>>> import ipaddress
>>> import re
>>> msg = "My address is 192.168.0.42; 192.168.0.420 is not an address"
>>> for maybeip in re.findall(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', msg):
...     try:
...         print(ipaddress.ip_address(maybeip))
...     except ValueError:
...         pass

Answer 6

def isValidHostname(hostname):

    if len(hostname) > 255:
        return False
    if hostname[-1:] == ".":
        hostname = hostname[:-1]   # strip exactly one dot from the right,
                                   #  if present
    allowed = re.compile("(?!-)[A-Z\d-]{1,63}(?<!-)$", re.IGNORECASE)
    return all(allowed.match(x) for x in hostname.split("."))

Comments

आप इस regex की व्याख्या कर सकते हैं? वास्तव में, क्या (? -!), (? <-!) का अर्थ है?

— Scit

@Scit, जो यह सुनिश्चित करते हैं कि यह एक "-" चरित्र के साथ शुरू या समाप्त नहीं होता है यदि आपका regex इंजन उनके उपयोग की अनुमति देता है। उदाहरण के लिए, पायथन से या पर्ल से ।

— YLearn

Answer 7

मुझे लगता है कि यह सबसे अच्छा आईपी सत्यापन रेगेक्स है। कृपया इसे एक बार जांच लें !!!

^(([01]?[0-9]?[0-9]|2([0-4][0-9]|5[0-5]))\.){3}([01]?[0-9]?[0-9]|2([0-4][0-9]|5[0-5]))$

Answer 8

"^((\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])\.){3}(\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])$"

Answer 9

यह मान्य IP पतों के लिए काम करता है:

regex = '^([0-9]|[1-9][0-9]|[1][0-9][0-9]|[2][0-5][0-5])[.]([0-9]|[1-9][0-9]|[1][0-9][0-9]|[2][0-5][0-5])[.]([0-9]|[1-9][0-9]|[1][0-9][0-9]|[2][0-5][0-5])[.]([0-9]|[1-9][0-9]|[1][0-9][0-9]|[2][0-5][0-5])$'

Answer 10

/^(?:[a-zA-Z0-9]+|[a-zA-Z0-9][-a-zA-Z0-9]+[a-zA-Z0-9])(?:\.[a-zA-Z0-9]+|[a-zA-Z0-9][-a-zA-Z0-9]+[a-zA-Z0-9])?$/

Answer 11

यहाँ एक regex है जो मैंने Ant में इस्तेमाल किया था एक प्रॉक्सी होस्ट IP या ANT_OPTS से होस्टनाम होस्ट करने के लिए। इसका उपयोग प्रॉक्सी आईपी प्राप्त करने के लिए किया गया था ताकि मैं कांटे वाले JVM के लिए प्रॉक्सी कॉन्फ़िगर करने से पहले एक चींटी "पहुंच योग्य" परीक्षण चला सकूं।

^.*-Dhttp\.proxyHost=(\w{1,}\.\w{1,}\.\w{1,}\.*\w{0,})\s.*$

Comments

यह \wवहीं है, यह आईपी पर कब्जा नहीं करेगा, केवल कुछ परिस्थितियों में होस्टनाम।

— यारॉन

Answer 12

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

(?! <\ एस)? (: (: \ घ | [1-9] \ घ | 1 \ घ \ घ | 2 [0-4] \ घ | 25 [0-5]) \ ख |। \ ख) {7} (?! \ एस)

Comments

मैंने बहुत कोशिश की लेकिन मैं यहां 2 चीजों को समझ नहीं पाया। 1. \ b शब्द सीमा निर्दिष्ट करता है हम \ b का उपयोग क्यों कर रहे हैं? सीमा कौन सी है? और 2. यह केवल {7} के लिए ही क्यों काम करता है जो मैंने समझा था, मुझे लगता है कि यह {4} होना चाहिए लेकिन, यह काम नहीं कर रहा है। वैकल्पिक रूप से, आप इस बारे में बता सकते हैं कि आप गैर-कैप्चरिंग ब्लॉक का उपयोग क्यों कर रहे हैं।

— श्रीचक्रधर

Answer 13

AddressRegex = "^(ftp|http|https):\/\/([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}:[0-9]{1,5})$";

HostnameRegex =  /^(ftp|http|https):\/\/([a-z0-9]+\.)?[a-z0-9][a-z0-9-]*((\.[a-z]{2,6})|(\.[a-z]{2,6})(\.[a-z]{2,6}))$/i

यह पुनः इस प्रकार के सत्यापन के लिए उपयोग किया जाता है

अगर केवल http://www.kk.com http://www.kk.co.in

के लिए काम नहीं करता है

http://www.kk.com/ http: //www.kk.co.in.kk

http://www.kk.com/dfas http://www.kk.co.in/

Answer 14

इसे इस्तेमाल करे:

((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)

यह मेरे मामले में काम करता है।

Answer 15

आईपी ​​पते के बारे में, ऐसा प्रतीत होता है कि अग्रणी शून्य को शामिल करने के लिए कुछ बहस है। यह एक बार आम प्रथा थी और इसे आमतौर पर स्वीकार किया जाता है, इसलिए मैं यह तर्क दूंगा कि उन्हें वर्तमान वरीयता की परवाह किए बिना मान्य रूप में चिह्नित किया जाना चाहिए । इस बात पर भी कुछ अस्पष्टता है कि क्या स्ट्रिंग से पहले और बाद के पाठ को मान्य किया जाना चाहिए और, फिर से, मुझे लगता है कि यह होना चाहिए। 1.2.3.4 एक वैध आईपी है, लेकिन 1.2.3.4.5 नहीं है और न ही 1.2.3.4 भाग और न ही 2.3.4.5 भाग का मिलान होना चाहिए। कुछ चिंताओं को इस अभिव्यक्ति के साथ संभाला जा सकता है:

grep -E '(^|[^[:alnum:]+)(([0-1]?[0-9]{1,2}|2[0-4][0-9]|25[0-5])\.){3}([0-1]?[0-9]{1,2}|2[0-4][0-9]|25[0-5])([^[:alnum:]]|$)' 

यहाँ दुर्भाग्यपूर्ण तथ्य यह है कि रेगेक्स भाग जो एक ओकटेट को मान्य करता है, दोहराया जाता है, जो कई प्रस्तावित समाधानों में सच है। यद्यपि यह पैटर्न के उदाहरणों के लिए बेहतर है, पुनरावृत्ति का इस्तेमाल होने पर सबटूटिन का समर्थन करने पर पुनरावृत्ति को पूरी तरह से समाप्त किया जा सकता है। अगला उदाहरण उन कार्यों को -Pस्विच के साथ सक्षम करता है grepऔर लुकहेड और लुकबाइंड कार्यक्षमता का लाभ भी उठाता है। (मैंने जो फ़ंक्शन नाम चुना है, वह ओकटेट के लिए 'ओ' है। मैं नाम के रूप में 'ऑक्टेट' का उपयोग कर सकता था, लेकिन इसका छंद बनना चाहता था।)

grep -P '(?<![\d\w\.])(?<o>([0-1]?[0-9]{1,2}|2[0-4][0-9]|25[0-5]))(\.\g<o>){3}(?![\d\w\.])'

डॉट का हैंडलिंग वास्तव में एक गलत नकारात्मक बना सकता है अगर आईपी पते वाक्यों के रूप में पाठ के साथ एक फ़ाइल में हैं क्योंकि एक अवधि बिंदीदार नोटेशन का हिस्सा होने के बिना एक अवधि का पालन कर सकती है। उपरोक्त का एक प्रकार यह तय करेगा कि:

grep -P '(?<![\d\w\.])(?<x>([0-1]?[0-9]{1,2}|2[0-4][0-9]|25[0-5]))(\.\g<x>){3}(?!([\d\w]|\.\d))'

Answer 16

>>> my_hostname = "testhostn.ame"
>>> print bool(re.match("^(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])$", my_hostname))
True
>>> my_hostname = "testhostn....ame"
>>> print bool(re.match("^(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])$", my_hostname))
False
>>> my_hostname = "testhostn.A.ame"
>>> print bool(re.match("^(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])$", my_hostname))
True

Answer 17

नए नेटवर्क ढांचे में संरचित IPv4Address और संरचित IPv6Address के लिए प्रारंभिक आरम्भक हैं जो बहुत आसानी से IP पता भाग को संभालते हैं। IPv6 में regex के साथ ऐसा करना सभी छोटे नियमों के साथ कठिन है।

दुर्भाग्य से मैं hostname के लिए एक सुंदर जवाब नहीं है।

ध्यान दें कि नेटवर्क फ्रेमवर्क हाल ही में है, इसलिए यह आपको हाल के OS संस्करणों के लिए संकलन करने के लिए मजबूर कर सकता है।

import Network
let tests = ["192.168.4.4","fkjhwojfw","192.168.4.4.4","2620:3","2620::33"]

for test in tests {
    if let _ = IPv4Address(test) {
        debugPrint("\(test) is valid ipv4 address")
    } else if let _ = IPv6Address(test) {
        debugPrint("\(test) is valid ipv6 address")
    } else {
        debugPrint("\(test) is not a valid IP address")
    }
}

output:
"192.168.4.4 is valid ipv4 address"
"fkjhwojfw is not a valid IP address"
"192.168.4.4.4 is not a valid IP address"
"2620:3 is not a valid IP address"
"2620::33 is valid ipv6 address"

Answer 18

इस बारे में कैसा है?

([0-9]{1,3}\.){3}[0-9]{1,3}

Comments

और ऐसा है 9999999999.0.0.9999999999 :) लेकिन अधिकांश प्रोग्रामर के लिए, यह छोटा दृष्टिकोण पर्याप्त होगा।

— andreas

-1 क्योंकि यह बकवास आईपी पते (@Shebuka नोट्स के रूप में) से मेल खाता है।

— ब्रेडशाम

Answer 19

php पर: filter_var(gethostbyname($dns), FILTER_VALIDATE_IP) == true ? 'ip' : 'not ip'

Comments

हालांकि यह कोड प्रश्न का उत्तर दे सकता है, आमतौर पर कोड के साथ स्पष्टीकरण एक उत्तर को अधिक उपयोगी बनाता है। कृपया अपना उत्तर संपादित करें और कुछ संदर्भ और स्पष्टीकरण प्रदान करें ।

— user4642212

और, जब तक मैं गलत नहीं हूँ, तब तक FILTER_VALIDATE_IP एक PHP केवल मान है।

— 23

Answer 20

होस्ट नामों के लिए जाँच कर रहा है ... mywebsite.co.in, thangaraj.name, 18thangaraj.in, thangarajad.in, आदि।

[a-z\d+].*?\\.\w{2,4}$

Comments

-1। ओपी ने कुछ "अच्छी तरह से नवीनतम आरएफसी चश्मा से मिलान करने के लिए परीक्षण" के लिए कहा, लेकिन यह * .मुजबूत से मेल नहीं खाता, जबकि यह * .foo से मेल खाएगा। यहां वैध TLD की सूची दी गई है।

— ब्रेडशाम 15

मुझे यकीन नहीं है कि चरित्र वर्ग (वर्ग कोष्ठक) के अंदर प्लस रखना एक अच्छा विचार है, इसके अलावा, 5 अक्षरों वाले टीएलडी हैं ( उदाहरण के लिए -expert )।

— यार्न

RFC के साथ पूरा करने का सबसे अच्छा तरीका सिस्टम / भाषा फ़ंक्शन का उपयोग करना है। inet_atonकाफी अच्छा है

— m3nda

Answer 21

मैंने IP पते के लिए इस सरल रेगेक्स मिलान पैटर्न के बारे में सोचा था जो \ d [[।] \ D + [।] \ D + [।] \ D + से मेल खाता है।

Comments

1111.1.1.1 एक वैध आईपी नहीं है। यदि आप सबनेट के बारे में ध्यान नहीं रखते हैं तो वास्तव में एक आईपी प्रारूप का परीक्षण करने का कोई तरीका नहीं है। आपको कम से कम कुछ के साथ दिखावे की संख्या के बारे में ध्यान रखना चाहिए ^\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}और निश्चित रूप से यह सही तरीका नहीं होगा। यदि आपके पास स्क्रिप्ट लिखने के लिए एक समस्या है, तो सुनिश्चित करें कि आपके पास इसके नेटवर्क कार्यों तक पहुंच होगी। REAL IP को चेक करने का सबसे अच्छा तरीका यह है कि सिस्टम को कन्वर्ट करने के लिए और ip को सही फॉर्मेट में बताने के लिए इसे सही / गलत की जाँच करें। पायथन के मामले में मैं उपयोग करता हूं socket.inet_aton(ip)। पीएचपी का मामला यू जरूरत inet_aton($ip)।

— m3nda

अजगर उपयोगकर्ता यहाँ देख सकते हैं: gist.github.com/erm3nda/f25439bba66931d3ca9699b2816e796c

— m3nda