regulären Ausdruck
Ein regulärer Ausdruck ist eine Formel, die ein bestimmtes Muster verwendet, um Zeichenfolgen abzugleichen
Reguläre Ausdrücke gibt es nicht nur in Java. Tatsächlich unterstützen viele Programmiersprachen reguläre Ausdrücke für String-Operationen.
Syntax für reguläre Ausdrücke
- begrenzt
- Übereinstimmung auswählen
- Gruppierungskombinationen und Rückverweise
- Spezielle Charaktere
- Charakter-Matcher
- Locator
Metazeichen (Escape-Symbol \\)
Wenn wir reguläre Ausdrücke verwenden, um bestimmte Sonderzeichen abzurufen, müssen wir Escape-Symbole verwenden, andernfalls werden keine Ergebnisse abgerufen und es wird sogar ein Fehler gemeldet.
In regulären Ausdrücken in Java \\steht zwei für eins in anderen Sprachen\
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 演示转义字符的使用
*/
public class RegExp02 {
public static void main(String[] args) {
String content = "abc$(a.bc(123( )";
//匹配( => \\(
//匹配. => \\.
//String regStr = "\\.";
//String regStr = "\\d\\d\\d";
String regStr = "\\d{3}";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到 " + matcher.group(0));
}
}
}
需要用到转义符号的字符有以下:.*+()$/?[] ^{
Metazeichen-Zeichen-Matcher
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 演示字符匹配符 的使用
*/
public class RegExp03 {
public static void main(String[] args) {
String content = "a11c8abc _ABCy @";
//String regStr = "[a-z]";//匹配 a-z之间任意一个字符
//String regStr = "[A-Z]";//匹配 A-Z之间任意一个字符
//String regStr = "abc";//匹配 abc 字符串[默认区分大小写]
//String regStr = "(?i)abc";//匹配 abc 字符串[不区分大小写]
//String regStr = "[0-9]";//匹配 0-9 之间任意一个字符
//String regStr = "[^a-z]";//匹配 不在 a-z之间任意一个字符
//String regStr = "[^0-9]";//匹配 不在 0-9之间任意一个字符
//String regStr = "[abcd]";//匹配 在 abcd中任意一个字符
//String regStr = "\\D";//匹配 不在 0-9的任意一个字符
//String regStr = "\\w";//匹配 大小写英文字母, 数字，下划线
//String regStr = "\\W";//匹配 等价于 [^a-zA-Z0-9_]
//\\s 匹配任何空白字符(空格,制表符等)
//String regStr = "\\s";
//\\S 匹配任何非空白字符 ,和\\s刚好相反
//String regStr = "\\S";
//. 匹配出 \n 之外的所有字符,如果要匹配.本身则需要使用 \\.
String regStr = ".";
//说明
//1. 当创建Pattern对象时，指定 Pattern.CASE_INSENSITIVE, 表示匹配是不区分字母大小写.
Pattern pattern = Pattern.compile(regStr/*, Pattern.CASE_INSENSITIVE*/);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到 " + matcher.group(0));
}
}
}
Metazeichen (Übereinstimmungszeichen auswählen)
Wenn eine bestimmte Zeichenfolge abgeglichen wird, ist sie selektiv, das heißt, sie kann sowohl mit diesem als auch mit dem anderen übereinstimmen. In diesem Fall müssen Sie das Auswahl-Übereinstimmungssymbol verwenden.|
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 选择匹配符
*/
public class RegExp04 {
public static void main(String[] args) {
String content = "hanshunping 韩 寒冷";
String regStr = "han|韩|寒";
Pattern pattern = Pattern.compile(regStr/*, Pattern.CASE_INSENSITIVE*/);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到 " + matcher.group(0));
}
}
}
Metazeichen (Qualifizierer)
Wird verwendet, um anzugeben, wie oft die vorhergehenden Zeichen und Kombinationen nacheinander vorkommen
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 演示限定符的使用
*/
public class RegExp05 {
public static void main(String[] args) {
String content = "a111111aaaaaahello";
//a{3},1{4},\\d{2}
//String regStr = "a{3}";// 表示匹配 aaa
//String regStr = "1{4}";// 表示匹配 1111
//String regStr = "\\d{2}";// 表示匹配 两位的任意数字字符
//a{3,4},1{4,5},\\d{2,5}
//细节：java匹配默认贪婪匹配，即尽可能匹配多的
// String regStr = "a{3,4}"; //表示匹配 aaa 或者 aaaa 但是实际返回： aaaa 贪婪
// String regStr = "1{2,3}"; //表示匹配 11 或者 111 实际输出：111 11
// String regStr = "\\d{2,5}"; //匹配2位数或者3,4,5位数
//1+
//String regStr = "1+"; //匹配一个1或者多个1
//String regStr = "\\d+"; //匹配一个数字或者多个数字
//1*
//String regStr = "1*"; //匹配0个1或者多个1
//演示?的使用, 遵守贪婪匹配
String regStr = "a1?"; //匹配 a 或者 a1
Pattern pattern = Pattern.compile(regStr/*, Pattern.CASE_INSENSITIVE*/);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到 " + matcher.group(0));
}
}
}
Metazeichen (Locators)
Locators geben an, wo die abzugleichende Zeichenfolge erscheint, beispielsweise am Anfang oder am Ende der Zeichenfolge.
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 演示定位符的使用
*/
public class RegExp06 {
public static void main(String[] args) {
String content = "hanshunping sphan nnhan";
//String content = "123-abc";
//以至少1个数字开头，后接任意个小写字母的字符串
//String regStr = "^[0-9]+[a-z]*";
//以至少1个数字开头, 必须以至少一个小写字母结束
//String regStr = "^[0-9]+\\-[a-z]+$";
//表示匹配边界的han[这里的边界是指：被匹配的字符串最后,
// 也可以是空格的子字符串的后面]
//String regStr = "han\\b";
//和\\b的含义刚刚相反
String regStr = "han\\B";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到=" + matcher.group(0));
}
}
}
Gruppe
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 分组:
*/
public class RegExp07 {
public static void main(String[] args) {
String content = "hanshunping s7789 nn1189han";
//下面就是非命名分组
//说明
// 1. matcher.group(0) 得到匹配到的字符串
// 2. matcher.group(1) 得到匹配到的字符串的第1个分组内容
// 3. matcher.group(2) 得到匹配到的字符串的第2个分组内容
//String regStr = "(\\d\\d)(\\d\\d)";//匹配4个数字的字符串
//命名分组： 即可以给分组取名
String regStr = "(?<g1>\\d\\d)(?<g2>\\d\\d)";//匹配4个数字的字符串
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到=" + matcher.group(0)); //7789 1189
System.out.println("第1个分组内容=" + matcher.group(1)); // 77 11
System.out.println("第1个分组内容[通过组名]=" + matcher.group("g1")); // 77 11
System.out.println("第2个分组内容=" + matcher.group(2)); // 89 89
System.out.println("第2个分组内容[通过组名]=" + matcher.group("g2")); // 89 89
}
}
}
Nicht erfassende Gruppierung:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 演示非捕获分组, 语法比较奇怪
*/
public class RegExp08 {
public static void main(String[] args) {
String content = "hello碳膜闰教育 jack碳膜闰老师 碳膜闰同学hello碳膜闰学生";
// 找到 碳膜闰教育 、碳膜闰老师、碳膜闰同学 子字符串
//String regStr = "碳膜闰教育|碳膜闰老师|碳膜闰同学";
//上面的写法可以等价非捕获分组, 注意：不能 matcher.group(1)，因为并不是分组，不能捕获
//String regStr = "碳膜闰(?:教育|老师|同学)";
//找到 碳膜闰 这个关键字,但是要求只是查找碳膜闰教育和 碳膜闰老师 中包含有的碳膜闰
//下面也是非捕获分组，不能使用 matcher.group(1)
//String regStr = "碳膜闰(?=教育|老师)";
//找到 碳膜闰 这个关键字,但是要求只是查找 不是 (碳膜闰教育 和 碳膜闰老师) 中包含有的碳膜闰
//下面也是非捕获分组，不能使用 matcher.group(1)
String regStr = "碳膜闰(?!教育|老师)";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到: " + matcher.group(0));
}
}
}
nicht gieriges Matching
verwenden?
package com.hspedu.regexp;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 非贪婪匹配
*/
public class RegExp09 {
public static void main(String[] args) {
String content = "hello111111 ok";
//String regStr = "\\d+"; //默认是贪婪匹配 111111
// String regStr = "\\d+?"; //非贪婪匹配 1 1 1 1 1 1
String regStr = "\\d+?"; //非贪婪匹配
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到: " + matcher.group(0));
}
}
}
Eckige Klammern [. ? *]zeigen an, dass es sich bei der Übereinstimmung um . ? *sie selbst handelt
Drei gängige Klassen regulärer Ausdrücke
Das Paket java.util.regex enthält hauptsächlich die folgenden drei Klassen: Pattern-Klasse, Matcher-Klasse und PatternSyntaxException
- Das Musterklassenobjekt
patternist ein reguläres Ausdrucksobjekt. Die Musterklasse hat keinen öffentlichen Konstruktor. Um ein Pattern-Objekt zu erstellen, rufen Sie dessen öffentliche statische Methode auf, die ein Pattern-Objekt zurückgibt. Diese Methode akzeptiert einen regulären Ausdruck als ersten Parameter, wie zum Beispiel:Pattern r= Pattern.compile(pattern); MatcherMatcher- ähnliche
Objekte sind Engines, die Eingabezeichenfolgen interpretieren und abgleichen. Wie die Pattern-Klasse verfügt auch Matcher über keinen öffentlichen Konstruktor. Sie müssen die Matcher-Methode des Pattern-Objekts aufrufen, um ein Matcher-Objekt zu erhaltenPatternSyntaxException
PatternSyntaxExceptionIst eine nicht obligatorische Ausnahmeklasse, die einen Syntaxfehler in einem regulären Ausdrucksmuster darstellt.matchesDa es sich um eine Gesamtübereinstimmung handelt, benötigen Sie nicht einmal die Locator-^Summe$. Der Standardwert ist die Gesamtübereinstimmung.
import java.util.regex.Pattern;
/**
* 演示matches方法，用于整体匹配, 在验证输入的字符串是否满足条件使用
*/
public class PatternMethod {
public static void main(String[] args) {
String content = "hello abc hello, 教育";
//String regStr = "hello";
String regStr = "hello.*";
boolean matches = Pattern.matches(regStr, content);
System.out.println("整体匹配= " + matches);
}
}
Matcher-Klasse
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Matcher 类的常用方法
*/
public class MatcherMethod {
public static void main(String[] args) {
String content = "hello edu jack hspedutom hello smith hello hspedu hspedu";
String regStr = "hello";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("=================");
System.out.println(matcher.start());
System.out.println(matcher.end());
System.out.println("找到: " + content.substring(matcher.start(), matcher.end()));
}
//整体匹配方法，常用于，去校验某个字符串是否满足某个规则
System.out.println("整体匹配=" + matcher.matches());
//完成如果content 有 hspedu 替换成 碳膜闰教育
regStr = "hspedu";
pattern = Pattern.compile(regStr);
matcher = pattern.matcher(content);
//注意：返回的字符串才是替换后的字符串 原来的 content 不变化
String newContent = matcher.replaceAll("碳膜闰教育");
System.out.println("newContent=" + newContent);
System.out.println("content=" + content);
}
}
Gruppieren, Erfassen, Rückreferenzieren
(\\dd) (\\dd)
- Gruppierung
Wir können Klammern verwenden, um ein komplexeres Übereinstimmungsmuster zu bilden. Dann kann der Teil einer Klammer als Unterausdruck/Gruppierung betrachtet werden. - Erfasst
den Inhalt des Unterausdrucks/der übereinstimmenden Gruppe im regulären Ausdruck und speichert ihn in einer numerisch nummerierten oder explizit benannten Gruppe im Speicher, damit er später von links nach rechts leicht darauf verwiesen werden kann, markiert durch die linke Klammer der Gruppe, die erste Die angezeigte Gruppennummer ist 1, die zweite ist 2 und so weiter. Gruppe O repräsentiert den gesamten regulären Ausdruck. - Rückverweis
Nachdem der Inhalt der Klammern erfasst wurde. Es kann nach dieser Klammer verwendet werden, um ein praktischeres Übereinstimmungsmuster zu schreiben. Dies wird als Rückreferenz bezeichnet. Diese Art von
Referenz kann entweder innerhalb des regulären Ausdrucks oder außerhalb des regulären Ausdrucks sein. Interne Rückreferenz\\分组号, externe Rückreferenz$分组号.
Fall
- Um zwei aufeinanderfolgende identische Zahlen abzugleichen:
(\\d)\\1 - Um fünf aufeinanderfolgende identische Zahlen zuzuordnen:
(\\d)\\1{4} - Zum Zuordnen von Zahlen mit der gleichen Einer- und Tausenderstelle und der gleichen Zehnerstelle wie die erste Ziffer 5225,1551
(\\d)(\\d)\\2\\1
Bitte suchen Sie in der Zeichenfolge nach der Produktnummer in der Form: 12321-333999111. Einer solchen Nummer muss eine fünfstellige Zahl, dann eine - Zahl und dann eine neunstellige Zahl vorangestellt werden. Alle aufeinanderfolgenden drei Ziffern müssen die sein Dasselbe.
package com.hspedu.regexp;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 反向引用
*/
public class RegExp12 {
public static void main(String[] args) {
String content = "h1234el9876lo33333 j12324-333999111a1551ck14 tom11 jack22 yyy12345 xxx";
//要匹配两个连续的相同数字 : (\\d)\\1
//String regStr = "(\\d)\\1";
//要匹配五个连续的相同数字： (\\d)\\1{4}
//String regStr = "(\\d)\\1{4}";
//要匹配个位与千位相同，十位与百位相同的数 5225 , 1551 (\\d)(\\d)\\2\\1
//String regStr = "(\\d)(\\d)\\2\\1";
/**
* 请在字符串中检索商品编号,形式如:12321-333999111 这样的号码,
* 要求满足前面是一个五位数,然后一个-号,然后是一个九位数,连续的每三位要相同
*/
String regStr = "\\d{5}-(\\d)\\1{2}(\\d)\\2{2}(\\d)\\3{2}";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到 " + matcher.group(0));
}
}
}
klassischer Stottervorgang
Ändern Sie etwas wie: „Ich ... ich möchte ... lernen, Java zu programmieren!“; ändern Sie es durch reguläre Ausdrücke in „Ich möchte lernen, Java zu programmieren“.
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegExp13 {
public static void main(String[] args) {
String content = "我....我要....学学学学....编程java!";
//1. 去掉所有的.
Pattern pattern = Pattern.compile("\\.");
Matcher matcher = pattern.matcher(content);
content = matcher.replaceAll("");
// System.out.println("content=" + content);
//2. 去掉重复的字 我我要学学学学编程java!
// 思路
//(1) 使用 (.)\\1+ 匹配重复的字
//(2) 使用 反向引用$1 来替换匹配到的内容
// 注意：因为正则表达式变化，所以需要重置 matcher
// pattern = Pattern.compile("(.)\\1+");//分组的捕获内容记录到$1
// matcher = pattern.matcher(content);
// while (matcher.find()) {
// System.out.println("找到=" + matcher.group(0));
// }
// //使用 反向引用$1 来替换匹配到的内容
// content = matcher.replaceAll("$1");
// System.out.println("content=" + content);
//3. 也可以使用一条语句 去掉重复的字 我我要学学学学编程java!
content = Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");
System.out.println("content=" + content);
}
}
Verwendung regulärer Ausdrücke in der String-Klasse
Ersatzfunktion
String 类 public String replaceAll(String regex, String replacement)
Urteilsfunktion
String 类 public boolean matches(String regex){
}
//使用Pattern 和 Matcher 类
Split-Funktion
String 类 public String[] split(String regex)
public class StringReg {
public static void main(String[] args) {
String content = "2000年5月，JDK1.3、JDK1.4和J2SE1.3相继发布，几周后其" +
"获得了Apple公司Mac OS X的工业标准的支持。2001年9月24日，J2EE1.3发" +
"布。" +
"2002年2月26日，J2SE1.4发布。自此Java的计算能力有了大幅提升";
//使用正则表达式方式，将 JDK1.3 和 JDK1.4 替换成JDK
content = content.replaceAll("JDK1\\.3|JDK1\\.4", "JDK");
System.out.println(content);
//要求 验证一个 手机号， 要求必须是以 138 139 开头的
content = "13888889999";
if (content.matches("1(38|39)\\d{8}")) {
System.out.println("验证成功");
} else {
System.out.println("验证失败");
}
//要求按照 # 或者 - 或者 ~ 或者 数字 来分割
System.out.println("===================");
content = "hello#abc-jack12smith~北京";
String[] split = content.split("#|-|~|\\d+");
for (String s : split) {
System.out.println(s);
}
}
}
Anhang: Ausführliche Erläuterung der Metazeichen regulärer Ausdrücke
| Charakter | veranschaulichen |
|---|---|
\ |
Markieren Sie das nächste Zeichen als Sonderzeichen, Text, Rückverweis oder oktales Escape-Zeichen. Beispielsweise entspricht „n“ dem Zeichen „n“. „\n“ entspricht einem Zeilenumbruchzeichen. Die Sequenz „\\“ entspricht „\“, „\(“ entspricht „(“. |
^ |
Entspricht dem Anfang der Eingabezeichenfolge. Wenn die Multiline-Eigenschaft des RegExp-Objekts festgelegt ist, stimmt ^ auch mit der Position nach „\n“ oder „\r“ überein. |
$ |
Entspricht dem Ende der Eingabezeichenfolge. Wenn die Multiline-Eigenschaft des RegExp-Objekts festgelegt ist, entspricht $ auch der Position vor „\n“ oder „\r“. |
* |
Entspricht dem vorhergehenden Zeichen oder Unterausdruck nullmal oder mehrmals. Beispielsweise stimmt zo* mit „z“ und „zoo“ überein. * Entspricht {0,}. |
+ |
Entspricht dem vorhergehenden Zeichen oder Unterausdruck einmal oder mehrmals. Beispielsweise stimmt „zo+“ mit „zo“ und „zoo“ überein, aber nicht mit „z“. + Entspricht {1,}. |
? |
Entspricht dem vorhergehenden Zeichen oder Unterausdruck null oder einmal. Beispielsweise entspricht „do(es)?“ „do“ oder „do“ in „does“. ? Entspricht {0,1}. |
{n} |
n ist eine nicht negative ganze Zahl. Passt genau n- mal zusammen. Beispielsweise stimmt „o{2}“ nicht mit dem „o“ in „Bob“ überein, stimmt aber mit beiden „o“s in „food“ überein. |
{n,} |
n ist eine nicht negative ganze Zahl. Passt mindestens n -mal zusammen. Beispielsweise stimmt „o{2,}“ nicht mit dem „o“ in „Bob“ überein, sondern mit allen o in „foooood“. „o{1,}“ ist äquivalent zu „o+“. „o{0,}“ ist äquivalent zu „o*“. |
{n,m} |
m und n sind nichtnegative ganze Zahlen, wobei n <= m ist . Übereinstimmung mindestens n -mal und höchstens m -mal. Beispielsweise entspricht „o{1,3}“ den ersten drei o in „fooooood“. „o{0,1}“ ist äquivalent zu „o?“. Hinweis: Zwischen Kommas und Zahlen können keine Leerzeichen eingefügt werden. |
? |
Wenn dieses Zeichen unmittelbar auf ein anderes Qualifikationsmerkmal (*, +, ?, { n }, { n ,}, { n , m }) folgt, ist das Übereinstimmungsmuster „nicht gierig“. Das „non-greedy“-Muster entspricht der kürzestmöglichen gesuchten Zeichenfolge, während das standardmäßige „greedy“-Muster der längstmöglichen gesuchten Zeichenfolge entspricht. Beispielsweise stimmt „o+?“ in der Zeichenfolge „oooo“ nur mit einem einzelnen „o“ überein, während „o+“ mit allen „o“ übereinstimmt. |
. |
Entspricht jedem einzelnen Zeichen außer „\r\n“. Um ein beliebiges Zeichen einschließlich „\r\n“ zu finden, verwenden Sie ein Muster wie „[\s\S]“. |
(pattern) |
Entspricht einem Muster und erfasst den passenden Unterausdruck. Erfasste Übereinstimmungen können mithilfe der Attribute $0…$9 aus der resultierenden Sammlung „Übereinstimmungen“ abgerufen werden. Um das Klammerzeichen ( ) anzupassen, verwenden Sie „(“ oder „)“. |
(?:pattern) |
Ein Unterausdruck, der mit dem Muster übereinstimmt, die Übereinstimmung jedoch nicht erfasst, d. h. es handelt sich um eine nicht erfassende Übereinstimmung, und die Übereinstimmung wird nicht zur späteren Verwendung gespeichert. Dies ist nützlich, wenn Sie Musterteile mit dem „oder“-Zeichen (|) kombinieren. Beispielsweise ist „industr(?:y|ies)“ ein wirtschaftlicherer Ausdruck als „industry|industries“. |
(?=pattern) |
Ein Unterausdruck, der eine Vorwärts-Lookahead-Suche durchführt, die mit einer Zeichenfolge am Anfang einer Zeichenfolge übereinstimmt, die mit dem Muster übereinstimmt. Es handelt sich um einen nicht erfassenden Treffer, d. h. einen Treffer, der nicht zur späteren Verwendung erfasst werden kann. Beispielsweise entspricht „Windows (?=95|98|NT|2000)“ „Windows“ in „Windows 2000“, aber nicht „Windows“ in „Windows 3.1“. Vorhersage-Lookaheads belegen keine Zeichen, d. h. nach einer Übereinstimmung wird die nächste Übereinstimmung unmittelbar nach der vorherigen Übereinstimmung gesucht, nicht nach den Zeichen, aus denen der Vorhersage-Lookahead besteht. |
(?!pattern) |
Ein Unterausdruck, der eine Rückwärts-Lookahead-Suche durchführt, die mit einer Suchzeichenfolge übereinstimmt, die nicht am Anfang einer Zeichenfolge steht, die mit dem Muster übereinstimmt. Es handelt sich um einen nicht erfassenden Treffer, d. h. einen Treffer, der nicht zur späteren Verwendung erfasst werden kann. Beispielsweise entspricht „Windows (?!95|98|NT|2000)“ „Windows“ in „Windows 3.1“, aber nicht „Windows“ in „Windows 2000“. Vorhersage-Lookaheads belegen keine Zeichen, d. h. nach einer Übereinstimmung wird die nächste Übereinstimmung unmittelbar nach der vorherigen Übereinstimmung gesucht, nicht nach den Zeichen, aus denen der Vorhersage-Lookahead besteht. |
| *`x | y`* |
[xyz] |
Zeichensatz. Entspricht jedem in enthaltenen Zeichen. Beispielsweise entspricht „[abc]“ dem „a“ in „plain“. |
[^xyz] |
Umgekehrter Zeichensatz. Entspricht allen nicht enthaltenen Zeichen. Beispielsweise stimmt „ [^abc]“ mit „p“, „l“, „i“ und „n“ in „plain“ überein. |
[a-z] |
Zeichenbereich. Entspricht jedem Zeichen innerhalb des angegebenen Bereichs. „[az]“ entspricht beispielsweise jedem Kleinbuchstaben im Bereich „a“ bis „z“. |
[^a-z] |
Zeichen für umgekehrten Bereich. Entspricht jedem Zeichen, das nicht im angegebenen Bereich liegt. „ “ entspricht beispielsweise [^a-z]jedem Zeichen, das nicht im Bereich „a“ bis „z“ liegt. |
| \B | Entspricht einer Wortgrenze, also der Position zwischen einem Wort und einem Leerzeichen. Beispielsweise entspricht „er\b“ dem „er“ in „never“, aber nicht dem „er“ in „verb“. |
| \B | Nicht-Wortgrenzen-Matching. „er\B“ entspricht dem „er“ in „verb“, aber nicht dem „er“ in „never“. |
| \c x | Entspricht dem durch x angegebenen Steuerzeichen . \cM entspricht beispielsweise Control-M oder einem Wagenrücklaufzeichen. Der Wert von x muss zwischen AZ und az liegen. Ist dies nicht der Fall, wird angenommen, dass c das „c“-Zeichen selbst ist. |
| \D | Numerischer Zeichenabgleich. Entspricht [0-9]. |
| \D | Entspricht nicht numerischen Zeichen. Entspricht [^0-9]. |
| \F | Formularfeed-Übereinstimmungen. Entspricht \x0c und \cL. |
| \N | Newline-Matching. Entspricht \x0a und \cJ. |
| \R | Entspricht einem Wagenrücklaufzeichen. Entspricht \x0d und \cM. |
| \S | Entspricht jedem Leerzeichen, einschließlich Leerzeichen, Tabulatoren, Formularfeeds usw. Entspricht [ \f\n\r\t\v]. |
| \S | Entspricht jedem Zeichen, das kein Leerzeichen ist. Entspricht [^ \f\n\r\t\v]. |
| \T | 制表符匹配。与 \x09 和 \cI 等效。 |
| \v | 垂直制表符匹配。与 \x0b 和 \cK 等效。 |
| \w | 匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。 |
| \W | 与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。 |
| \xn | 匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，“\x41"匹配"A”。“\x041"与”\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。 |
| \num | 匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，"(.)\1"匹配两个连续的相同字符。 |
| \n | 标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数 (0-7)，那么 n 是八进制转义码。 |
| \nm | 标识一个八进制转义码或反向引用。如果 nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。如果两种前面的情况都不存在，则 nm 匹配八进制值 nm，其中 n 和 m 是八进制数字 (0-7)。 |
| \nml | 当 n 是八进制数 (0-3)，m 和 l 是八进制数 (0-7) 时，匹配八进制转义码 nml。 |
| \un | 匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (©)。 |
附：正则表达式参考大全
一、校验数字的表达式
1 数字：^[0-9]*$
2 n位的数字：^\d{n}$
3 至少n位的数字：^\d{n,}$
4 m-n位的数字：^\d{m,n}$
5 零和非零开头的数字：^(0|[1-9][0-9]*)$
6 非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(.[0-9]{1,2})?$
7 带1-2位小数的正数或负数：^(\-)?\d+(\.\d{1,2})?$
8 正数、负数、和小数：^(\-|\+)?\d+(\.\d+)?$
9 有两位小数的正实数：^[0-9]+(.[0-9]{2})?$
10 有1~3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$
11 非零的正整数：^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\+?[1-9][0-9]*$
12 非零的负整数：^\-[1-9][]0-9"*$ 或 ^-[1-9]\d*$
13 非负整数：^\d+$ 或 ^[1-9]\d*|0$
14 非正整数：^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$
15 非负浮点数：^\d+(\.\d+)?$ 或 ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
16 非正浮点数：^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 或 ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
17 正浮点数：^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
18 负浮点数：^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
19 浮点数：^(-?\d+)(\.\d+)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
二、校验字符的表达式
1 汉字：^[\u4e00-\u9fa5]{0,}$
2 英文和数字：^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$
3 长度为3-20的所有字符：^.{3,20}$
4 由26个英文字母组成的字符串：^[A-Za-z]+$
5 由26个大写英文字母组成的字符串：^[A-Z]+$
6 由26个小写英文字母组成的字符串：^[a-z]+$
7 由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$
8 由数字、26个英文字母或者下划线组成的字符串：^\w+$ 或 ^\w{3,20}$
9 中文、英文、数字包括下划线：^[\u4E00-\u9FA5A-Za-z0-9_]+$
10 中文、英文、数字但不包括下划线等符号：^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
11 可以输入含有^%&',;=?$\"等字符：[^%&',;=?$\x22]+
12 禁止输入含有~的字符：[^~\x22]+
三、特殊需求表达式
1 Email地址：^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
2 域名：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
3 InternetURL：[a-zA-z]+://[^\s]* 或 ^https://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
4 手机号码：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
5 电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)：^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
6 国内电话号码(0511-4405222、021-87888822)：\d{3}-\d{8}|\d{4}-\d{7}
7 身份证号：
15或18位身份证：^\d{15}|\d{18}$
15位身份证：^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$
18位身份证：^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$
8 短身份证号码(数字、字母x结尾)：^([0-9]){7,18}(x|X)?$ 或 ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$
9 帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
10 密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：^[a-zA-Z]\w{5,17}$
11 强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间)：^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
12 日期格式：^\d{4}-\d{1,2}-\d{1,2}
13 一年的12个月(01～09和1～12)：^(0?[1-9]|1[0-2])$
14 一个月的31天(01～09和1～31)：^((0?[1-9])|((1|2)[0-9])|30|31)$
15 钱的输入格式：
16 1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：^[1-9][0-9]*$
17 2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：^(0|[1-9][0-9]*)$
18 3.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：^(0|-?[1-9][0-9]*)$
19 4.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：^[0-9]+(.[0-9]+)?$
20 5.必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：^[0-9]+(.[0-9]{2})?$
21 6.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：^[0-9]+(.[0-9]{1,2})?$
22 7.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
23 8.1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
24 备注：这就是最终结果了,别忘了"+"可以用"*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里
25 xml文件：^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
26 中文字符的正则表达式：[\u4e00-\u9fa5]
27 双字节字符：[^\x00-\xff] (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))
28 空白行的正则表达式：\n\s*\r (可以用来删除空白行)
29 HTML标记的正则表达式：<(\S*?)[^>]*>.*?|<.*? /> (网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力)
30 首尾空白字符的正则表达式：^\s*|\s*$或(^\s*)|(\s*$) (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)
31 腾讯QQ号：[1-9][0-9]{4,} (腾讯QQ号从10000开始)
32 中国邮政编码：[1-9]\d{5}(?!\d) (中国邮政编码为6位数字)
33 IP地址：\d+\.\d+\.\d+\.\d+ (提取IP地址时有用)