Partagez quelques exemples d'expressions régulières couramment utilisés-js tutoriel-php.cn

Résumé des expressions régulières couramment utilisées

Les expressions régulières sont également appelées expressions régulières et expressions conventionnelles. (Anglais : Regular Expression, souvent abrégé en regex, regexp ou RE dans le code), un concept en informatique. Les expressions régulières utilisent une seule chaîne pour décrire et faire correspondre une série de mots correspondant à une certaine règle de syntaxe. Dans de nombreux éditeurs de texte, les expressions régulières sont souvent utilisées pour récupérer et remplacer du texte correspondant à un certain modèle.

Expressions régulières, y a-t-il quelqu'un comme moi, qui l'a appris plusieurs fois mais qui est encore confus. Quand je l'apprends, je le comprends toujours, mais après l'avoir appris, j'oublie tout. Eh bien, en fait, je n'ai pas encore assez pratiqué. La soi-disant révision du passé et l'apprentissage du nouveau peuvent être un enseignant. Aujourd'hui, permettez-moi de revoir cette fière expression régulière.

Pourquoi avons-nous besoin d'expressions régulières ? En fait, c'est parce que les ordinateurs sont stupides (ce n'est pas ce que j'ai dit). Par exemple, 123456@qq.com, quand on le regarde, c'est une adresse email, mais l'ordinateur ne la reconnaît pas, donc on a. utiliser certains langages que les ordinateurs comprennent pour formuler des règles et leur dire. Celui qui se conforme à cette règle est une boîte aux lettres, donc l'ordinateur peut nous aider à trouver la chose correspondante. Ainsi, les règles régulières sont utilisées pour définir des règles permettant d'effectuer certaines opérations dont nous avons besoin, telles que la vérification de la connexion, la recherche d'éléments spécifiés, etc. Il est redondant d'en dire trop, passons directement au sujet.

Définir régulier :

1 var re = new RegExp("a"); //RegExp object. Les paramètres sont les règles que nous voulons établir. Il existe une situation où cette méthode doit être utilisée, qui sera mentionnée ci-dessous.

2 var re = /a/; // La méthode d'abréviation est recommandée pour de meilleures performances. Elle ne peut pas être vide sinon elle sera considérée comme un commentaire.

Méthodes régulières couramment utilisées

1 test() : recherche du contenu conforme aux règles régulières dans une chaîne. S'il est trouvé, il renvoie vrai, sinon il renvoie faux.

Utilisation : regular.test(string)

Exemple : Déterminer s'il s'agit d'un nombre

var str = '374829348791';

var re = /D /; // D signifie non-chiffre

if( re.test(str) ){ // Renvoie vrai, ce qui signifie qu'un non-chiffre a été trouvé dans la chaîne.

alert('Pas tous les numéros');

}else{

alert('Tous les numéros');

}

Il existe de nombreux symboles dans les expressions régulières, qui représentent différentes significations et sont utilisés pour nous permettre de définir différentes règles, comme D ci-dessus, et les suivantes :

s : espace

S : non-espace

d : chiffre

D : non-chiffre

w : caractère (lettre, chiffre, trait de soulignement_ )

W : Exemples sans caractères : Y a-t-il des caractères qui ne sont pas des nombres ?

