Regulärer Ausdruck, der dem DNS-Hostnamen oder der IP-Adresse entspricht?

369

Hat jemand einen regulären Ausdruck zur Hand, der mit einem legalen DNS-Hostnamen oder einer IP-Adresse übereinstimmt?

Es ist einfach, eine zu schreiben, die in 95% der Fälle funktioniert, aber ich hoffe, dass etwas gut getestet wird, das genau den neuesten RFC-Spezifikationen für DNS-Hostnamen entspricht.

DonGar
quelle

Antworten:

535

Sie können die folgenden regulären Ausdrücke separat oder durch Kombinieren in einem gemeinsamen ODER-Ausdruck verwenden.

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 Spiele gültige IP - Adressen und ValidHostnameRegex gültige Hostnamen. Abhängig von der verwendeten Sprache muss \ möglicherweise mit \ maskiert werden.


ValidHostnameRegex ist gemäß RFC 1123 gültig . Ursprünglich gab RFC 952 an, dass Hostnamensegmente nicht mit einer Ziffer beginnen dürfen.

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

Die ursprüngliche Spezifikation von Hostnamen in RFC 952 sah vor , dass Beschriftungen nicht mit einer Ziffer oder einem Bindestrich beginnen dürfen und nicht mit einem Bindestrich enden dürfen. Eine nachfolgende Spezifikation ( RFC 1123 ) erlaubte jedoch, dass Hostnamenbezeichnungen mit Ziffern beginnen.

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])$";
Jorge Ferreira
quelle
3
Hier: stackoverflow.com/questions/4645126/… - Ich erkläre, dass Namen, die mit einer Ziffer beginnen, ebenfalls als gültig angesehen werden. Auch ist nur ein Punkt fraglich. Wäre toll, mehr Feedback dazu zu haben.
BreakPhreak
16
Möglicherweise möchten Sie IPv6 hinzufügen. Das OP hat nicht angegeben, welche Art von Adresse. (Übrigens kann es hier gefunden werden )
new123456
32
Bevor Benutzer dies blind in ihrem Code verwenden, beachten Sie, dass es nicht vollständig korrekt ist. RFC2181 wird ignoriert: "Der DNS selbst legt nur eine Einschränkung für die bestimmten Labels fest, mit denen Ressourceneinträge identifiziert werden können. Diese eine Einschränkung bezieht sich auf die Länge des Labels und den vollständigen Namen. Die Länge eines Labels ist auf zwischen begrenzt 1 und 63 Oktette. Ein vollständiger Domainname ist auf 255 Oktette (einschließlich der Trennzeichen) beschränkt. "
Rubel
7
@UserControl: Nicht-lateinische (punycodierte) Hostnamen müssen zuerst ( éxämplè.com= xn--xmpl-loa1ab.com) in die ASCII-Form konvertiert und dann validiert werden.
Alix Axel
6
Ihr Hostname-Ausdruck stimmt mit einigen ungültigen Werten überein: Ich habe es versucht 123.456.789.0und es heißt, es ist ein gültiger Hostname.
Lbarreira
62

Der reguläre Ausdruck des Sminks für den Hostnamen beachtet nicht die Beschränkung der Länge einzelner Labels innerhalb eines Hostnamens. Jedes Label innerhalb eines gültigen Hostnamens darf nicht länger als 63 Oktette sein.

ValidHostnameRegex = "^ ([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])) * $ "

Beachten Sie, dass der Backslash am Ende der ersten Zeile (oben) die Unix-Shell-Syntax zum Teilen der langen Zeile ist. Es ist kein Teil des regulären Ausdrucks.

Hier ist nur der reguläre Ausdruck in einer einzelnen Zeile:

^ ([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])) * $

Sie sollten auch separat prüfen, ob die Gesamtlänge des Hostnamens 255 Zeichen nicht überschreiten darf . Weitere Informationen finden Sie in RFC-952 und RFC-1123.

Sakari A. Maaranen
quelle
6
Ausgezeichnetes Host-Muster. Es hängt wahrscheinlich von der Regex-Implementierung der eigenen Sprache ab, aber für JS kann es leicht angepasst werden, um kürzer zu sein, ohne etwas zu verlieren:/^[a-z\d]([a-z\d\-]{0,61}[a-z\d])?(\.[a-z\d]([a-z\d\-]{0,61}[a-z\d])?)*$/i
Semikolon
31

