webentwicklung-frage-antwort-db.com.de

javascript regulärer Ausdruck, um nach IP-Adressen zu suchen

Ich habe mehrere IP-Adressen wie:

  1. 115.42.150.37
  2. 115.42.150.38
  3. 115.42.150.50

Welche Art von regulären Ausdrücken sollte ich schreiben, wenn ich nach allen 3 IP-Adressen suchen möchte? ZB wenn ich 115.42.150.* mache (ich kann nach allen 3 IP-Adressen suchen)

Was ich jetzt tun kann, ist etwas wie: /[0-9]{1-3}\.[0-9]{1-3}\.[0-9]{1-3}\.[0-9]{1-3}/, aber es scheint nicht gut zu funktionieren. 

Vielen Dank. 

30
KennC.

Die Regex, die Sie bereits haben, hat mehrere Probleme:

Erstens enthält es Punkte. In Regex bedeutet ein Punkt "Übereinstimmung mit jedem beliebigen Zeichen", bei dem Sie nur einen tatsächlichen Punkt finden müssen. Dafür musst du dem entkommen, also füge einen Backslash vor den Punkten ein.

Zweitens stimmen Sie in jedem Abschnitt mit drei beliebigen Ziffern überein. Dies bedeutet, dass Sie eine beliebige Zahl zwischen 0 und 999 finden, die offensichtlich viele ungültige IP-Adressnummern enthält.

Dies kann gelöst werden, indem der Zahlenabgleich komplexer wird. Es gibt andere Antworten auf dieser Seite, die erklären, wie das geht, aber ehrlich gesagt, es lohnt sich nicht. Mühe wäre es meiner Meinung nach, die Zeichenfolge durch die Punkte zu teilen und dann die vier Blöcke als numerisch zu bestätigen ganzzahlige Bereiche - dh:

if(block > 0 && block <256) {....}

Hoffentlich hilft das.

13
Spudley

Kann zu spät kommen, aber jemand könnte es versuchen:

Beispiel für eine gültige IP-Adresse

115.42.150.37
192.168.0.1
110.234.52.124

Beispiel für eine UNGÜLTIGE IP-Adresse

210.110 – must have 4 octets
255 – must have 4 octets
y.y.y.y – only digits are allowed
255.0.0.y – only digits are allowed
666.10.10.20 – octet number must be between [0-255]
4444.11.11.11 – octet number must be between [0-255]
33.3333.33.3 – octet number must be between [0-255]

JavaScript-Code zum Validieren einer IP-Adresse

function ValidateIPaddress(ipaddress) {  
  if (/^(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]?)\.(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]?)$/.test(ipaddress)) {  
    return (true)  
  }  
  alert("You have entered an invalid IP address!")  
  return (false)  
}  
75
ErickBest

Versuchen Sie es mit einer kürzeren Version:

^(?!0)(?!.*\.$)((1?\d?\d|25[0-5]|2[0-4]\d)(\.|$)){4}$

Erklärt: 

^ start of string
  (?!0)         Assume IP cannot start with 0
  (?!.*\.$)     Make sure string does not end with a dot
  (
    (
    1?\d?\d|   A single digit, two digits, or 100-199
    25[0-5]|   The numbers 250-255
    2[0-4]\d   The numbers 200-249
    )
  \.|$ the number must be followed by either a dot or end-of-string - to match the last number
  ){4}         Expect exactly four of these
$ end of string

Unit-Test für die Konsole eines Browsers:

var rx=/^(?!0)(?!.*\.$)((1?\d?\d|25[0-5]|2[0-4]\d)(\.|$)){4}$/;
var valid=['1.2.3.4','11.11.11.11','123.123.123.123','255.250.249.0','1.12.123.255','127.0.0.1','1.0.0.0'];
var invalid=['0.1.1.1','01.1.1.1','012.1.1.1','1.2.3.4.','1.2.3\n4','1.2.3.4\n','259.0.0.1','123.','1.2.3.4.5','.1.2.3.4','1,2,3,4','1.2.333.4','1.299.3.4'];
valid.forEach(function(s){if (!rx.test(s))console.log('bad valid: '+s);});
invalid.forEach(function(s){if (rx.test(s)) console.log('bad invalid: '+s);});
34
oriadam

Wenn Sie nodejs verwenden, versuchen Sie:

require('net').isIP('10.0.0.1')

doc net.isIP ()

17
Andrew K

Versuchen Sie es hier .. Quelle von hier .

"\b(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]?)\.(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]?)\b"
15
Teja Kantamneni

Wenn Sie etwas lesbareres als Regex für ipv4 in modernen Browsern suchen, können Sie mitgehen

