Explication détaillée des expressions régulières js

Les expressions régulières sont très utiles pour rechercher, faire correspondre, traiter des chaînes, remplacer et convertir des chaînes, entrer et sortir, etc. Voici quelques expressions régulières couramment utilisées.

Caractères réguliers couramment utilisés

1. : changer le caractère suivant Marqué comme un caractère spécial, ou un caractère littéral, ou une référence arrière, ou un caractère d'échappement octal. Par exemple, « n » correspond au caractère « n ». 'n' correspond à un caractère de nouvelle ligne. La séquence '' correspond à "" et "(" correspond à "(".

2.^ : correspond à la chaîne d'entrée La position de départ. Si la propriété Multiline de l'objet RegExp est définie, ^ correspond également à la position après 'n' ou 'r'

 : correspond à la position de fin du. chaîne d'entrée. Si la propriété Multiline de l'objet RegExp est définie, $ correspond également à la position avant 'n' ou 'r' 4.$ : correspond à la sous-expression précédente. zéro ou plusieurs fois. Par exemple, zo peut correspondre à "z" et "zoo", etc. Valable en

5. * : correspond à la sous-expression précédente une ou plusieurs fois. 'zo+' correspond à "zo" et "zoo", mais pas "z + n'est équivalent à {1,}.6.

 : Faites correspondre la sous-expression précédente zéro ou une fois. Par exemple, "faire(s) ?" faire" ou "fait" ? est équivalent à {0. ,1}. +7.

 : n est un un entier non négatif correspondant n fois. o{2}' ne peut pas correspondre au 'o' dans "Bob", mais il peut correspondre aux deux o dans "food" ?8.

 : n est un entier non négatif. Correspond au moins n fois. Par exemple, "o{2,}" ne peut pas correspondre à "o" dans "Bob". il peut correspondre à tous les o dans "foooood". 'o{1,}' est équivalent à 'o+' 'o{0,}' est équivalent à 'o*'. : m et n sont tous deux des entiers non négatifs, où n {n}10.

 : Lorsque ce caractère est immédiatement suivi de tout autre limiteur (*, +, ?, {n}, {n,}, {n,m }), le mode de correspondance est non -gourmand. Le mode non gourmand correspond le moins possible à la chaîne recherchée, tandis que le mode gourmand par défaut correspond le plus possible à la chaîne recherchée. Par exemple, pour la chaîne "oooo". un seul "o", tandis que "o+" correspondra à tous les "o". {n,}11.

 : correspond à n'importe quel caractère sauf "n". Pour faire correspondre n'importe quel caractère incluant « n », utilisez un modèle tel que « [.n] ». {n,m}12.

 : Faites correspondre le modèle et obtenez cette correspondance. Les correspondances obtenues peuvent être obtenues à partir de la collection Matches générée, en utilisant la collection SubMatches dans VBScript ou les propriétés $0…$9 dans JScript. Pour faire correspondre les caractères entre parenthèses, utilisez '(' ou ')'.

13.(?:pattern) : correspond au modèle mais n'obtient pas le résultat correspondant, ce qui signifie qu'il s'agit d'une correspondance non obtenue et n'est pas stockée pour plus tard utiliser. Ceci est utile lorsque vous utilisez le caractère « ou » (|) pour combiner des parties d'un motif. Par exemple, « industr(?:y|ies) est une expression plus courte que « industry|industries ».

14.(?=pattern) : recherche directe, faisant correspondre la chaîne de recherche au début de tout modèle de correspondance de chaîne. Il s'agit d'une correspondance sans récupération, c'est-à-dire qu'il n'est pas nécessaire de récupérer la correspondance pour une utilisation ultérieure. Par exemple, « Windows (?=95|98|NT|2000) » correspond à « Windows » dans « Windows 2000 » mais pas à « Windows » dans « Windows 3.1 ». La prélecture ne consomme pas de caractères, c'est-à-dire qu'après une correspondance, la recherche de la correspondance suivante commence immédiatement après la dernière correspondance, plutôt qu'après le caractère contenant la prélecture.