Verwenden Sie den folgenden regulären Ausdruck, um eine gültige IP-Adresse abzugleichen:

(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}

anstatt:

([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}

Erläuterung

Viele Regex-Engines entsprechen der ersten Möglichkeit in der ORSequenz. Versuchen Sie beispielsweise den folgenden regulären Ausdruck:

10.48.0.200

Prüfung

Testen Sie den Unterschied zwischen gut und schlecht

Alban
quelle
5
Vergessen Sie nicht, dass start ^ und end $ oder etwas wie 0.0.0.999 oder 999.0.0.0 ebenfalls übereinstimmen. ;)
andreas
1
Ja, um eine Zeichenfolge zu validieren, sind Start ^ und Ende $ erforderlich. Wenn Sie jedoch eine IP-Adresse in einem Text suchen, verwenden Sie sie nicht.
Alban
Die unbeabsichtigte "Nicht-Gierigkeit", die Sie identifizieren, gilt auch für die anderen Hostnamenlösungen. Es lohnt sich, dies zu Ihrer Antwort hinzuzufügen, da die anderen nicht mit dem vollständigen Hostnamen übereinstimmen. zB ([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]))*versus([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: In der obigen Verwendung +am Ende statt *die Fehler zu sehen.
Ergohack
5

Ich kann den Top-Beitrag anscheinend nicht bearbeiten, daher füge ich hier meine Antwort hinzu.

Für den Hostnamen - einfache Antwort, am Beispiel egrep hier - http: //www.linuxinsight.com/how_to_grep_for_ip_addresses_using_the_gnu_egrep_utility.html

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

Der Fall berücksichtigt jedoch keine Werte wie 0 im ersten Oktett und Werte größer als 254 (IP-Adresse) oder 255 (Netzmaske). Vielleicht würde eine zusätzliche if-Anweisung helfen.

Was den legalen DNS-Hostnamen betrifft, habe ich, vorausgesetzt, Sie suchen nur nach Internet-Hostnamen (und nicht nach Intranet), den folgenden Ausschnitt geschrieben, eine Mischung aus Shell / PHP, die jedoch als regulärer Ausdruck anwendbar sein sollte.

Gehen Sie zuerst zur ietf-Website, laden Sie eine Liste der legalen Domain-Namen der Ebene 1 herunter und analysieren Sie sie:

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)"

Das sollte Ihnen einen schönen Code geben, der die Rechtmäßigkeit von Top-Domain-Namen wie .com .org oder .ca überprüft

Fügen Sie dann den ersten Teil des Ausdrucks gemäß den hier angegebenen Richtlinien hinzu - http: //www.domainit.com/support/faq.mhtml?category=Domain_FAQ&question=9 (eine alphanumerische Kombination und ein '-' Symbol, Bindestrich sollte nicht enthalten sein der Anfang oder das Ende eines Oktetts.

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

Dann setzen Sie alles zusammen (PHP preg_match Beispiel):

$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
    }

Möglicherweise möchten Sie auch eine if-Anweisung hinzufügen, um zu überprüfen, ob die von Ihnen überprüfte Zeichenfolge kürzer als 256 Zeichen ist - http://www.ops.ietf.org/lists/namedroppers/namedroppers.2003/msg00964.html

Alex Volkov
quelle
1
-1, da dies mit gefälschten IP-Adressen wie "999.999.999.999" übereinstimmt.
Bdesham
1
"Obwohl der Fall keine Werte wie 0 im ersten Oktett und Werte größer als 254 (IP-Adresse) oder 255 (Netzmaske) berücksichtigt."
Alex Volkov
Ich habe gesehen, dass Sie Ihre Antwort qualifiziert haben, ja. Ich habe abgelehnt, weil dieser Teil Ihrer Antwort immer noch nicht nützlich ist.
Bdesham
3

Es ist erwähnenswert, dass es für die meisten Sprachen Bibliotheken gibt, die dies für Sie tun und häufig in die Standardbibliothek integriert sind. Und diese Bibliotheken werden wahrscheinlich viel häufiger aktualisiert als Code, den Sie vor vier Jahren aus einer Stapelüberlauf-Antwort kopiert und vergessen haben. Und natürlich analysieren sie die Adresse im Allgemeinen auch in eine verwendbare Form, anstatt Ihnen nur eine Übereinstimmung mit einer Reihe von Gruppen zu geben.