function checkIsIPV4(entry) {
  var blocks = entry.split(".");
  if(blocks.length === 4) {
    return blocks.every(function(block) {
      return parseInt(block,10) >=0 && parseInt(block,10) <= 255;
    });
  }
  return false;
}
9
Ben McCormick
/^(?!.*\.$)((?!0\d)(1?\d?\d|25[0-5]|2[0-4]\d)(\.|$)){4}$/

Volle Gutschrift an oriadam . Ich hätte unten seine/ihre Antwort kommentiert, um die doppelte Null-Änderung vorzuschlagen, die ich vorgenommen habe, aber ich habe hier noch nicht genug Ansehen ...

Veränderung:

  • - (?! 0) Da IPv4-Adressen, die mit Nullen beginnen ('0.248.42.223'), valid sind ( aber nicht verwertbar ).

  • + (?! 0\d) Weil IPv4-Adressen mit führenden Nullen ('63 .14.209.00 'und' 011.012.013.014 ') manchmal als octal interpretiert werden können.

3
Tom

Regulärer Ausdruck für das IP-Adressformat:

/^(\d\d?)|(1\d\d)|(0\d\d)|(2[0-4]\d)|(2[0-5])\.(\d\d?)|(1\d\d)|(0\d\d)|(2[0-4]\d)|(2[0-5])\.(\d\d?)|(1\d\d)|(0\d\d)|(2[0-4]\d)|(2[0-5])$/;
3
waleed.arshad

Ein kurzer RegEx: ^(?:(?:^|\.)(?:2(?:5[0-5]|[0-4]\d)|1?\d?\d)){4}$

Beispiel

const isValidIp = value => (/^(?:(?:^|\.)(?:2(?:5[0-5]|[0-4]\d)|1?\d?\d)){4}$/.test(value) ? true : false);


// valid
console.log("isValidIp('0.0.0.0') ? ", isValidIp('0.0.0.0'));
console.log("isValidIp('115.42.150.37') ? ", isValidIp('115.42.150.37'));
console.log("isValidIp('192.168.0.1') ? ", isValidIp('192.168.0.1'));
console.log("isValidIp('110.234.52.124' ? ", isValidIp('110.234.52.124'));
console.log("isValidIp('115.42.150.37') ? ", isValidIp('115.42.150.37'));
console.log("isValidIp('115.42.150.38') ? ", isValidIp('115.42.150.38'));
console.log("isValidIp('115.42.150.50') ? ", isValidIp('115.42.150.50'));

// Invalid
console.log("isValidIp('210.110') ? ", isValidIp('210.110'));
console.log("isValidIp('255') ? ", isValidIp('255'));
console.log("isValidIp('y.y.y.y' ? ", isValidIp('y.y.y.y'));
console.log(" isValidIp('255.0.0.y') ? ", isValidIp('255.0.0.y'));
console.log("isValidIp('666.10.10.20') ? ", isValidIp('666.10.10.20'));
console.log("isValidIp('4444.11.11.11') ? ", isValidIp('4444.11.11.11'));
console.log("isValidIp('33.3333.33.3') ? ", isValidIp('33.3333.33.3'));

2

Und statt

{1-3}

du solltest setzen

{1,3}
2
Mikel

Wenn Sie den richtigen Code schreiben, benötigen Sie nur diesen sehr einfachen regulären Ausdruck:/\ d {1,3} /

function isIP(ip) {
    let arrIp = ip.split(".");
    if (arrIp.length !== 4) return "Invalid IP";
    let re = /\d{1,3}/;
    for (let oct of arrIp) {
        if (oct.match(re) === null) return "Invalid IP"
        if (Number(oct) < 0 || Number(oct) > 255)
            return "Invalid IP";
}
    return "Valid IP";
}

Tatsächlich erhalten Sie noch einfacheren Code, indem Sie überhaupt keinen regulären Ausdruck verwenden:

function isIp(ip) {
    var arrIp = ip.split(".");
    if (arrIp.length !== 4) return "Invalid IP";
    for (let oct of arrIp) {
        if ( isNaN(oct) || Number(oct) < 0 || Number(oct) > 255)
            return "Invalid IP";
}
    return "Valid IP";
}
2
Mohsen Kadoura

Meine Version als es6-Methode, gibt für gültige IPs true zurück, andernfalls false

isIP(ip) {
  if (typeof(ip) !== 'string')
    return false;
  if (!ip.match(/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/)) {
    return false;
  }
  return ip.split('.').filter(octect => octect >= 0 && octect <= 255).length === 4;
}
2
geckos

Einen späten Beitrag einwerfen:

^(?!\.)((^|\.)([1-9]?\d|1\d\d|2(5[0-5]|[0-4]\d))){4}$

