Tutoriel de correspondance de position pour le didacticiel d'expression régulière (avec code)

Cette fois, je vous propose un tutoriel de correspondance de position (avec code) pour le tutoriel expression régulière Quelles sont les précautions pour utiliser le tutoriel d'expression régulière pour la correspondance de position. le combat réel Jetons un coup d’œil au cas.

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 référence, comme suit :

Remarque : Dans tous les exemples, les résultats de correspondance des expressions régulières sont inclus dans le texte source [ et ], quelques exemples seront implémentés en utilisant Java. S'il s'agit de l'utilisation d'expressions régulières dans Java lui-même, cela sera expliqué à l'endroit correspondant. 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 présenté plus tard), nous Cela pourrait ressembler à ceci :

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】tory, demain 【est】 un mystère, mais aujourd'hui 【est】 un cadeau.

Analyse : À l'origine, il voulait seulement correspondre au mot is, mais il correspondait aussi au est contenu en d'autres termes . Pour résoudre ce problème, utilisez des délimiteurs de limites, c'est-à-dire utilisez des métacaractères dans les expressions régulières pour indiquer où (ou limite) nous voulons que l'opération de correspondance se produise.

2. Limites de mots

Une limite couramment utilisée est la limite de 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】 de 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 is, 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é. Par exemple :

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 couleur - codé 【clé d'accès】.

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

3. StringBoundary

La limite du mot peut être utilisée pour faire correspondre les positions liées aux mots (début du mot, fin du mot, mot entier , etc. attendez). 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>

正则表达式：^\s*<\?xml.*?\?>

结果：

分析：^匹配一个字符串的开头位置，所以^\s*将匹配一个字符串的开头位置和随后的零个或多个空白字符，因为标签前面允许有空格、制表符、换行符等空白字符。

$元字符符的用法除了位置上的差异外，与^用法完全一样。比如，检查一个html页面是否以结尾，可以用模式：\s*$

四、多行匹配模式

正则表达式可以通过一些特殊的元字符来改变另外一些元字符的行为。可以通过(?m) 来启用多行匹配模式。多行匹配模式将使得正则表达式引擎把行分隔符当做一个字符串分隔符来对待。在多行匹配模式下，^不仅匹配正常的字符串开头，还将匹配行分隔符（换行符）后面的开始位置，$不仅匹配正常的字符串结尾，还将匹配行分隔符（换行符）后面的结束位置。

在使用时，(?m)必须出现在整个模式的最前面。比如，通过正则表达式把一段java代码中的单行注释（以//开始）内容全部找出来。

文本：

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

正则表达式：(?m)^\s*//.*$

结果：

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

输出结果如下：

//Appelez le super constructeur, en spécifiant que la boîte de dialogue est modale.
//Définissez le titre de la boîte de dialogue.
//Instruisez que la fenêtre ne se ferme pas lorsque l'on clique sur le "X".
//Mettez un message avec une jolie bordure dans cette boîte de dialogue.
//Taille de la boîte de dialogue des composants.
//Centrez la boîte de dialogue sur l'application.

5. Résumé

Les expressions régulières peuvent non seulement être utilisées pour faire correspondre des blocs de texte de n'importe quelle longueur, mais peuvent également être utilisées pour faire correspondre du texte qui apparaît à des positions spécifiques dans une chaîne. b est utilisé pour spécifier une limite de mot (B est juste le contraire). ^ et $ sont utilisés pour spécifier les limites des mots. S'ils sont utilisés avec (?m), ^ et $ correspondront également aux chaînes qui commencent ou se terminent par un caractère de nouvelle ligne. L'utilisation de sous-expressions sera introduite dans le prochain article.

Je pense que vous maîtrisez la méthode après avoir lu le cas dans cet article. Pour des informations plus intéressantes, veuillez prêter attention aux autres articles connexes sur le site Web chinois de php. !

Lecture recommandée :

Comment faire correspondre des nombres consécutifs avec des expressions régulières

Expérience de développement de la mise en œuvre d'une correspondance minimale avec des expressions régulières

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!