Beispiel: Erkennen und Parsen von IPv4 in (POSIX) C:

#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;
}

Offensichtlich funktionieren solche Funktionen nicht, wenn Sie beispielsweise versuchen, alle gültigen Adressen in einer Chat-Nachricht zu finden. Aber selbst dort ist es möglicherweise einfacher, einen einfachen, aber übereifrigen regulären Ausdruck zu verwenden, um potenzielle Übereinstimmungen zu finden, und dann die zu verwenden Bibliothek, um sie zu analysieren.

Zum Beispiel in Python:

>>> 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
abarnert
quelle
2
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("."))
PythonDev
quelle
Könnten Sie diesen regulären Ausdruck erklären? Was genau bedeutet (?! -), (? <! -)?
Scit
1
@Scit, diese stellen sicher, dass es nicht mit einem "-" Zeichen beginnt oder endet, wenn Ihre Regex-Engine ihre Verwendung zulässt. Zum Beispiel von Python oder von Perl .
YLearn
1

Ich denke, dies ist der beste IP-Validierungs-Regex. bitte einmal überprüfen !!!

^(([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]))$
Prakash Thapa
quelle
1
"^((\\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])$"
zangw
quelle
1

Dies funktioniert für gültige IP-Adressen:

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])$'
aliasav
quelle
1
/^(?:[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])?$/
user2240578
quelle
0

Hier ist ein regulärer Ausdruck, den ich in Ant verwendet habe, um eine Proxy-Host-IP oder einen Hostnamen aus ANT_OPTS zu erhalten. Dies wurde verwendet, um die Proxy-IP zu erhalten, damit ich einen Ant "isreachable" -Test ausführen konnte, bevor ich einen Proxy für eine gegabelte JVM konfigurierte.

^.*-Dhttp\.proxyHost=(\w{1,}\.\w{1,}\.\w{1,}\.*\w{0,})\s.*$
Bill Stephens
quelle
Das ist \wgenau dort, es erfasst keine IP, nur den Hostnamen in bestimmten Situationen.
Yaron
0

Ich fand, dass dies für IP-Adressen ziemlich gut funktioniert. Es wird wie die Top-Antwort validiert, stellt aber auch sicher, dass die IP isoliert ist, sodass nach oder vor der IP kein Text oder mehr Zahlen / Dezimalstellen stehen.

(? <! \ S) (?: (?: \ D | [1-9] \ d | 1 \ d \ d | 2 [0-4] \ d | 25 [0-5]) \ b |. \ b) {7} (?! \ S)

Andrew
quelle
Ich habe viel versucht, aber ich konnte hier zwei Dinge nicht verstehen. 1. \ b gibt die Wortgrenze an Warum verwenden wir \ b? Welches ist die Grenze? und 2. Warum funktioniert es nur für {7} Nach meinem Verständnis sollte es {4} sein, aber es funktioniert nicht. Optional können Sie feststellen, warum Sie nicht erfassende Blöcke verwenden.
Srichakradhar
0

Versuche dies:

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

es funktioniert in meinem Fall.

Seraphim
quelle
0

In Bezug auf IP-Adressen scheint es einige Debatten darüber zu geben, ob führende Nullen aufgenommen werden sollen. Es war einmal die übliche Praxis und wird allgemein akzeptiert, daher würde ich argumentieren, dass sie unabhängig von der aktuellen Präferenz als gültig gekennzeichnet werden sollten . Es gibt auch einige Unklarheiten darüber, ob Text vor und nach der Zeichenfolge validiert werden soll, und ich denke, dies sollte auch so sein. 1.2.3.4 ist eine gültige IP, 1.2.3.4.5 jedoch nicht, und weder der 1.2.3.4-Teil noch der 2.3.4.5-Teil sollten zu einer Übereinstimmung führen. Einige der Bedenken können mit diesem Ausdruck behandelt werden:

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:]]|$)' 