Von den Antworten, die ich geprüft habe, sind sie entweder länger oder unvollständig. Länger bedeutet nach meiner Erfahrung, dass es schwieriger ist, zu übersehen und daher eher fehlerhaft zu sein. Und aus ähnlichen Gründen vermeide ich es, ähnliche Muster zu wiederholen.

Der Hauptteil ist natürlich der Test für eine Zahl - 0 bis 255, aber es muss auch sichergestellt werden, dass keine anfänglichen Nullen zulässig sind (außer wenn es sich um eine einzelne Zahl handelt):

[1-9]?\d|1\d\d|2(5[0-5]|[0-4]\d)

Drei Alternativen - eine für Unter 100: [1-9]?\d, eine für 100-199: 1\d\d und schließlich 200-255: 2(5[0-5]|[0-4]\d).

Dies wird durch einen Test für Zeilenanfangoder einen Punkt . vorangestellt, und dieser gesamte Ausdruck wird viermal mit dem angefügten {4} getestet.

Dieser vollständige Test für 4-Byte-Darstellungen wird gestartet, indem der Zeilenanfang getestet wird, gefolgt von einem negativen Look-Ahead, um Adressen zu vermeiden, die mit einem .: ^(?!\.) beginnen, und mit einem Test für das Zeilenende ($) beendet.

Siehe einige Beispiele hier bei regex101.

2
SamWhan

Below Solution akzeptiert keine Auffüll-Nullen

Hier ist der sauberste Weg, um eine IP-Adresse zu überprüfen.

Fakt: eine gültige IP-Adresse hat 4 octets, jedes Oktett kann eine Zahl zwischen 0 - 255 sein

Zusammenbruch von Regex.

  • 25[0-5] passt 250 - 255
  • 2[0-4][0-9] passt 200 - 249
  • 1[0-9][0-9] passt 100 - 199
  • [1-9][0-9]? passt 1 - 99
  • 0 passt 0

Hinweise: Wenn Sie new RegExp verwenden, sollten Sie \\. anstelle von \. verwenden, da Zeichenfolge zweimal umgangen wird. 

function isValidIP(str) {
  const octet = '(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]?|0)';
  const regex = new RegExp(`^${octet}\\.${octet}\\.${octet}\\.${octet}$`);
  return regex.test(str);
}
1
Mahdi Pedram

Immer auf der Suche nach Variationen, schien es eine sich ständig wiederholende Aufgabe zu sein. Wie wäre es also, forEach zu verwenden! 

function checkIP(ip) {
  //assume IP is valid to start, once false is found, always false
  var test = true;

  //uses forEach method to test each block of IPv4 address
  ip.split('.').forEach(validateIP4);

  if (!test) 
    alert("Invalid IP4 format\n"+ip) 
  else 
    alert("IP4 format correct\n"+ip);

  function validateIP4(num, index, arr) {
    //returns NaN if not an Int
    item = parseInt(num, 10);
    //test validates Int, 0-255 range and 4 bytes of address
    // && test; at end required because this function called for each block
    test = !isNaN(item) && !isNaN(num) && item >=0 && item < 256 && arr.length==4 && test;
  }
}
0
Dave Joyce

es ist vielleicht besser:

function checkIP(ip) {
    var x = ip.split("."), x1, x2, x3, x4;

    if (x.length == 4) {
        x1 = parseInt(x[0], 10);
        x2 = parseInt(x[1], 10);
        x3 = parseInt(x[2], 10);
        x4 = parseInt(x[3], 10);

        if (isNaN(x1) || isNaN(x2) || isNaN(x3) || isNaN(x4)) {
            return false;
        }

        if ((x1 >= 0 && x1 <= 255) && (x2 >= 0 && x2 <= 255) && (x3 >= 0 && x3 <= 255) && (x4 >= 0 && x4 <= 255)) {
            return true;
        }
    }
    return false;
}    
0
user826822
\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b

passt zu 0.0.0.0 bis 999.999.999.999 , wenn Sie wissen, dass die Seachdata keine ungültigen IP-Adressen enthält

\b(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]?)\.(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]?)\b

verwenden Sie diese Option, um die IP-Nummern mit Genauigkeit abzugleichen. Jede der 4 Nummern wird in einer eigenen Erfassungsgruppe gespeichert, sodass Sie später darauf zugreifen können

0
pastacool

Schreibe nicht deine eigene Regex oder kopiere Einfügen! Sie werden wahrscheinlich nicht alle Edge-Cses (IPv6, aber auch Oktal-IPs usw.) abdecken. Verwenden Sie is-ip von npm: 

var isIp = require('is-ip');

isIp('192.168.0.1');

Gibt einen Boolean zurück.

Downvoters : Wollen Sie erklären, warum die Verwendung einer aktiv gepflegten Bibliothek besser ist als das Kopieren von Websites?

0
mikemaccana