15.(?!pattern) : recherche négative, correspond à la chaîne de recherche au début de toute chaîne qui ne correspond pas au modèle. Il s'agit d'une correspondance sans récupération, c'est-à-dire qu'il n'est pas nécessaire de récupérer la correspondance pour une utilisation ultérieure. Par exemple, « Windows (?!95|98|NT|2000) » correspond à « Windows » dans « Windows 3.1 », mais pas à « Windows » dans « Windows 2000 ». La prélecture ne consomme pas de caractères, c'est-à-dire qu'après une correspondance, la recherche de la correspondance suivante commence immédiatement après la dernière correspondance, plutôt que de commencer après les caractères contenant la prélecture

16. x|y : Faites correspondre x ou y. Par exemple, « z|food » correspond à « z » ou « food ». '(z|f)ood' correspond à "zood" ou "food".

17.[xyz] : Collection de personnages. Correspond à l'un des caractères contenus. Par exemple, « [abc] » correspond à « a » dans « plain ».

18.[^xyz] : jeu de caractères de valeur négative. Correspond à n’importe quel caractère non inclus. Par exemple, « 1 » correspond à « p » dans « plain ».

19.[a-z] : plage de caractères. Correspond à n’importe quel caractère dans la plage spécifiée. Par exemple, « [a-z] » correspond à n’importe quel caractère alphabétique minuscule compris entre « a » et « z ».

20.[^a-z] : Plage de caractères négative. Correspond à tout caractère ne se trouvant pas dans la plage spécifiée. Par exemple, « 2 » correspond à tout caractère qui n'est pas compris entre « a » et « z ».

21.b : Faites correspondre une limite de mot, c'est-à-dire la position entre le mot et l'espace. Par exemple, « erb » correspond au « er » dans « jamais » mais pas au « er » dans « verbe ».

22.B : faites correspondre les limites des mots. « erB » correspond à « er » dans « verbe » mais pas dans « jamais ».

23.cx : correspond au caractère de contrôle spécifié par x. Par exemple, cM correspond à un caractère Control-M ou à un retour chariot. La valeur de x doit être A-Z ou a-z. Sinon, c est traité comme un caractère « c » littéral.

24.d : correspond à un caractère numérique. Équivalent à [0-9].

25.D : correspond à un caractère non numérique. Équivalent à 3.

26.f : correspond à un saut de formulaire. Équivalent à x0c et cL.

27.n : correspond à un caractère de nouvelle ligne. Équivalent à x0a et cJ.

28.r : correspond à un caractère de retour chariot. Équivalent à x0d et cM.

29.s : correspond à tous les caractères d'espacement, y compris les espaces, les tabulations, les sauts de formulaire, etc. Équivalent à [fnrtv].

30.S : correspond à tout caractère autre qu'un espace. Équivalent à 4.

31.t : correspond à un caractère de tabulation. Équivalent à x09 et cI.

32.v : correspond à un caractère de tabulation verticale. Équivalent à x0b et cK.

33.w : correspond à n'importe quel caractère de mot, y compris un trait de soulignement. Équivalent à '[A-Za-z0-9_]'.

34.W : correspond à n'importe quel caractère autre qu'un mot. Équivalent à « 5 ».

35.xn : correspond à n, où n est une valeur d'échappement hexadécimale. La valeur d’échappement hexadécimale doit comporter exactement deux chiffres. Par exemple, « x41 » correspond à « A ». « x041 » est équivalent à « x04 » et « 1 ». Le codage ASCII peut être utilisé dans les expressions régulières.

36.num : correspond à num, où num est un entier positif. Une référence au match obtenu. Par exemple, « (.)1 » correspond à deux caractères identiques consécutifs.

