IPv4 adreslerini regexp ile doğrulama

IPv4 doğrulaması için verimli bir normal ifade almaya çalışıyorum, ancak çok şansım olmadı. Bir noktada sahip olduğum gibi görünüyordu (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}, ancak bazı garip sonuçlar veriyor:

$ 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

Bunun daha önce sorulup cevaplanmadığını görmek için bir araştırma yaptım, ancak diğer cevaplar sadece 1-3 sayılık 4 grubun nasıl belirleneceğini gösteriyor gibi görünüyor veya benim için işe yaramıyor.

Zaten çalışan bir cevabınız var, ancak orijinal yaklaşımınızda neyin yanlış olduğunu merak ediyorsanız, cevap, alternatifinizin etrafında parantezlere ihtiyaç duymanızdır, aksi takdirde (\.|$)sadece sayı 200'den azsa gereklidir.

'\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]?)$

Kabul et :

127.0.0.1
192.168.1.1
192.168.1.255
255.255.255.255
0.0.0.0
1.1.1.01        # This is an invalid IP address!

Reddet :

30.168.1.255.1
127.1
192.168.1.256
-1.2.3.4
1.1.1.1.
3...3

Birim testleri ile çevrimiçi deneyin: https://www.debuggex.com/r/-EDZOqxTxhiTncN6/1

En yeni, en kısa, en az okunabilir versiyon ( 55 karakter )

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

Bu sürüm 250-5 vakasını arar, bundan sonra vakalar için tüm olası vakaları akıllıca OR (OR) yapar 200-249 100-199 10-99. |)Parçanın bir hata olmadığına, ancak 0-9 aralığı için son durum olduğuna dikkat edin . Ayrıca, ?:ele geçirilmeyen grup kısmını da atladım, çünkü ele geçirilen eşyalar gerçekten umurumuzda değil, ilk etapta tam bir maç yapmasaydık, her iki şekilde de ele geçirilmezlerdi.

Eski ve daha kısa versiyon (daha az okunabilir) ( 63 karakter )

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

Daha eski (okunabilir) sürüm ( 70 karakter )

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

Negatif önden bakışı (?!)kullanarak ipin bir.

En eski cevap ( 115 karakter )

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

Bunun en doğru ve katı normal ifade olduğunu düşünüyorum, buradaki çoğu yanıtın yaptığı gibi şeyleri kabul 000.021.01.0.etmiyor ve buna benzer durumları reddetmek için ek normal ifadeler gerektiriyor - yani 0başlangıç ​​numaraları ve bir ip ile biten bir ip.

IPv4 adresi (doğru yakalama) 0.0.0.0 ile 255.255.255.255 ile eşleşir, ancak 1.1.000.1 gibi geçersiz adresleri yakalar IP numaralarını doğru bir şekilde eşleştirmek için bu normal ifadeyi kullanın. 4 numaranın her biri bir yakalama grubunda saklanır, böylece daha sonraki işlemler için bunlara erişebilirsiniz.

\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 kütüphanesinden alınmıştır

Düzenleme: bu (\.|$)kısım garip görünüyor

IPv4 adresleri için benzer bir şey arıyordum - yaygın olarak kullanılan özel ip adreslerinin doğrulanmasını da engelleyen bir normal ifade (192.168.xy, 10.xyz, 172.16.xy), bu nedenle bunu başarmak için negatif bakış kullandım:

(?!(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}

(Bunlar tek satırda olmalı, okunabilirlik amacıyla 3 ayrı satırda biçimlendirilmelidir)

Debuggex Demosu

Hız için optimize edilmemiş olabilir, ancak yalnızca 'gerçek' internet adresleri arandığında iyi çalışır.

Başarısız olacak (ve olması gereken) şeyler:

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

Çalışacak (ve çalışması gereken) IP'ler:

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)

Başka birinin 'ortak özel adresleri içermeyen İnternet IP adreslerini' doğrulamak istediği durumlarda sağlanır

