Detaillierte Erläuterung des regulären Positionsabgleichs

Dieses Mal werde ich Ihnen die Verwendung des regulären Positionsabgleichs ausführlich erklären. Was sind die Vorsichtsmaßnahmen bei der Verwendung des regulären Positionsabgleichs? Hier sind praktische Fälle.

regulärer Ausdruck. Geben Sie es wie folgt als Referenz an alle weiter:

Hinweis: In allen Beispielen sind die Ergebnisse der regulären Ausdrucksübereinstimmung im Quelltext [ und ], einige Beispiele werden mit Java implementiert. Wenn es sich um die Verwendung regulärer Ausdrücke in Java selbst handelt, wird dies an der entsprechenden Stelle erläutert. Alle Java-Beispiele werden unter JDK1.6.0_13 getestet.

Wenn wir ein bestimmtes Wort in einem Textstück zuordnen möchten (wobei wir den mehrzeiligen Modus vorerst nicht berücksichtigen). wird später vorgestellt), wir Es könnte so aussehen:

Text:

Regulärer Ausdruck :

Ergebnis:

【ist】 h【ist】tory, morgen 【ist】 ein Rätsel, aber heute 【ist】 ein Geschenk. Analyse: Ursprünglich wollte es nur mit dem Wort „ist“ übereinstimmen, aber es passte auch zu dem, was in anderen Worten enthalten ist . Um dieses Problem zu lösen, verwenden Sie Grenztrennzeichen, d. h. einige

in regulären Ausdrücken, um anzugeben, wo (oder Grenze) der Abgleichvorgang stattfinden soll.

Eine häufig verwendete Grenze ist die durch den Qualifizierer b angegebene Wortgrenze, die verwendet wird, um den Anfang und das Ende eines Wortes abzugleichen. Genauer gesagt entspricht es einer Position zwischen einem Zeichen, das zur Bildung eines Wortes verwendet werden kann (Buchstabe, Zahl, Unterstrich, das ist das Zeichen, das mit w übereinstimmt) und einem Zeichen, das nicht zur Bildung eines Wortes verwendet werden kann (wobei W mit Zeichen übereinstimmt). . Schauen wir uns das vorherige Beispiel an:

Text:

Regulärer Ausdruck:

Ergebnis:

[ist] Geschichte, morgen [ist]ein Rätsel, aber heute [ist]a gift. Analyse: Im Originaltext steht vor und nach dem Wort is ein Leerzeichen, das dem Muster bisb entspricht (Leerzeichen ist eines der Zeichen, die zum Trennen von Wörtern verwendet werden). Das Wort „history“ enthält auch „is“, da davor und danach zwei Zeichen „h“ und „t“ stehen. Keines dieser beiden Zeichen kann mit „b“ übereinstimmen.

Wenn eine Wortgrenze nicht übereinstimmt, wird B verwendet. Zum Beispiel:

Text:

Regulärer Ausdruck:

Ergebnis:

【neunstellige】 ID ein, wie sie auf Ihrem farbcodierten 【Passschlüssel】 erscheint.Analyse: B-B passt zu einem Bindestrich, der keine Wortgrenze vor und nach dem Bindestrich darstellt. Es gibt keine Leerzeichen vor und nach dem Bindestrich, daher können sie abgeglichen werden. Bei der Farbcodierung gibt es Leerzeichen vor und nach dem Bindestrich. Es gibt Leerzeichen, daher kann es nicht übereinstimmen.

StringGrenzeWortgrenze kann verwendet werden, um Positionen im Zusammenhang mit Wörtern abzugleichen (Wortanfang, Wortende, ganzes Wort). usw. warten). Zeichenfolgengrenzen haben einen ähnlichen Zweck, werden jedoch verwendet, um Positionen in Bezug auf Zeichenfolgen abzugleichen (Anfang der Zeichenfolge, Ende der Zeichenfolge, gesamte Zeichenfolge usw.). Es gibt zwei Metazeichen, die zum Definieren von Zeichenfolgengrenzen verwendet werden: eines ist ^, das den Anfang der Zeichenfolge definiert, und das andere ist $, das verwendet wird, um das Ende der Zeichenfolge zu definieren.

Wenn Sie beispielsweise die Rechtmäßigkeit eines XML-Dokuments überprüfen möchten, beginnen alle rechtlichen XML-Dokumente mit :

Text:

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

结果：

分析：^匹配一个字符串的开头位置，所以^\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());
  }
}

输出结果如下：

//Rufen Sie den Superkonstruktor auf und geben Sie an, dass das Dialogfeld modal ist.
//Legen Sie den Titel des Dialogfelds fest.
//Instruieren Sie, dass das Fenster nicht geschlossen wird, wenn auf das „X“ geklickt wird.
//Fügen Sie eine Nachricht mit einem schönen Rahmen in dieses Dialogfeld ein.
//Größe des Dialogfelds auf Komponenten.
//Zentrieren Sie das Dialogfeld über der Anwendung.

5. Zusammenfassung

Reguläre Ausdrücke können nicht nur zum Abgleichen von Textblöcken beliebiger Länge verwendet werden, sondern auch zum Abgleichen von Text, der an bestimmten Positionen in einer Zeichenfolge erscheint. b wird verwendet, um eine Wortgrenze anzugeben (B ist genau das Gegenteil). ^ und $ werden verwendet, um Wortgrenzen anzugeben. Bei Verwendung mit (?m) stimmen ^ und $ auch mit Zeichenfolgen überein, die mit einem Zeilenumbruchzeichen beginnen oder enden. Die Verwendung von Unterausdrücken wird im nächsten Artikel vorgestellt.

Ich glaube, dass Sie die Methode beherrschen, nachdem Sie den Fall in diesem Artikel gelesen haben. Weitere spannende Informationen finden Sie in anderen verwandten Artikeln auf der chinesischen PHP-Website !

Empfohlene Lektüre:

Tutorial zum Positionsabgleich des Tutorials zu regulären Ausdrücken (mit Code)

JS-Passwortstärkekorrektur Überprüfen Sie regelmäßig Ausdruck (mit Code)

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung des regulären Positionsabgleichs. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!