37.n : Identifie une valeur d'échappement octale ou une référence arrière. Si n est précédé d'au moins n sous-expressions récupérées, n est une référence vers l'arrière. Sinon, si n est un nombre octal (0-7), alors n est une valeur d'échappement octale.

38.nm : Identifie une valeur d'échappement octale ou une référence arrière. nm est une référence vers l'arrière si nm est précédé d'au moins nm sous-expressions pouvant être obtenues. Si nm est précédé d'au moins n, alors n est une référence vers l'arrière suivie du littéral m. Si aucune des conditions précédentes n'est vraie et si n et m sont tous deux des chiffres octaux (0-7), nm correspondra à la valeur d'échappement octale nm.

39.nml : Si n est un nombre octal (0-3), et m et l sont tous deux des nombres octaux ( 0-7), correspond à la valeur d'échappement octale nml.

Type RegExp

ECMAScript prend en charge les expressions régulières via le type RegExp, comme suit :

var expression = /pattern/flags;

La partie motif （pattern） peut être n'importe quelle expression régulière simple ou complexe et peut inclure des classes de caractères, des qualificatifs, un regroupement, une recherche avant et des références arrière. Chaque expression régulière peut avoir une ou plusieurs annotations （flags） pour indiquer le comportement de l'expression régulière. Il y a trois signes suivants :

• g : indique le mode global, c'est-à-dire que le mode sera appliqué à toutes les chaînes, ne pas s'arrêter immédiatement lorsque la première correspondance est trouvée.

• i : Indique le mode insensible à la casse.

• m : Indique le mode multiligne, c'est-à-dire que lorsqu'on atteint la fin d'une ligne de texte, il continue à recherchez s'il existe dans la ligne suivante.

正则表达式定义方式

以字面量的形式来定义正则表达式

例如：匹配第一个bat或者cat,不区分大小写

var pattern = /[bc]at/i;

使用RegExp构造函数

它接收两个参数：一个是要匹配的字符串模式，另一个是可选的标志字符串。可以使用字面量定义的任何表达式，都可以使用构造函数来定义，还是以上面的例子为例：

var pattern = new RegExp("[bc]at","i");

注意:RegExp构造函数模式参数时字符串，所以再某些情况下要对字符进项双重转义。所有元字符都必须双重转义，如字面量模式为/\[bc\]at/,那么等价的字符串为"/\\[bc\\]at/"

例子：

var re = null,
    i;    for(i=0; i < 10; i++){
        re = /cat/g;
        console.log(re.test("catastrophe"));
    }    for(i=0; i < 10; i++){
        re = new RegExp("cat","g");
        console.log(re.test("catastrophe"));
    }

打印结果都为10个true

正则表达式方法

RegExp对象的exec()方法

该方法是专门为捕获组而设计的，其接受一个参数，即要应用模式的字符串，然后返回包含第一个匹配项信息的数组；或者在没有匹配项的情况下返回null。返回的数组虽然是Array的实例，但是包含两个额外的属性：index和input。其中index表示匹配项在字符串中的位置，而input表示应用字符串表达式的字符串。
例：

var text = "mom and dad and baby";var pattern = /mom( and dad( and baby)?)?/gi;var matches = pattern.exec(text);
console.log(matches.index); 
//0console.log(matches.input); 
//mom and dad and babyconsole.log(matches[0]);    
//mom and dad and babyconsole.log(matches[1]);    
//and dad and babyconsole.log(matches[2]);    
//and baby

对于exec()方法而言，即使在模式中设置了全局标志g，它每次也只是返回一个匹配项。在不设置全局标志的情况下，在同一个字符串上多次调用exec()方法将始终返回第一个匹配项的信息。而在设置全局标志的情况下，每次调用exec()则都会在字符串中继续查找新匹配项，如下例子：