Bu yazıyı okuyan pek çok kişinin, teknik olarak geçersiz bazı IP adresleriyle eşleşseler bile, daha basit normal ifadeler arayacağını düşünüyorum. (Ve başka yerlerde de belirtildiği gibi, normal ifade muhtemelen bir IP adresini düzgün şekilde doğrulamak için doğru araç değildir.)

Satırın başlangıcını / sonunu eşleştirmek istemiyorsanız ^, kaldırın ve varsa $ile değiştirin \b.

Temel Normal İfade (BRE) (GNU grep, GNU sed ve vim üzerinde test edilmiştir):

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

Genişletilmiş Normal İfade (ERE):

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

veya:

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

Perl uyumlu Normal İfade (PCRE) (Perl 5.18 üzerinde test edilmiştir):

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

veya:

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

Ruby (Ruby 2.1'de test edildi):

PCRE olması gerekmesine rağmen, Ruby bu regex'e her ne sebeple izin verirse versin Perl 5.18 tarafından izin verilmiyor:

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

Tüm bunlar için testlerim burada çevrimiçi .

Bu, bazılarından biraz daha uzun ama IPv4 adreslerini eşleştirmek için kullandığım şey bu. Ödün vermeden basit.

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

Yukarıdaki cevaplar geçerlidir ama ip adresi satırın sonunda değilse ve metin arasındaysa .. Bu regex bunun üzerinde bile işe yarayacak.

kod: '\b((([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])(\.)){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\b'

giriş metin dosyası:

ip address 0.0.0.0 asfasf
 sad sa 255.255.255.255 cvjnzx
zxckjzbxk  999.999.999.999 jshbczxcbx
sjaasbfj 192.168.0.1 asdkjaksb
oyo 123241.24121.1234.3423 yo
yo 0000.0000.0000.0000 y
aw1a.21asd2.21ad.21d2
yo 254.254.254.254 y0
172.24.1.210 asfjas
200.200.200.200
000.000.000.000
007.08.09.210
010.10.30.110

çıktı metni:

0.0.0.0
255.255.255.255
192.168.0.1
254.254.254.254
172.24.1.210
200.200.200.200

'' 'Bu kod benim için çalışıyor ve bu kadar basit.

Burada ip'in değerini aldım ve bunu regex ile eşleştirmeye çalışıyorum.

ip="25.255.45.67"    

op=re.match('(\d+).(\d+).(\d+).(\d+)',ip)

if ((int(op.group(1))<=255) and (int(op.group(2))<=255) and int(op.group(3))<=255) and (int(op.group(4))<=255)):

print("valid ip")

else:

print("Not valid")

Yukarıdaki koşul, değerin 4 sekizlinin tümü için 255'i aşıp aşmadığını kontrol eder, bu durumda geçerli değildir. Ancak koşulu uygulamadan önce, değer bir dizede olduğundan bunları tam sayıya dönüştürmemiz gerekir.

grup (0) eşleşen çıktıyı yazdırırken, grup (1) ilk eşleşen değeri yazdırır ve burada "25" vb. '' '

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

0 ile 255 arasındaki sayılar için şu normal ifadeyi kullanıyorum:

(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))

Yukarıdaki normal ifade, 0 ile 255 arasındaki tamsayılarla eşleşecek ancak 256 ile eşleşmeyecektir.

Dolayısıyla IPv4 için şu normal ifadeyi kullanıyorum:

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

Bu yapı ^(N)((\.(N)){3})$şu şekildedir : Burada N, 0 ile 255 arasındaki bir sayıyı eşleştirmek için kullanılan normal ifadedir.
Bu normal ifade aşağıdaki gibi IP ile eşleşecektir:

0.0.0.0
192.168.1.2

ancak aşağıdakiler değil:

10.1.0.256
1.2.3.
127.0.1-2.3

IPv4 CIDR (Sınıfsız Etki Alanları Arası Yönlendirme) için şu normal ifadeyi kullanıyorum:

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

