Explication détaillée de la correspondance de position dans le didacticiel sur les expressions régulières

L'exemple de cet article décrit la correspondance de position du didacticiel d'expression régulière. Partagez-le avec tout le monde pour votre référence, comme suit :

Remarque : dans tous les exemples, les résultats de correspondance des expressions régulières sont inclus entre [et] dans le texte source. Certains exemples seront implémentés en utilisant Java. Les expressions régulières en Java lui-même seront expliquées aux endroits correspondants. Tous les exemples Java sont testés sous JDK1.6.0_13.

1. Introduction au problème

Si vous souhaitez faire correspondre un certain mot dans un morceau de texte (sans tenir compte du mode multiligne pour l'instant, qui sera introduit plus tard), nous peut ressembler à ce qui suit :

Texte : Hier c'est de l'histoire, demain est un mystère, mais aujourd'hui est un cadeau.

Expression régulière : est

Résultat : Hier [est ] h [est] une histoire, demain 【est】un mystère, mais aujourd'hui 【est】un cadeau.

Analyse : à l'origine, il voulait seulement correspondre au mot est, mais il correspondait également au est contenu dans d'autres mots. Pour résoudre ce problème, utilisez des délimiteurs de limites, qui sont des métacaractères utilisés dans les expressions régulières pour indiquer où (ou limites) nous voulons que l'opération de correspondance se produise.

2. Limites des mots

Une limite couramment utilisée est la limite du mot spécifiée par le qualificatif b, qui est utilisé pour faire correspondre le début et la fin d'un mot. Plus précisément, il fait correspondre une position entre un caractère pouvant être utilisé pour former un mot (lettre, chiffre, trait de soulignement, qui est le caractère qui correspond à w) et un caractère qui ne peut pas être utilisé pour former un mot (avec W correspond à des caractères). . Regardons l'exemple précédent :

Texte : Hier c'est de l'histoire, demain est un mystère, mais aujourd'hui est un cadeau.

Expression régulière : bisb

Résultat : Hier [ est】 l'histoire, demain 【est】 un mystère, mais aujourd'hui 【est】 un cadeau.

Analyse : Dans le texte original, il y a un espace avant et après le mot est, et cela correspond au modèle bisb ( l'espace est l'un des caractères utilisés pour séparer les mots). Le mot history contient également is, car il y a deux caractères h et t avant et après aucun de ces deux caractères ne peut correspondre à b.

Si une limite de mot ne correspond pas, B est utilisé. Tels que :

Texte : Veuillez saisir l'identifiant à neuf chiffres tel qu'il apparaît sur votre clé d'accès codée en couleur.

Expression régulière : B-B

Résultat : Veuillez saisir l'identifiant [à neuf chiffres] tel qu'il apparaît sur votre [clé d'accès] codée en couleur

Analyse : B-B correspondra à un trait d'union qui n'est pas une limite de mot avant et après, à neuf chiffres et passe. -key Il n'y a pas d'espaces avant et après le trait d'union, donc cela peut correspondre. Cependant, en code couleur, il y a des espaces avant et après le trait d'union, donc cela ne peut pas correspondre.

3. Limites de chaînes

Les limites de mots peuvent être utilisées pour faire correspondre les positions liées aux mots (début de mot, fin de mot, mot entier, etc.). Les limites de chaîne ont un objectif similaire, mais sont utilisées pour faire correspondre les positions liées aux chaînes (début de chaîne, fin de chaîne, chaîne entière, etc.). Deux métacaractères sont utilisés pour définir les limites d'une chaîne : l'un est ^ utilisé pour définir le début de la chaîne et l'autre est $ utilisé pour définir la fin de la chaîne.

Par exemple, si vous souhaitez vérifier la légalité d'un document XML, les documents XML légaux commencent tous par  :

Texte :

<?xml version="1.0" encoding="UTF-8"?>
<project basedir="." default="ear">
</project>

Expression régulière : ^s*

Résultat :

Analyse : ^ Correspond au début d'une chaîne, donc ^s* correspondra au début d'une chaîne et à zéro ou plusieurs caractères d'espacement suivants, car les espaces, tabulations, nouvelles lignes, etc. sont autorisés devant la balise personnages.

L'utilisation du métacaractère $ est exactement la même que celle de ^ à l'exception de la différence de position. Par exemple, pour vérifier si une page html se termine par , vous pouvez utiliser le modèle : s*$

4 . Correspondance multiligne L'expression régulière du modèle

peut utiliser certains métacaractères spéciaux pour modifier le comportement d'autres métacaractères. Le mode de correspondance multiligne peut être activé via (?m). Le modèle de correspondance multiligne amènera le moteur d'expression régulière à traiter le délimiteur de ligne comme un délimiteur de chaîne. En mode de correspondance multiligne, ^ correspond non seulement au début normal de la chaîne, mais correspond également à la position de départ après le séparateur de ligne (le caractère de nouvelle ligne $ correspond non seulement à la fin normale de la chaîne, mais correspond également au séparateur de ligne). (caractère de nouvelle ligne). La position de fin derrière.

Lorsqu'il est utilisé, (?m) doit apparaître devant tout le motif. Par exemple, utilisez des expressions régulières pour rechercher tous les commentaires sur une seule ligne (commençant par //) dans un morceau de code Java.

Texte :

publicDownloadingDialog(Frame parent){
     //Callsuper constructor, specifying that dialog box is modal.
     super(parent,true);
     //Setdialog box title.
     setTitle("E-mailClient");
     //Instructwindow not to close when the "X" is clicked.
     setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
     //Puta message with a nice border in this dialog box.
     JPanelcontentPanel = new JPanel();
     contentPanel.setBorder(BorderFactory.createEmptyBorder(5,5, 5, 5));
     contentPanel.add(newJLabel("Downloading messages..."));
     setContentPane(contentPanel);
     //Sizedialog box to components.
     pack();
     //Centerdialog box over application.
     setLocationRelativeTo(parent);
}

Expression régulière : (?m)^s*//.*$

Résultat :

publicDownloadingDialog(Frame parent){
【 //Call superconstructor, specifying that dialog box is modal.】
super(parent,true);
【 //Set dialog boxtitle.】
setTitle("E-mailClient");
【 //Instruct windownot to close when the "X" is clicked.】
setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
【 //Put a messagewith a nice border in this dialog box.】
JPanelcontentPanel = new JPanel();
contentPanel.setBorder(BorderFactory.createEmptyBorder(5,5, 5, 5));
contentPanel.add(newJLabel("Downloading messages..."));
setContentPane(contentPanel);
【 //Size dialog boxto components.】
pack();
【 //Center dialogbox over application.】
setLocationRelativeTo(parent);
}

分析：^\s*//.*$将匹配一个字符串的开始，然后是任意多个空白字符，再后面是//，再往后是任意文本，最后是一个字符串的结束。不过这个模式只能找出第一条注释，加上(?m)前缀后，将把换行符视为一个字符串分隔符，这样就可以把每一行注释匹配出来了。

java代码实现如下（文本保存在text.txt文件中）：

public static String getTextFromFile(String path) throws Exception{
  BufferedReader br = new BufferedReader(new FileReader(new File(path)));
  StringBuilder sb = new StringBuilder();
  char[] cbuf = new char[1024];
  int len = 0;
  while(br.ready() && (len = br.read(cbuf)) > 0){
    br.read(cbuf);
    sb.append(cbuf, 0, len);
  }
    br.close();
  return sb.toString();
}
public static void multilineMatch() throws Exception{
  String text = getTextFromFile("E:/text.txt");
  String regex = "(?m)^\\s*//.*$";
  Matcher m = Pattern.compile(regex).matcher(text);
  while(m.find()){
    System.out.println(m.group());
  }
}

   

输出结果如下：

//Call super constructor, specifying that dialog box is modal.
//Set dialog box title.
//Instruct window not to close when the "X" is clicked.
//Put a message with a nice border in this dialog box.
//Size dialog box to components.
//Center dialog box over application.

五、小结

正则表达式不仅可以用来匹配任意长度的文本块，还可以用来匹配出现在字符串中特定位置的文本。\b用来指定一个单词边界（\B刚好相反）。^和$用来指定单词边界。如果与(?m)配合使用，^和$还将匹配在一个换行符处开头或结尾的字符串。在接下来的文章中将介绍子表达式的使用。

希望本文所述对大家正则表达式学习有所帮助。

更多正则表达式教程之位置匹配详解相关文章请关注PHP中文网！