var text = "cat, bat, sat, fat";var pattern1 = /.at/;var matches = pattern1.exec(text);
console.log(matches.index); //0console.log(matches[0]);  //catconsole.log(pattern1.lastIndex); //0matches = pattern1.exec(text);
console.log(matches.index); //0console.log(matches[0]);  //catconsole.log(pattern1.lastIndex); 
//0var pattern2 = /.at/g;var matches = pattern2.exec(text);
console.log(matches.index); //0console.log(matches[0]);  //catconsole.log(pattern2.lastIndex); //3var matches = pattern2.exec(text);
console.log(matches.index); //5console.log(matches[0]);  //batconsole.log(pattern2.lastIndex); //8

注意：IE的JavaScript实现lastIndex属性上存在偏差，即使在非全局模式下，lastIndex属性每次也都在变化。

test()方法

正则表达式常用方法test()，它接受一个字符串参数。在模式与该参数匹配的情况下返回true，否则返回false。
例如：

var text ="000-00-0000";var pattern = /\d{3}-\d{2}-\d{4}/;if(pattern.test(text)){
    console.log('the pattern was matched.');
}

match方法

获取正则匹配到的结果，以数组的形式返回例如：

"186a619b28".match(/\d+/g); 
// ["186","619","28"]

replace方法

replace 本身是JavaScript字符串对象的一个方法，它允许接收两个参数：

replace([RegExp|String],[String|Function])

第1个参数可以是一个普通的字符串或是一个正则表达式.
第2个参数可以是一个普通的字符串或是一个回调函数.

如果第2个参数是回调函数，每匹配到一个结果就回调一次，每次回调都会传递以下参数：

• result: 本次匹配到的结果

• $1,...$9: 正则表达式中有几个()，就会传递几个参数，$1~$9分别代表本次匹配中每个()提取的结果，最多9个

• offset:记录本次匹配的开始位置

• source:接受匹配的原始字符串

以下是replace和JS正则搭配使用的几个常见经典案例：

（1）实现字符串的trim函数，去除字符串两边的空格

String.prototype.trim = function(){ 
  //方式一：将匹配到的每一个结果都用""替换
  return this.replace(/(^\s+)|(\s+$)/g,function(){    return "";
  }); 
  //方式二：和方式一的原理相同
  return this.replace(/(^\s+)|(\s+$)/g,'');
};

^s+ 表示以空格开头的连续空白字符，s+$ 表示以空格结尾的连续空白字符，加上() 就是将匹配到的结果提取出来，由于是 | 的关系，因此这个表达式最多会match到两个结果集，然后执行两次替换：

String.prototype.trim = function(){  /**
   * @param rs：匹配结果
   * @param $1:第1个()提取结果
   * @param $2:第2个()提取结果
   * @param offset:匹配开始位置
   * @param source：原始字符串   */
  this.replace(/(^\s+)|(\s+$)/g,function(rs,$1,$2,offset,source){    //arguments中的每个元素对应一个参数    console.log(arguments);
  });
}; 
" abcd ".trim();

输出结果：

[" ", " ", undefined, 0, " abcd "] 
//第1次匹配结果
[" ", undefined, " ", 5, " abcd "] 
//第2次匹配结果

（2）提取浏览器url中的参数名和参数值，生成一个key/value的对象

function getUrlParamObj(){  var obj = {};  //获取url的参数部分
  var params = window.location.search.substr(1);  //[^&=]+ 表示不含&或=的连续字符，加上()就是提取对应字符串
  params.replace(/([^&=]+)=([^&=]*)/gi,function(rs,$1,$2){
    obj[$1] = $2;
  }); 
  return obj;
}

/([^&=]+)=([^&=]*)/gi 每次匹配到的都是一个完整key/value,形如 <span style="color: #ff0000;">xxxx=xxx</span>, 每当匹配到一个这样的结果时就执行回调，并传递匹配到的key和value，对应到$1和$2

（3）在字符串指定位置插入新字符串

