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

Ответ 1

У вашего регулярного выражения уже есть несколько проблем:

Во-первых, он содержит точки. В регулярном выражении точка означает "соответствовать любому символу", где вам нужно сопоставить только фактическую точку. Для этого вам нужно избежать этого, поэтому поставьте обратную косую черту перед точками.

Во-вторых, но вы сопоставляете любые три цифры в каждом разделе. Это означает, что вы будете сопоставлять любое число от 0 до 999, которое, очевидно, содержит много недопустимых номеров IP-адресов.

Это можно решить, сделав сопоставление чисел более сложным; на этом сайте есть другие ответы, которые объясняют, как это сделать, но, честно говоря, это не стоит усилий - по моему мнению, вам будет гораздо лучше разбить строку по точкам, а затем просто проверить четыре блока как числовые целочисленные диапазоны - т.е.

if(block >= 0 && block <= 255) {....}

Надеюсь, это поможет.

Ответ 2

Может быть, поздно, но кто-то может попробовать:

Пример IP-адреса VALID

115.42.150.37
192.168.0.1
110.234.52.124

Пример IP-адреса INVALID

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-код для проверки IP-адреса

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

Ответ 3

Попробуйте это, это более короткая версия:

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

Разъяснение:

^ 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 для консоли браузера:

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

Ответ 4

Если вы используете nodejs try:

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

doc net.isIP()

Ответ 5

Попробуйте это... Источник из здесь.

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

Ответ 6

Если вам нужно что-то более читаемое, чем регулярное выражение для ipv4 в современных браузерах, вы можете пойти с

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

Ответ 7

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

Полный кредит oriadam. Я бы прокомментировал ниже его/ее ответ, чтобы предложить двойное изменение нуля, которое я сделал, но у меня пока нет достаточной репутации...

изменить

• - (?! 0) Поскольку адреса IPv4, начинающиеся с нулей ('0.248.42.223'), действительны (но не полезный)

• + (?! 0\d) Поскольку адреса IPv4 с ведущими нулями ('63.14.209.00 'и' 011.012.013.014 ') могут иногда интерпретироваться как восьмеричное

Ответ 8

Ниже решение не принимает дополняющие нули

Вот самый чистый способ проверки IP-адреса, позвольте его разбить:

Факт: действительный IP-адрес имеет 4 octets, каждый октет может быть числом от 0 - 255

Разрушение регулярных выражений.

• 25[0-5] матчей 250 - 255
• 2[0-4][0-9] матчей 200 - 249
• 1[0-9][0-9] соответствует 100 - 199
• [1-9][0-9]? соответствует 1 - 99
• 0 совпадений 0

Примечания: при использовании new RegExp вы должны использовать \\. вместо \. так как строка будет экранирована дважды.

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

Ответ 9

Регулярное выражение для формата IP-адреса:

/^(\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])$/;

Ответ 10

Не пишите свое собственное регулярное выражение или скопируйте пасту! Вы, вероятно, не охватите все граничные cses (IPv6, но также восьмеричные IP и т.д.). Используйте is-ip из npm:

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

isIp('192.168.0.1');

Вернет логическое значение.

Downvoters: хотите объяснить, почему использование активно поддерживаемой библиотеки лучше, чем копирование вставок с веб-сайта?

Ответ 11

И вместо

{1-3}

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

{1,3}

Ответ 12

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

Ответ 13

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

^(?!\.)((^|\.)([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}.

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

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

Ответ 14

Моя версия как метод 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;
}

Ответ 15

Короткое 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'));

Ответ 16

\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-х номеров хранится в собственной группе захвата, поэтому вы можете получить к ним доступ позже

Ответ 17

возможно, лучше:

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

Ответ 18

Всегда искать варианты, казалось, повторяющаяся задача, так как насчет использования 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;
  }
}

Ответ 19

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

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)