регулярное выражение javascript для проверки IP-адресов

Question

У меня есть несколько IP-адресов, таких как:

1. 115.42.150.37
2. 115.42.150.38
3. 115.42.150.50

Какой тип регулярного выражения мне следует написать, если я хочу найти все 3 IP-адреса? Например, если я сделаю 115.42.150.* (я смогу найти все 3 IP-адреса)

Что я могу сделать сейчас, это что-то вроде: /[0-9]{1-3}\.[0-9]{1-3}\.[0-9]{1-3}\.[0-9]{1-3}/, но, похоже, это не работает хорошо.

Спасибо.

Answer 1

Короткий RegEx: ^(?:(?:^|\.)(?:2(?:5[0-5]|[0-4]\d)|1?\d?\d)){4}$

Пример

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'));

Answer 2

И вместо

{1-3}

вы должны поставить

{1,3}

Answer 3

Внесение позднего вклада:

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

Из проверенных мной ответов они либо более длинные, либо неполные в своей проверке.По моему опыту, чем дольше, тем труднее упускать из виду и, следовательно, более склонным к ошибкам.И мне нравится избегать повторения подобных паттернов по той же причине.

Основная часть, конечно же, это тест на число от 0 до 255, но также и то, что он не допускает начальные нули (за исключением случаев, когда он один):

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

Три чередования - одно для саба 100: [1-9]?\d, одно для 100-199: 1\d\d и, наконец, 200-255: 2(5[0-5]|[0-4]\d).

Этому предшествует проверка начала строки или точки ., и все это выражение проверяется 4 раза добавленной {4}.

Этот полный тест для четырехбайтовых представлений начинается с проверки начала строки с последующим отрицательным просмотром вперед, чтобы избежать адресов, начинающихся с .: ^(?!\.), и завершается проверкой конца строки($).

См. Некоторые примеры здесь на regex101.

Answer 4

Моя версия в качестве метода es6, возвращает true для действительных IP-адресов, 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;
}

Answer 5

Если вы пишете правильный код, вам нужно только это очень простое регулярное выражение: / \ 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";
}

Но на самом деле вы получаете еще более простой код, вообще не используя регулярные выражения:

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

Answer 6

Менее строгий при тестировании типа не действительность. Например, при сортировке столбцов используйте эту проверку, чтобы увидеть, какую сортировку использовать.

export const isIpAddress = (ipAddress) => 
    /^((\d){1,3}\.){3}(\d){1,3}$/.test(ipAddress)

При проверке на достоверность используйте этот тест. Еще более строгий тест, проверяющий, что 8-битные числа IP находятся в диапазоне 0-255:

export const isValidIpAddress = (ipAddress) => 
    /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(ipAddress)

Answer 7

Всегда искать варианты, казалось, повторяющаяся задача, так как насчет использования forEach!

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

Answer 8

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

соответствует 0.0.0.0–999.999.999.999, если известно, что seachdata не содержит недопустимых IP-адресов

\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

используется для сопоставления IP-номеров с точностью - каждое из 4 чисел сохраняетсяв свою собственную группу захвата, чтобы вы могли получить к ним доступ позже

Answer 9

может быть лучше:

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