generate - Validar direcciones IPv4 con regexp
regex online c# (25)
^((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]?))$
Arriba estará regex para la dirección IP como: 221.234.000.112 también para 221.234.0.112, 221.24.03.112, 221.234.0.1
Puedes imaginar todo tipo de dirección como la anterior
He intentado obtener una expresión regular eficiente para la validación de IPv4, pero sin mucha suerte. Parecía que en un momento lo había tenido con (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(/.|$)){4}
, pero produce algunos resultados extraños:
[chris@helios bashscripts]$ grep --version
grep (GNU grep) 2.7
[chris@helios bashscripts]$ 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
[chris@helios bashscripts]$ 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
[chris@helios bashscripts]$ grep -E ''/b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(/.|$)){4}/b'' <<< 192.168.255.255
[chris@helios bashscripts]$ 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
Hice una búsqueda para ver si esto ya se había preguntado y respondido, pero otras respuestas parecen simplemente mostrar cómo determinar 4 grupos de 1 a 3 números, o no funcionan para mí.
¿Algunas ideas? ¡Gracias!
Con máscara de subred:
^$|([01]?//d//d?|2[0-4]//d|25[0-5])//
.([01]?//d//d?|2[0-4]//d|25[0-5])//
.([01]?//d//d?|2[0-4]//d|25[0-5])//
.([01]?//d//d?|2[0-4]//d|25[0-5])
((/([01]?//d//d?|2[0-4]//d|25[0-5]))?)$
Creo que este es el más corto.
^(([01]?/d/d?|2[0-4]/d|25[0-5]).){3}([01]?/d/d?|2[0-4]/d|25[0-5])$
Creo que muchas personas que lean esta publicación buscarán algo más simple, incluso si permite el paso de algunas direcciones IP técnicamente no válidas.
Esto es lo más simple que se me ocurre:
Python / Ruby / Perl:
/(/d+(/.|$)){4}/
grep -E (GNU Grep 3.1), awk (versión 20070501) y sed:
/([0-9]+(/.|$)){4}/
Puppet permitió esto:
/(/d+[/.$]){4}/
Dirección IPv4 (captura precisa) Coincide con 0.0.0.0 a 255.255.255.255 Utilice esta expresión regular para hacer coincidir los números de IP con la precisión. Cada uno de los 4 números se almacena en un grupo de captura, por lo que puede acceder a ellos para su posterior procesamiento.
/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
tomado de la biblioteca JGsoft RegexBuddy
Editar: esta parte (/.|$)
Parece extraña
Encontré esta muestra muy útil, además permite diferentes notaciones de ipv4.
código de muestra usando Python:
def is_valid_ipv4(ip4):
"""Validates IPv4 addresses.
"""
import re
pattern = re.compile(r"""
^
(?:
# Dotted variants:
(?:
# Decimal 1-255 (no leading 0''s)
[3-9]/d?|2(?:5[0-5]|[0-4]?/d)?|1/d{0,2}
|
0x0*[0-9a-f]{1,2} # Hexadecimal 0x0 - 0xFF (possible leading 0''s)
|
0+[1-3]?[0-7]{0,2} # Octal 0 - 0377 (possible leading 0''s)
)
(?: # Repeat 0-3 times, separated by a dot
/.
(?:
[3-9]/d?|2(?:5[0-5]|[0-4]?/d)?|1/d{0,2}
|
0x0*[0-9a-f]{1,2}
|
0+[1-3]?[0-7]{0,2}
)
){0,3}
|
0x0*[0-9a-f]{1,8} # Hexadecimal notation, 0x0 - 0xffffffff
|
0+[0-3]?[0-7]{0,10} # Octal notation, 0 - 037777777777
|
# Decimal notation, 1-4294967295:
429496729[0-5]|42949672[0-8]/d|4294967[01]/d/d|429496[0-6]/d{3}|
42949[0-5]/d{4}|4294[0-8]/d{5}|429[0-3]/d{6}|42[0-8]/d{7}|
4[01]/d{8}|[1-3]/d{0,9}|[4-9]/d{0,8}
)
$
""", re.VERBOSE | re.IGNORECASE)
return pattern.match(ip4) <> None
Encuentra una dirección IP válida siempre que la IP se ajuste a cualquier carácter que no sea dígitos (detrás o adelante de la IP). 4 Backreferences created: $ + {first}. $ + {Second}. $ + {Third}. $ + {Forth}
Find String:
#any valid IP address
(?<IP>(?<![/d])(?<first>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))[/.](?<second>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))[/.](?<third>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))[/.](?<forth>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))(?![/d]))
#only valid private IP address RFC1918
(?<IP>(?<![/d])(:?(:?(?<first>10)[/.](?<second>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5])))|(:?(?<first>172)[/.](?<second>(:?1[6-9])|(:?2[0-9])|(:?3[0-1])))|(:?(?<first>192)[/.](?<second>168)))[/.](?<third>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))[/.](?<forth>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))(?![/d]))
Notepad++ Replace String Option 1: Replaces the whole IP (NO Change):
$+{IP}
Notepad++ Replace String Option 2: Replaces the whole IP octect by octect (NO Change)
$+{first}.$+{second}.$+{third}.$+{forth}
Notepad++ Replace String Option 3: Replaces the whole IP octect by octect (replace 3rd octect value with 0)
$+{first}.$+{second}.0.$+{forth}
NOTE: The above will match any valid IP including 255.255.255.255 for example and change it to 255.255.0.255 which is wrong and not very useful of course.
Reemplazando la porción de cada octeto con un valor real, sin embargo puedes construir tu propio hallazgo y reemplazar lo que es realmente útil para mejorar las direcciones IP en los archivos de texto:
for example replace the first octect group of the original Find regex above:
(?<first>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))
with
(?<first>10)
and
(?<second>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))
with
(?<second>216)
and you are now matching addresses starting with first octect 192 only
Find on notepad++:
(?<IP>(?<![/d])(?<first>10)[/.](?<second>216)[/.](?<third>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))[/.](?<forth>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))(?![/d]))
Todavía puede realizar Reemplazar utilizando grupos de referencia inversa de la misma manera que antes.
Puedes hacerte una idea de cómo lo anterior coincide a continuación:
cat ipv4_validation_test.txt
Full Match:
0.0.0.1
12.108.1.34
192.168.1.1
10.249.24.212
10.216.1.212
192.168.1.255
255.255.255.255
0.0.0.0
Partial Match (IP Extraction from line)
30.168.1.0.1
-1.2.3.4
sfds10.216.24.23kgfd
da11.15.112.255adfdsfds
sfds10.216.24.23kgfd
NO Match
1.1.1.01
3...3
127.1.
192.168.1..
192.168.1.256
da11.15.112.2554adfdsfds
da311.15.112.255adfdsfds
Usando grep puedes ver los resultados a continuación:
From grep:
grep -oP ''(?<IP>(?<![/d])(?<first>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))[/.](?<second>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))[/.](?<third>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))[/.](?<forth>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))(?![/d]))'' ipv4_validation_test.txt
0.0.0.1
12.108.1.34
192.168.1.1
10.249.24.212
10.216.1.212
192.168.1.255
255.255.255.255
0.0.0.0
30.168.1.0
1.2.3.4
10.216.24.23
11.15.112.255
10.216.24.23
grep -P ''(?<IP>(?<![/d])(?<first>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))[/.](?<second>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))[/.](?<third>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))[/.](?<forth>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))(?![/d]))'' ipv4_validation_test.txt
0.0.0.1
12.108.1.34
192.168.1.1
10.249.24.212
10.216.1.212
192.168.1.255
255.255.255.255
0.0.0.0
30.168.1.0.1
-1.2.3.4
sfds10.216.24.23kgfd
da11.15.112.255adfdsfds
sfds10.216.24.23kgfd
#matching ip addresses starting with 10.216
grep -oP ''(?<IP>(?<![/d])(?<first>10)[/.](?<second>216)[/.](?<third>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))[/.](?<forth>(:?/d)|(:?[1-9]/d)|(:?1/d{2})|(:?2[0-4]/d)|(:?25[0-5]))(?![/d]))'' ipv4_validation_test.txt
10.216.1.212
10.216.24.23
10.216.24.23
Esta es la expresión regular que funciona para mí:
"/<((([1-9]|1[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])/.){3}([1-9]|1[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-4]))/>"
Estaba en busca de algo similar para las direcciones IPv4, una expresión regular que también impidió validar las direcciones IP privadas (192.168.xy, 10.xyz, 172.16.xy), así que utilicé las características negativas para lograr esto:
(?!(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}
(Estos deben estar en una línea, por supuesto, formateados para facilitar la lectura en 3 líneas separadas)
Puede que no esté optimizado para la velocidad, pero funciona bien cuando solo se buscan direcciones de Internet "reales".
Cosas que van a (y deberían) fallar:
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
IPs que funcionarán (y deberían):
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)
Proporcionado en caso de que alguien más esté buscando la validación de ''direcciones IP de Internet que no incluyan las direcciones privadas comunes''
Esto es un poco más largo que algunos, pero esto es lo que uso para hacer coincidir direcciones IPv4. Simple sin compromisos.
^((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])$
La dirección IPv4 es algo muy complicado.
Nota : La sangría y el forro son solo para fines ilustrativos y no existen en el RegEx real.
/b(
((
(2(5[0-5]|[0-4][0-9])|1[0-9]{2}|[1-9]?[0-9])
|
0[Xx]0*[0-9A-Fa-f]{1,2}
|
0+[1-3]?[0-9]{1,2}
)/.){1,3}
(
(2(5[0-5]|[0-4][0-9])|1[0-9]{2}|[1-9]?[0-9])
|
0[Xx]0*[0-9A-Fa-f]{1,2}
|
0+[1-3]?[0-9]{1,2}
)
|
(
[1-3][0-9]{1,9}
|
[1-9][0-9]{,8}
|
(4([0-1][0-9]{8}
|2([0-8][0-9]{7}
|9([0-3][0-9]{6}
|4([0-8][0-9]{5}
|9([0-5][0-9]{4}
|6([0-6][0-9]{3}
|7([0-1][0-9]{2}
|2([0-8][0-9]{1}
|9([0-5]
))))))))))
)
|
0[Xx]0*[0-9A-Fa-f]{1,8}
|
0+[1-3]?[0-7]{,10}
)/b
Estas direcciones IPv4 son validadas por el RegEx anterior.
127.0.0.1
2130706433
0x7F000001
017700000001
0x7F.0.0.01 # Mixed hex/dec/oct
000000000017700000001 # Have as many leading zeros as you want
0x0000000000007F000001 # Same as above
127.1
127.0.1
Estos son rechazados.
256.0.0.1
192.168.1.099 # 099 is not a valid number
4294967296 # UINT32_MAX + 1
0x100000000
020000000000
La expresión regular de IPv4 más precisa, directa y compacta que puedo imaginar es
^(25[0-5]|2[0-4]/d|1/d/d|[1-9]?/d)/.(25[0-5]|2[0-4]/d|1/d/d|[1-9]?/d)/.(25[0-5]|2[0-4]/d|1/d/d|[1-9]?/d)/.(25[0-5]|2[0-4]/d|1/d/d|[1-9]?/d)$
Pero, ¿qué pasa con el rendimiento / eficiencia de ... Lo siento, no sé, a quién le importa?
Logré construir una expresión regular de todas las otras respuestas.
(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}
Nueva versión mejorada y más corta
^(?:(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])(/.(?!$)|$)){4}$
Utiliza el lookahead negativo (?!)
Para eliminar el caso en el que la ip podría terminar con a .
Respuesta anterior
^(?:(?: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])$
Creo que esta es la expresión regular más precisa y estricta, no acepta cosas como 000.021.01.0.
parece que la mayoría de las respuestas aquí lo hacen y requieren expresiones regulares adicionales para rechazar casos similares a ese, es decir, 0
números iniciales y una ip que termina con a .
Prueba esto:
/b(([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])/.([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])/.([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])/.(2[0-5][0-5]|1[0-9][0-9]|[1-9][0-9]|[1-9]))/b
Regex no es la herramienta para este trabajo. Sería mejor escribir un analizador sintáctico que separe los cuatro números y compruebe que están en el rango [0,255]. ¡La expresión regular no funcional ya es ilegible!
Usaría PCRE y la palabra clave define
:
/^
((?&byte))/.((?&byte))/.((?&byte))/.((?&byte))$
(?(DEFINE)
(?<byte>25[0-5]|2[0-4]/d|[01]?/d/d?))
/gmx
Demostración: https://regex101.com/r/IB7j48/2
La razón de esto es para evitar repetir el patrón (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)
Cuatro veces. Otras soluciones como la siguiente funcionan bien, pero no capturan a cada grupo como lo solicitarían muchos.
/^((/d+?)(/.|$)){4}/
La única otra forma de tener 4 grupos de captura es repetir el patrón cuatro veces:
/^(?<one>/d+)/.(?<two>/d+)/.(?<three>/d+)/.(?<four>/d+)$/
Por lo tanto, capturar un ipv4 en perl es muy fácil
$ echo "Hey this is my IP address 138.131.254.8, bye!" | /
perl -ne ''print "[$1, $2, $3, $4]" if /
//b((?&byte))/.((?&byte))/.((?&byte))/.((?&byte))
(?(DEFINE)
/b(?<byte>25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))
/x''
[138, 131, 254, 8]
Ya tienes una respuesta funcional, pero en caso de que tengas curiosidad sobre cuál era el problema con tu enfoque original, la respuesta es que necesitas paréntesis alrededor de tu alternancia; de lo contrario, solo se requiere (/.|$)
Si el número es menor que 200.
''/b((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(/.|$)){4}/b''
^ ^
^((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]?)$
Aceptar :
127.0.0.1
192.168.1.1
192.168.1.255
255.255.255.255
0.0.0.0
1.1.1.01
Rechazar :
30.168.1.255.1
127.1
192.168.1.256
-1.2.3.4
3...3
Pruebe en línea con pruebas unitarias: https://www.debuggex.com/r/-EDZOqxTxhiTncN6/1
const char*ipv4_regexp = "//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";
Adapté la expresión regular tomada de la biblioteca JGsoft RegexBuddy al lenguaje C (regcomp / regexec) y descubrí que funciona, pero hay un pequeño problema en algunos sistemas operativos como Linux. Esa expresión regular acepta direcciones IPv4 como 192.168.100.009 donde 009 en Linux se considera un valor octal, por lo que la dirección no es la que usted pensó. Cambié esa expresión regular de la siguiente manera:
const char* ipv4_regex = "//b(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])//."
"(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])//b";
utilizando esa expresión regular ahora 192.168.100.009 no es una dirección IPv4 válida, mientras que 192.168.100.9 está bien.
Modifiqué una expresión regular para la dirección de multidifusión también y es la siguiente:
const char* mcast_ipv4_regex = "//b(22[4-9]|23[0-9])//."
"(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]?)//."
"(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])//b";
Creo que debes adaptar la expresión regular al idioma que estás usando para desarrollar tu aplicación
Pongo un ejemplo en java:
package utility;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class NetworkUtility {
private static String ipv4RegExp = "//b(?:(?:25[0-5]|2[0-4]//d|1//d//d|[1-9]?//d?)//.){3}(?:25[0-5]|2[0-4]//d|1//d//d|[1-9]?//d?)//b";
private static String ipv4MulticastRegExp = "2(?:2[4-9]|3//d)(?://.(?:25[0-5]|2[0-4]//d|1//d//d|[1-9]//d?|0)){3}";
public NetworkUtility() {
}
public static boolean isIpv4Address(String address) {
Pattern pattern = Pattern.compile(ipv4RegExp);
Matcher matcher = pattern.matcher(address);
return matcher.matches();
}
public static boolean isIpv4MulticastAddress(String address) {
Pattern pattern = Pattern.compile(ipv4MulticastRegExp);
Matcher matcher = pattern.matcher(address);
return matcher.matches();
}
}
(((25[0-5])|(2[0-4]/d)|(1/d{2})|(/d{1,2}))/.){3}(((25[0-5])|(2[0-4]/d)|(1/d{2})|(/d{1,2})))
Prueba para buscar coincidencias en el texto, https://regex101.com/r/9CcMEN/2
Las siguientes son las reglas que definen las combinaciones válidas en cada número de una dirección IP:
- Cualquier número de uno o dos dígitos.
Cualquier número de tres dígitos que comience con
1
.Cualquier número de tres dígitos que comience con
2
si el segundo dígito es de0
a4
.- Cualquier número de tres dígitos que comience con
25
si el tercer dígito es de0
a5
.
Comencemos con (((25[0-5])|(2[0-4]/d)|(1/d{2})|(/d{1,2}))/.)
, A conjunto de cuatro subexpresiones anidadas, y las miraremos en orden inverso. (/d{1,2})
coincide con cualquier número de uno o dos dígitos o números del 0
al 99
. (1/d{2})
coincide con cualquier número de tres dígitos que comience con 1
( 1
seguido de dos dígitos) o entre 100
y 199
. (2[0-4]/d)
coincide con los números 200
a 249
. (25[0-5])
coincide con los números 250
a 255
. Cada una de estas subexpresiones está encerrada dentro de otra subexpresión con un |
entre cada uno (de modo que una de las cuatro subexpresiones tiene que coincidir, no todas). Después viene el rango de números /.
para que coincida , y luego toda la serie (todas las opciones numéricas más /.
) está encerrada en otra subexpresión y se repite tres veces usando {3}
. Finalmente, el rango de números se repite (esta vez sin el final /.
) Para coincidir con el número de dirección IP final. Al restringir cada uno de los cuatro números a valores entre 0
y 255
, este patrón puede coincidir con direcciones IP válidas y rechazar direcciones no válidas.
Extracto de: Ben Forta. "Aprendizaje de expresiones regulares".
Si no se desea un carácter al principio de la dirección IP ni al final, se deben usar ^
y $
metacaracteres, respectivamente.
^(((25[0-5])|(2[0-4]/d)|(1/d{2})|(/d{1,2}))/.){3}(((25[0-5])|(2[0-4]/d)|(1/d{2})|(/d{1,2})))$
Prueba para buscar coincidencias en el texto, https://regex101.com/r/uAP31A/1
((/.|^)(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]?|0$)){4}
Esta expresión regular no aceptará 08.8.8.8 o 8.08.8.8 u 8.8.08.8 u 8.8.8.08
-bash-3.2$ echo "191.191.191.39" | egrep
''(^|[^0-9])((2([6-9]|5[0-5]?|[0-4][0-9]?)?|1([0-9][0-9]?)?|[3-9][0-9]?|0)/.{3}
(2([6-9]|5[0-5]?|[0-4][0-9]?)?|1([0-9][0-9]?)?|[3-9][0-9]?|0)($|[^0-9])''
>> 191.191.191.39
(Este es un DFA que coincide con el espacio completo de addr (incluidas las emisiones, etc.) y nada más.
String zeroTo255 = "([0-9]|[0-9][0-9]|(0|1)[0-9][0-9]|2[0-4][0-9]|25[0-5])";
it can contain single digit i.e ([0-9]);
It can contain two digits i.e ([0-9][0-9]);
range is (099 to 199)i.e((0|1)[0-9][0-9]);
range is (200 - 249) i.e (2[0-9][0-9]) ;
range is (250-255) i.e(25[0-5]);
mysql> select ip from foo where ip regexp ''^//s*[0-9]+//.[0-9]+//.[0-9]+//.[0-9]//s*'';