Der unglückliche Teil hier ist die Tatsache, dass der Regex-Teil, der ein Oktett validiert, wiederholt wird, wie dies bei vielen angebotenen Lösungen der Fall ist. Obwohl dies besser ist als für Instanzen des Musters, kann die Wiederholung vollständig eliminiert werden, wenn Unterprogramme im verwendeten regulären Ausdruck unterstützt werden. Das nächste Beispiel aktiviert diese Funktionen mit dem -PSchalter von grepund nutzt auch die Lookahead- und Lookbehind-Funktionen. (Der von mir ausgewählte Funktionsname ist 'o' für Oktett. Ich hätte 'Oktett' als Namen verwenden können, wollte aber knapp sein.)

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

Die Behandlung des Punkts kann tatsächlich zu einem falschen Negativ führen, wenn sich IP-Adressen in einer Datei mit Text in Form von Sätzen befinden, da der a-Punkt folgen könnte, ohne dass er Teil der gepunkteten Notation ist. Eine Variante des oben genannten würde das beheben:

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))'
Thom Anderson
quelle
0
>>> 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
Mohammad Shahid Siddiqui
quelle
0

Das neue Netzwerkframework verfügt über fehlerhafte Initialisierer für struct IPv4Address und struct IPv6Address, die den IP-Adressenteil sehr einfach verarbeiten. Dies in IPv6 mit einem regulären Ausdruck zu tun, ist bei allen Verkürzungsregeln schwierig.

Leider habe ich keine elegante Antwort für den Hostnamen.

Beachten Sie, dass das Netzwerkframework neu ist, sodass Sie möglicherweise gezwungen sind, für neuere Betriebssystemversionen zu kompilieren.

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"
Darrell Root
quelle
-1

Wie wäre es damit?

([0-9]{1,3}\.){3}[0-9]{1,3}
Saikrishna Rao
quelle
Und so ist 9999999999.0.0.9999999999 :) Aber für die meisten Programmierer wird dieser kurze Ansatz ausreichen.
Andreas
3
-1, weil dies mit unsinnigen IP-Adressen übereinstimmt (wie @Shebuka bemerkt).
Bdesham
-1

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

Sirjay
quelle
2
Während dieser Code die Frage beantworten kann, macht eine allgemeine Erklärung neben dem Code eine Antwort viel nützlicher. Bitte bearbeiten Sie Ihre Antwort und geben Sie einen Kontext und eine Erklärung an.
user4642212
Und wenn ich mich nicht irre, ist FILTER_VALIDATE_IP nur ein PHP-Wert.
DonGar
-2

Suchen nach Hostnamen wie ... mywebsite.co.in, thangaraj.name, 18thangaraj.in, thangaraj106.in usw.,

[a-z\d+].*?\\.\w{2,4}$
Thangaraj
quelle
3
-1. Das OP forderte etwas "gut getestet, um genau den neuesten RFC-Spezifikationen zu entsprechen", aber dies stimmt nicht mit zB * .museum überein, während es mit * .foo übereinstimmt. Hier ist eine Liste gültiger TLDs.
Bdesham
Ich bin mir nicht sicher, ob es eine gute Idee ist, das Plus in die Zeichenklasse (eckige Klammern) zu setzen. Außerdem gibt es TLDs mit 5 Buchstaben ( z. B. .expert ).
Yaron
Der beste Weg, dies mit RFC zu erreichen, ist die Verwendung der System- / Sprachfunktionen. inet_atonist gut genug.
m3nda
-2

Ich dachte über dieses einfache Regex-Übereinstimmungsmuster für die IP-Adressanpassung nach \ d + [.] \ D + [.] \ D + [.] \ D +

Dody
quelle
1111.1.1.1 ist keine gültige IP. Es gibt keine Möglichkeit, ein IP-Format wirklich zu testen, wenn Sie sich nicht um Subnetze kümmern. Sie sollten sich zumindest um die Anzahl der Auftritte mit so etwas kümmern ^\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}und das wird natürlich nicht der richtige Weg sein. Wenn Sie eine Sprache zum Schreiben von Skripten haben, haben Sie sicher Zugriff auf die Netzwerkfunktionen. Der beste Weg, um eine ECHTE IP zu überprüfen, besteht darin, das System anzuweisen, die IP-Adresse zu konvertieren und in das richtige Format zu bringen. Überprüfen Sie dann, ob sie wahr / falsch ist. Im Falle von Python benutze ich socket.inet_aton(ip). Bei PHP brauchst du inet_aton($ip).
m3nda
Python-Benutzer können hier einen Blick darauf werfen: gist.github.com/erm3nda/f25439bba66931d3ca9699b2816e796c
m3nda