Bu yapı ^(N)((\.(N)){3})\/M$şu şekildedir : Burada N, 0 ile 255 arasındaki sayıyı eşleştirmek için kullanılan normal ifade ve M, 0 ile 32 arasındaki sayıyı eşleştirmek için kullanılan normal ifadedir.
Bu normal ifade aşağıdaki gibi CIDR ile eşleşecektir:

0.0.0.0/0
192.168.1.2/32

ancak aşağıdakiler değil:

10.1.0.256/16
1.2.3./24
127.0.0.1/33

Ve "10.0.0.0/16", "192.168.1.1/32"bu normal ifadeyi kullandığım gibi IPv4 CIDR listesi için :

^("(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))((\.(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))){3})\/(([0-9])|([12][0-9])|(3[0-2]))")((,([ ]*)("(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))((\.(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))){3})\/(([0-9])|([12][0-9])|(3[0-2]))"))*)$

Şu yapıdadır: ^(“C”)((,([ ]*)(“C”))*)$burada C, CIDR ile eşleşmek için kullanılan normal ifadedir (0.0.0.0/0 gibi).
Bu normal ifade, aşağıdaki gibi CIDR listesiyle eşleşecektir:

“10.0.0.0/16”,”192.168.1.2/32”, “1.2.3.4/32”

ancak aşağıdakiler değil:

“10.0.0.0/16” 192.168.1.2/32 “1.2.3.4/32”

Belki kısalabilir ama benim için çok iyi anlamak benim için kolay.

Umarım yardımcı olur!

Diğer tüm yanıtlardan bir normal ifade oluşturmayı başardım.

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

Alt ağ maskesi ile:

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

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

Metinde eşleşmeleri bulmak için test edin , https://regex101.com/r/9CcMEN/2

Bir IP adresinin her bir sayısındaki geçerli kombinasyonları tanımlayan kurallar aşağıdadır:

• Herhangi bir veya iki basamaklı sayı.

• İle başlayan herhangi bir üç basamaklı sayı 1.

• Herhangi üç basamaklı bir sayı başlangıcı ile 2eğer ikinci rakamdır 0 içinden 4.

• Herhangi üç basamaklı bir sayı başlangıcı ile 25eğer üçüncü basamaktır 0 yoluyla 5.