(Ce qui suit parlera de certains caractères couramment utilisés sur la base d'exemples, et enfin résumera.)

2 search() : recherche le contenu normal dans la chaîne et renvoie la position où il apparaît (en commençant à 0, si plus d'une lettre correspond, seule la position de la première lettre sera renvoyée), si la recherche renvoie -1 en cas d'échec

Utilisation : string.search(regular)

Trouver le contenu de l'expression régulière composée dans la chaîne. Ignorer la casse : i——ignore (regular est sensible à la casse par défaut. S'il n'est pas sensible à la casse, ajoutez l'identifiant i à la fin du régulier)

Exemple : recherchez la lettre b dans la chaîne , et non sensible à la casse

var str = 'abcdef';

var re = /B/i;

// var re = new RegExp('B','i'); Vous pouvez également écrire

alert( str.search(re) ); // 1

3 match() Recherche le contenu de la règle composée dans la chaîne. Si la recherche réussit, le contenu sera renvoyé sous la forme d'un tableau. Si la recherche échoue, null sera renvoyé. .

Utilisation : String.match (régulier)

Quantificateur : + Au moins une correspondance se produit un nombre indéterminé de fois (la correspondance signifie la recherche)

Correspondance globale : g —— global (par défaut dans les règles normales, la recherche se terminera tant que le contenu de la règle composée est recherché)

Exemple : recherchez tous les nombres dans le format spécifié, recherchez 123, 54, 33, 879 comme suit

var str = 'haj123sdk54hask33dkhalsd879';

var re = /d+/g; // Correspond à au moins un numéro à chaque fois et correspond globalement . S'il ne s'agit pas d'une correspondance globale, lorsqu'il trouve le nombre 123, il s'arrête. Seuls 123 apparaîtront. Avec la correspondance globale, il recherchera ceux qui correspondent aux règles du début à la fin. S’il n’y a pas de signe plus, les résultats correspondants sont 1, 2, 3, 5, 4, 3, 3, 879, ce qui n’est pas ce que nous souhaitons. Avec le signe plus, il y aura au moins un nombre correspondant à chaque fois.

alerte( str.match(re) ); // [123, 54, 33, 879]

4 replace() : recherchez une chaîne qui correspond au modèle régulier et remplacez-la par la chaîne correspondante. Renvoyez le contenu remplacé.

Utilisation : String.replace(regular, new string/callback function) (dans la fonction de rappel, le premier paramètre fait référence au caractère qui correspond avec succès à chaque fois)

: signifie ou.

例子：敏感词过滤，比如我爱北京天安门，天安门上太阳升。------我爱*****，****上太阳升。即北京和天安门变成*号，

一开始我们可能会想到这样的方法：

var str = "我爱北京天安门，天安门上太阳升。";

var re = /北京|天安门/g; // 找到北京或者天安门全局匹配

var str2 = str.replace(re,'*');

alert(str2) //我爱**，*上太阳升

//这种只是把找到的变成了一个*，并不能几个字就对应几个*。

要想实现几个字对应几个*，我们可以用回调函数实现：

var str = "我爱北京天安门，天安门上太阳升。";

var re = /北京|天安门/g; // 找到北京或者天安门全局匹配

var str2 = str.replace(re,function(str){

alert(str); //用来测试：函数的第一个参数代表每次搜索到的符合正则的字符，所以第一次str指的是北京第二次str是天安门第三次str是天安门

var result = '';

for(var i=0;i

result += '*';

}

return result; //所以搜索到了几个字就返回几个*

});

alert(str2) //我爱*****，***上太阳升

//整个过程就是，找到北京，替换成了两个*，找到天安门替换成了3个*，找到天安门替换成3个*。

replace是一个很有用的方法，经常会用到。

正则中的字符

()：，小括号，叫做分组符。就相当于数学里面的括号。如下：

var str = '2013-6-7';

var re1 = /\d-+/g; // 全局匹配数字，横杠，横杠数量至少为1，匹配结果为： 3- 6-

var re1 = /(\d-）+/g; // 全局匹配数字，横杠，数字和横杠整体数量至少为1 3-6-

var re2 = /(\d+)(-)/g; // 全局匹配至少一个数字，匹配一个横杠匹配结果：2013- 6-

同时，正则中的每一个带小括号的项，都叫做这个正则的子项。子项在某些时候非常的有用，比如我们来看一个栗子。

例子：让2013-6-7 变成 2013.6.7

var str = '2013-6-7';

var re = /(\d+)(-)/g;

str = str.replace(re,function($0,$1,$2){

//replace()中如果有子项， //第一个参数：$0（匹配成功后的整体结果 2013- 6-）,

// 第二个参数 : $1(匹配成功的第一个分组，这里指的是\d 2013, 6)

//第三个参数 : $1(匹配成功的第二个分组，这里指的是- - - )

return $1 + '.'; //分别返回2013. 6.

});

alert( str ); //2013.6.7

//整个过程就是利用子项把2013- 6- 分别替换成了2013. 6. 最终弹出2013.6.7

match方法也会返回自己的子项，如下：

var str = 'abc';

var re = /(a)(b)(c)/;

alert( str.match(re) ); //[abc,a,b,c]( 返回的是匹配结果以及每个子项当match不加g的时候才可以获取到子项的集合)

[] ：表示某个集合中的任意一个，比如 [abc] 整体代表一个字符匹配 a b c 中的任意一个，也可以是范围，[0-9] 范围必须从小到大。

[^a] 整体代表一个字符：^写在[]里面的话，就代表排除的意思

例子：匹配HTML标签比如

hahahah

找出标签

var re = /<[^>]+>/g; //Faire correspondre le contenu d'au moins un crochet non droit entre les crochets gauches (car il y a des attributs et d'autres éléments dans la balise), puis faire correspondre le crochet droit var re = /<[wW]+>/g; // Faire correspondre au moins un caractère ou un contenu non-caractère au milieu du crochet gauche, puis faire correspondre le contenu droit bracket // En fait, cela signifie trouver le crochet gauche, et alors il peut y avoir au moins un caractère au milieu. Un élément de contenu, jusqu'à ce que vous trouviez le crochet droit, représente une balise.

Caractères d'échappement

s : espace

S : non-espace

d : nombre

D : non-numéro

w : caractère (lettre, chiffre, trait de soulignement_)

W : non-caractère

: n'importe quel caractère

: point réel

b : partie indépendante (début, fin, espace)

B : partie non indépendante

Regardons les deux dernières :

var str = 'onetwo';

var str2 ="un deux";

var re = /oneb/; // derrière e Doit être indépendant et peut être start, space ou end

alert( re.test(str) ); //false

alert( re.test(str2) );// true

Exemple : Écrivez une fonction qui obtient les nœuds par nom de classe :

Nous avons peut-être déjà vu une telle fonction :

fonction getByClass(parent,classname){

if(parent.getElementsByClassName){

retour parent.getElementsByClassName(classname);

}

else{

var results = new Array();//Utilisé pour stocker tous les éléments récupérés avec la classe box

var elems = parent. getElementsByTagName("*");

for(var i =0;i

if(elems[i].className= =classname){

results.push(elems[i]);

}

retourner les résultats;

}

En fait, il y a un problème, par exemple s'il y a deux classes dans une balise, ou s'il y a des classes du même nom, par exemple. ,

Étiquettes associées：

常见总结表达式

source：php.cn

Article précédent：Que sont les constructeurs et les objets instanciés en javascript ? Article suivant：Introduction détaillée aux tableaux en javaScript

Déclaration de ce site Web

Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn

Derniers articles par auteur