Проверка IPv4-адресов с помощью регулярного выражения

Question

Я пытался получить эффективное регулярное выражение для проверки IPv4, но без особой удачи.Мне показалось, что в какой-то момент у меня было это с (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}, но это дает некоторые странные результаты:

$ grep --version
grep (GNU grep) 2.7
$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.1
192.168.1.1
$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.255
192.168.1.255
$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.255.255
$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.2555
192.168.1.2555

Я выполнил поиск, чтобы выяснить, было ли это уже задано и получено, но другие ответы кажутсяпросто покажи, как определить 4 группы из 1-3 чисел, или у меня не работает.

Answer 1

Вы уже получили рабочий ответ, но на случай, если вам интересно, что не так с вашим первоначальным подходом, ответ таков: вам нужно заключить скобки в скобки, в противном случае (\.|$) требуется только в том случае, если число меньше200.

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

Answer 2

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

Принять :

127.0.0.1
192.168.1.1
192.168.1.255
255.255.255.255
0.0.0.0
1.1.1.01

Отклонить :

30.168.1.255.1
127.1
192.168.1.256
-1.2.3.4
3...3

Попробуйте онлайн с устройствомтесты: https://www.debuggex.com/r/-EDZOqxTxhiTncN6/1

Answer 3

Regex не является инструментом для этой работы.Было бы лучше написать синтаксический анализатор, который разделяет четыре числа и проверяет, что они находятся в диапазоне [0,255].Нефункциональное регулярное выражение уже не читается!

Answer 4

Новая и улучшенная более короткая версия

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

Используется отрицательный прогноз (?!), чтобы удалить случай, когда ip может заканчиваться .

Старый ответ

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

Я думаю, что это наиболее точное и строгое регулярное выражение, оно не принимает такие вещи, как 000.021.01.0., похоже, что большинство других ответов здесь и требуют дополнительного регулярного выражения, чтобы отклонить случаи, подобныетот - то есть 0 начальные номера и IP-адрес, который заканчивается .

Answer 5

IPv4-адрес (точный захват) Соответствует с 0.0.0.0 по 255.255.255.255 Используйте это регулярное выражение, чтобы сопоставить IP-номера с точностью. Каждое из 4 чисел сохраняется в группе захвата, поэтому вы можете получить к ним доступ для дальнейшей обработки.

\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

взято из библиотеки JGsoft RegexBuddy

Редактировать: эта (\.|$) часть кажется странной

Answer 6

Я искал что-то похожее для адресов IPv4 - регулярное выражение, которое также мешало проверять часто используемые частные ip-адреса (192.168.xy, 10.xyz, 172.16.xy), поэтому для достижения этого использовали негативные прогнозы:

(?!(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.).*)
(?!255\.255\.255\.255)(25[0-5]|2[0-4]\d|[1]\d\d|[1-9]\d|[1-9])
(\.(25[0-5]|2[0-4]\d|[1]\d\d|[1-9]\d|\d)){3}

(они должны быть в одной строке, отформатированы для удобства чтения на 3 отдельных строках)

Демо Debuggex

Возможно, он не оптимизирован по скорости, но работает хорошо, когда ищет только «настоящие» интернет-адреса.

Вещи, которые будут (и должны) потерпеть неудачу:

0.1.2.3         (0.0.0.0/8 is reserved for some broadcasts)
10.1.2.3        (10.0.0.0/8 is considered private)
172.16.1.2      (172.16.0.0/12 is considered private)
172.31.1.2      (same as previous, but near the end of that range)
192.168.1.2     (192.168.0.0/16 is considered private)
255.255.255.255 (reserved broadcast is not an IP)
.2.3.4
1.2.3.
1.2.3.256
1.2.256.4
1.256.3.4
256.2.3.4
1.2.3.4.5
1..3.4

IP-адреса, которые будут (и должны) работать:

1.0.1.0         (China)
8.8.8.8         (Google DNS in USA)
100.1.2.3       (USA)
172.15.1.2      (USA)
172.32.1.2      (USA)
192.167.1.2     (Italy)

Предоставляется в том случае, если кто-то еще ищет подтверждение «IP-адресов Интернета, не включая общие частные адреса»

Answer 7

Это немного длиннее, чем у некоторых, но это то, что я использую для сопоставления адресов IPv4. Просто без компромиссов.

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

Answer 8

Я думаю, что многие люди, читающие этот пост, будут искать более простые регулярные выражения, даже если они соответствуют некоторым технически недопустимым IP-адресам. (И, как отмечалось в другом месте, регулярное выражение, вероятно, в любом случае не подходит для правильной проверки IP-адреса.)

Удалите ^ и, если применимо, замените $ на \b, если вы не хотите совпадать с началом / концом строки.

Базовое регулярное выражение (BRE) (проверено на GNU grep, GNU sed и vim):

/^[0-9]\+\.[0-9]\+\.[0-9]\+\.[0-9]\+$/

Расширенное регулярное выражение (ERE):

/^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/

или

/^([0-9]+(\.|$)){4}/

Регулярное выражение, совместимое с Perl (PCRE) (протестировано на Perl 5.18):

/^\d+\.\d+\.\d+\.\d+$/

или

/^(\d+(\.|$)){4}/

Ruby (протестировано на Ruby 2.1):

Хотя предполагается, что это PCRE, Ruby по любой причине допустил, что это регулярное выражение не разрешено в Perl 5.18:

/^(\d+[\.$]){4}/

Мои тесты для всех этих онлайн здесь .

Answer 9

/^(?:(25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)\.){3}(?1)$/m

Answer 10

Мне удалось построить регулярное выражение из всех других ответов.

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