(((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.)Dört iç içe geçmiş alt ifade kümesiyle başlayalım ve onlara ters sırayla bakalım. (\d{1,2})Herhangi bir veya iki haneli bir sayı veya sayıları maçları 0aracılığıyla 99. (1\d{2})herhangi bir üç-haneli sayı ile başlangıç eşleşir 1( 1her iki basamağı takip eder), veya sayıları 100yoluyla 199. (2[0-4]\d)sayıları maçları 200aracılığıyla 249. (25[0-5])sayıları maçları 250aracılığıyla 255. Bu alt ifadelerin |her biri, her biri arasında birer alt ifadeyle (böylece dört alt ifadeden birinin tümü değil, eşleşmesi gerekecek şekilde) başka bir alt ifade içine alınır . Sayı aralığı \.eşleşmeye başladıktan sonra ) başka bir alt ifadeye eklenir ve kullanılarak üç kez tekrarlanır..Sayı ve ardından tüm seri (tüm sayı seçenekleri artı\.{3}. Son olarak, \.son IP adresi numarasıyla eşleşmek için sayı aralığı tekrarlanır (bu sefer sonda olmadan ). Arasındaki değerlere dört sayıdan oluşan her kısıtlayarak 0ve 255bu model gerçekten geçerli IP adresleri eşleştirmek ve geçersiz adresleri reddedebilir.

Alıntı: Ben Forta. "Normal İfadeleri Öğrenmek."

Bir karakter ne bir IP adresinin başına ne de sonunda istedik edilirse ^ve $meta karakterleri sırasıyla kullanılması gereken.

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

Metinde eşleşmeleri bulmak için test edin , https://regex101.com/r/uAP31A/1

Biraz daha basit ve kısaltmaya çalıştım.

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

Java / kotlin arıyorsanız:

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

Birisi nasıl çalıştığını bilmek isterse, açıklama burada. Gerçekten çok basit. Bir deneyin: p:

 1. ^.....$: '^' is the starting and '$' is the ending.

 2. (): These are called a group. You can think of like "if" condition groups.

 3. |: 'Or' condition - as same as most of the programming languages.

 4. [01]?\d{1,2}: '[01]' indicates one of the number between 0 and 1. '?' means '[01]' is optional. '\d' is for any digit between 0-9 and '{1,2}' indicates the length can be between 1 and 2. So here the number can be 0-199.

 5. 2[0-4]\d: '2' is just plain 2. '[0-4]' means a number between 0 to 4. '\d' is for any digit between 0-9. So here the number can be 200-249.

 6. 25[0-5]: '25' is just plain 25. '[0-5]' means a number between 0 to 5. So here the number can be 250-255.

 7. \.: It's just plan '.'(dot) for separating the numbers.

 8. {3}: It means the exact 3 repetition of the previous group inside '()'.

 9. ([01]?\d{1,2}|2[0-4]\d|25[0-5]): Totally same as point 2-6

Matematiksel olarak şöyle:

(0-199 OR 200-249 OR 250-255).{Repeat exactly 3 times}(0-199 OR 200-249 OR 250-255)

Normalde görebileceğiniz gibi bu, IP adreslerinin modelidir. Umarım Düzenli İfadeyi biraz anlamaya yardımcı olur. : p

Biraz daha basit ve kısaltmaya çalıştım.

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

Java / kotlin arıyorsanız:

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

Birisi nasıl çalıştığını bilmek isterse, açıklama burada. Gerçekten çok basit. Bir deneyin: p:

 1. ^.....$: '^' is the starting and '$' is the ending.

 2. (): These are called a group. You can think of like "if" condition groups.

 3. |: 'Or' condition - as same as most of the programming languages.

 4. [01]?\d{1,2}: '[01]' indicates one of the number between 0 and 1. '?' means '[01]' is optional. '\d' is for any digit between 0-9 and '{1,2}' indicates the length can be between 1 and 2. So here the number can be 0-199.

 5. 2[0-4]\d: '2' is just plain 2. '[0-4]' means a number between 0 to 4. '\d' is for any digit between 0-9. So here the number can be 200-249.

 6. 25[0-5]: '25' is just plain 25. '[0-5]' means a number between 0 to 5. So here the number can be 250-255.

 7. \.: It's just plan '.'(dot) for separating the numbers.

 8. {3}: It means the exact 3 repetition of the previous group inside '()'.

 9. ([01]?\d{1,2}|2[0-4]\d|25[0-5]): Totally same as point 2-6

Matematiksel olarak şöyle:

(0-199 OR 200-249 OR 250-255).{Repeat exactly 3 times}(0-199 OR 200-249 OR 250-255)

Normalde görebileceğiniz gibi bu, IP adreslerinin modelidir. Umarım Düzenli İfadeyi biraz anlamaya yardımcı olur. : p

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

JGsoft RegexBuddy kütüphanesinden alınan normal ifadeyi C diline (regcomp / regexec) uyarladım ve çalıştığını öğrendim ancak Linux gibi bazı işletim sistemlerinde küçük bir sorun var. Bu normal ifade, 192.168.100.009 gibi ipv4 adresini kabul eder; burada, 009, sekizlik bir değer olarak kabul edilir, bu nedenle adres, düşündüğünüz adres değildir. Bu normal ifadeyi aşağıdaki gibi değiştirdim:

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

192.168.100.009 normal ifadeyi şimdi kullanmak geçerli bir ipv4 adresi değil, 192.168.100.9 tamam.

Çok noktaya yayın adresi için bir normal ifadeyi de değiştirdim ve aşağıdaki gibi:

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

Uygulamanızı geliştirmek için normal ifadeyi kullandığınız dile uyarlamanız gerektiğini düşünüyorum.

Java'da bir örnek verdim:

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

-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

(Bu, adres alanının tamamıyla (yayınlar vb. Dahil) başka hiçbir şeyle eşleşmeyen bir DFA'dır.

Sanırım bu en kısa olanı.

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

Bu örneği çok kullanışlı buldum, ayrıca farklı ipv4 gösterimlerine izin veriyor.

python kullanarak örnek kod:

    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

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

Bu normal ifade 08.8.8.8 veya 8.08.8.8 veya 8.8.08.8 veya 8.8.8.08'i kabul etmeyecektir.

IP rakamlar dışındaki herhangi bir karakterin etrafına sarıldığı sürece (IP'nin arkasında veya önünde) geçerli bir IP adresi bulur. 4 Geri referans oluşturuldu: $ + {ilk}. $ + {Saniye}. $ + {Üçüncü}. $ + {İleri}

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.

Her sekizlinin bir bölümünü gerçek bir değerle değiştirmek, ancak metin dosyalarındaki IP'leri değiştirmek için gerçekten yararlı olan kendi bul ve değiştir'inizi oluşturabilirsiniz:

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

Yine de daha önce olduğu gibi geri yönlendirme gruplarını kullanarak Değiştir işlemini gerçekleştirebilirsiniz.

Aşağıdakilerin nasıl eşleştiğine dair bir fikir edinebilirsiniz:

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

Grep kullanarak aşağıdaki sonuçları görebilirsiniz:

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

IPv4 adresi çok karmaşık bir şeydir.

Not : Girinti ve çizgi yalnızca örnekleme amaçlıdır ve gerçek Normal İfadede mevcut değildir.

\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

Bu IPv4 adresleri yukarıdaki RegEx tarafından doğrulanır.

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

Bunlar reddedildi.

256.0.0.1
192.168.1.099 # 099 is not a valid number
4294967296 # UINT32_MAX + 1
0x100000000
020000000000

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

Yukarıdaki gibi ip adresi için normal ifade olacaktır: 221.234.000.112 ayrıca 221.234.0.112, 221.24.03.112, 221.234.0.1

Yukarıdaki gibi her türlü adresi hayal edebilirsiniz

PCRE ve defineanahtar kelimeyi kullanırdım:

/^
 ((?&byte))\.((?&byte))\.((?&byte))\.((?&byte))$
 (?(DEFINE)
     (?<byte>25[0-5]|2[0-4]\d|[01]?\d\d?))
/gmx

Demo: https://regex101.com/r/IB7j48/2

Bunun nedeni (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)modeli dört kez tekrar etmekten kaçınmaktır . Aşağıdaki gibi diğer çözümler iyi işliyor, ancak birçokları tarafından talep edildiği gibi her grubu yakalayamıyor.

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

4 yakalama grubuna sahip olmanın diğer tek yolu, düzeni dört kez tekrarlamaktır:

/^(?<one>\d+)\.(?<two>\d+)\.(?<three>\d+)\.(?<four>\d+)$/

Perl'de bir ipv4 yakalamak bu nedenle çok kolaydır

$ 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]

Hayal edebileceğim en kesin, basit ve kompakt IPv4 regexp

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

Peki ya performansı / verimliliği ... Üzgünüm bilmiyorum, kimin umrunda?

Bunu dene:

\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

ip address can be from 0.0.0.0 to 255.255.255.255

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

(0|1)?[0-9][0-9]? - checking value from 0 to 199
2[0-4][0-9]- checking value from 200 to 249
25[0-5]- checking value from 250 to 255
[.] --> represent verify . character 
{3} --> will match exactly 3
$ --> end of string

IP Adresini doğrulamak için normal ifade ifadesi aşağıdadır.

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

Kolay yol

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

Demo