String.prototype.insetAt = function(str,offset){ 
  //使用RegExp()构造函数创建正则表达式
  var regx = new RegExp("(.{"+offset+"})"); 
  return this.replace(regx,"$1"+str);
}; 
"abcd".insetAt('xyz',2); //在b和c之间插入xyz//结果 "abxyzcd"

当offset=2时，正则表达式为：(^.{2}) .表示除\n之外的任意字符，后面加{2} 就是匹配以数字或字母组成的前两个连续字符，加()就会将匹配到的结果提取出来，然后通过replace将匹配到的结果替换为新的字符串，形如：结果=结果+str

（4） 将手机号12988886666转化成129 8888 6666

function telFormat(tel){
 
  tel = String(tel); 
  //方式一
  return tel.replace(/(\d{3})(\d{4})(\d{4})/,function (rs,$1,$2,$3){    return $1+" "+$2+" "+$3
  }); 
  //方式二
  return tel.replace(/(\d{3})(\d{4})(\d{4})/,"$1 $2 $3");
}

(\d{3}\d{4}\d{4}) 可以匹配完整的手机号，并分别提取前3位、4-7位和8-11位，"$1 $2 $3" 是在三个结果集中间加空格组成新的字符串，然后替换完整的手机号。

常用实例

匹配第一个bat或者cat,不区分大小写： <span style="color: #ff0000;">/[bc]at/i</span> 或者 new RegExp("[bc]at","i");

匹配所有以"at"结尾的3个字符组合，不区分大小写：/.at/gi;

只能输入数字：^[0-9]*$;

只能输入n位的数字：^\d{n}$

只能输入至少n位的数字：^\d{n,}$

只能输入m~n位的数字：^\d{m,n}$

只能输入零和非零开头的数字：^(0|[1-9][0-9]*)$

只能输入有两位小数的正实数：^[0-9]+(.[0-9]{2})?$

只能输入有1~3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$

只能输入非零的正整数：^\+?[1-9][0-9]*$

只能输入长度为3的字符：^.{3}$

Seules les chaînes composées de 26 lettres anglaises peuvent être saisies : ^[A-Za-z]+$

Seules des chiffres et 26 lettres anglaises peuvent être saisies Une chaîne composée de : ^[A-Za-z0-9]+$

Seule une chaîne composée de chiffres, 26 lettres anglaises ou traits de soulignement peut être saisie : ^w+$

Vérifier le mot de passe de l'utilisateur : commencez par une lettre, mesurez entre 6 et 18 lettres et ne peut contenir que des caractères, des chiffres et des traits de soulignement : ^[a-zA-Z]w{5,17}$

Vérifiez s'il contient des caractères tels que ^%&',;=?$": [^%&',;=?$x22]+

ne peut être Caractères chinois saisis : ^[u4e00-u9fa5]{0,}$

Vérifier l'adresse e-mail : ^w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*$

Vérifier l'URL Internet :^http://([w-]+.)+[w-]+(/[w-./?%&=]*)?$

Vérifier le numéro d'identification (15 ou 18 chiffres) : ^d{15}|d{18}$

Vérifiez l'adresse IP : ^((2[0-4]d|25[0-5]|[01]?dd?).){3}(2[0-4]d|25[0-5]|[01]?dd?)$

Correspond à deux caractères qui se chevauchent. Par exemple, "aabbc11asd", le résultat renvoyé est aa bb 11. trois ensembles de correspondance : (w)1

Faire correspondre les balises HTML appariées : 36f5b8c5490f89f869cc27a69ae2619f[^s>]+)[^>]*>.*942957934194d656236298ebe7d0e760>

Correspond aux nombres compris entre 1 et 58 : /^([1-9]|[1-5][0-8])$/

Correspond à un nombre entier entre -90 et 90 (inclus) : ^(-?[1-8][0-9]|-?[1-9]|-?90|0) $

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!