J'ai plusieurs adresses IP comme:
115.42.150.37
115.42.150.38
115.42.150.50
Quel type d'expression régulière dois-je écrire si je souhaite rechercher les 3 adresses IP? Par exemple, si je fais 115.42.150.*
(je pourrai rechercher les 3 adresses IP)
Ce que je peux faire maintenant est quelque chose comme: /[0-9]{1-3}\.[0-9]{1-3}\.[0-9]{1-3}\.[0-9]{1-3}/
mais cela ne semble pas bien fonctionner.
Merci.
La regex que vous avez déjà a plusieurs problèmes:
Tout d'abord, il contient des points. En regex, un point signifie "correspondre à n'importe quel caractère", où vous devez rechercher uniquement un point réel. Pour cela, vous devez y échapper, alors mettez une barre oblique en face des points.
Deuxièmement, vous faites correspondre trois chiffres dans chaque section. Cela signifie que vous ferez correspondre tout nombre compris entre 0 et 999, qui contient évidemment de nombreux numéros d'adresses IP non valides.
Cela peut être résolu en rendant le rapprochement des nombres plus complexe; il y a d'autres réponses sur ce site qui expliquent comment faire cela, mais franchement, cela ne vaut pas l'effort - à mon avis, vous feriez bien mieux de scinder la chaîne par points, puis de valider simplement les quatre blocs comme étant numériques plages entières - c'est-à-dire:
if(block > 0 && block <256) {....}
J'espère que cela pourra aider.
Peut-être en retard, mais quelqu'un pourrait essayer:
Exemple d'adresse IP valide
115.42.150.37
192.168.0.1
110.234.52.124
Exemple d'adresse 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]
Code JavaScript pour valider une adresse 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)
}
Essayez celui-ci, c'est une version plus courte:
^(?!0)(?!.*\.$)((1?\d?\d|25[0-5]|2[0-4]\d)(\.|$)){4}$
A expliqué:
^ 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
Test unitaire pour la console d'un navigateur:
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);});
Essayez celui-ci .. Source de ici .
"\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"
Si vous voulez quelque chose de plus lisible que regex pour ipv4 dans les navigateurs modernes, vous pouvez aller avec
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;
}
/^(?!.*\.$)((?!0\d)(1?\d?\d|25[0-5]|2[0-4]\d)(\.|$)){4}$/
Crédit complet à oriadam . J'aurais commenté ci-dessous sa réponse pour suggérer le changement à zéro zéro que j'ai fait, mais je n'ai pas encore assez de réputation ici ...
changement:
- (?! 0) Parce que les adresses IPv4 commençant par des zéros ('0.248.42.223') sont valide ( mais pas utilisable )
+ (?! 0\d) Etant donné que les adresses IPv4 avec des zéros non significatifs ('63,14.209.00 'et' 011.012.013.014 ') peuvent sont parfois interprétées comme octal
Expression régulière pour le format d'adresse 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])$/;
Un court RegEx: ^(?:(?:^|\.)(?:2(?:5[0-5]|[0-4]\d)|1?\d?\d)){4}$
Exemple
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'));
Et au lieu de
{1-3}
tu devrais mettre
{1,3}
Si vous écrivez le code approprié, vous n’avez besoin que de cette expression régulière très simple:/\ 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";
}
Mais en réalité, vous obtenez un code encore plus simple en n'utilisant aucune expression régulière:
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";
}
Ma version en tant que méthode es6, renvoie true pour les adresses IP valides, false sinon
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;
}
Jeter une contribution tardive:
^(?!\.)((^|\.)([1-9]?\d|1\d\d|2(5[0-5]|[0-4]\d))){4}$
Parmi les réponses que j'ai vérifiées, leur vérification est soit plus longue, soit incomplète. Plus longtemps, selon mon expérience, cela signifie plus difficile à négliger et donc plus enclin à être erroné. Et j'aime éviter de répéter des modèles similaires, pour la même raison.
La partie principale est, bien sûr, le test pour un nombre - 0 à 255, mais vous devez également vous assurer qu'il ne permet pas les zéros initiaux (sauf s'il s'agit d'un seul):
[1-9]?\d|1\d\d|2(5[0-5]|[0-4]\d)
Trois alternances - une pour le sous 100: [1-9]?\d
, une pour 100-199: 1\d\d
et enfin 200-255: 2(5[0-5]|[0-4]\d)
.
Ceci est précédé d'un test pour début de ligneou un point .
, et cette expression entière est testée 4 fois par le {4}
ajouté.
Ce test complet pour les représentations sur quatre octets est démarré en testant le début de la ligne, suivi d’un regard négatif pour éviter les adresses commençant par .
: ^(?!\.)
et se terminant par un test en fin de ligne ($
).
La solution ci-dessous n'accepte pas les zéros de remplissage
Voici le moyen le plus propre de valider une adresse IP, décomposons-le:
Fait: une adresse IP valide a 4 octets
, chaque octet peut être un nombre compris entre 0 - 255
Ventilation de Regex.
25[0-5]
correspond à 250 - 255
2[0-4][0-9]
correspond à 200 - 249
1[0-9][0-9]
correspond à 100 - 199
[1-9][0-9]?
correspond à 1 - 99
0
correspond à 0
Notes: Lorsque vous utilisez new RegExp
, vous devez utiliser \\.
au lieu de \.
car la chaîne sera échappée deux fois.
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);
}
Toujours à la recherche de variantes, cela semblait être une tâche répétitive alors pourquoi ne pas utiliser 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;
}
}
c'est peut-être mieux:
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;
}
\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b
correspond à 0.0.0.0 à 999.999.999.999 à utiliser si vous savez que seachdata ne contient pas d'adresses IP invalides
\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
utiliser pour faire correspondre les numéros IP avec précision - chacun des 4 numéros est stocké dans son propre groupe de capture, afin que vous puissiez y accéder plus tard
Ne pas écrire votre propre regex ou copier coller! Vous ne couvrirez probablement pas tous les filtres Edge (IPv6, mais aussi les IP octales, etc.). Utilisez is-ip
à partir de npm:
var isIp = require('is-ip');
isIp('192.168.0.1');
Retournera un booléen.
Downvoters : vous expliquez pourquoi utiliser une bibliothèque maintenue activement est préférable au copier-coller depuis un site Web?