整合营销服务商
电脑端+手机端+微信端=数据同步管理
免费咨询热线：
电脑端+手机端+微信端=数据同步管理
免费咨询热线：
Java中，可以使用正则表达式来提取HTML中的任意内容。以下是一个示例代码，演示如何使用正则表达式从HTML中提取文本：
import java.util.regex.Matcher; import java.util.regex.Pattern; public class HtmlParser { public static void main(String[] args) { String html = "<html><head><title>My Website</title></head><body><p>This is some sample text.</p></body></html>"; Pattern pattern = Pattern.compile("<p[^>]*>(.*?)</p>"); Matcher matcher = pattern.matcher(html); String pText = matcher.group(1); System.out.println(pText); } }在上面的代码中，我们首先定义了一个HTML字符串，然后使用Pattern和Matcher类来匹配HTML中的文本。Pattern类用于定义正则表达式，Matcher类用于在HTML中查找匹配的文本。
在正则表达式中，我们使用了<p[^>]*>来匹配以<p>开头，后面跟着任意数量的字符，再以</p>结尾的文本。其中，[^>]*表示匹配任意数量的字符，</p>表示匹配</p>后面的任意字符。
最后，我们使用group(1)方法来获取匹配的文本，并将其打印到控制台上。
需要注意的是，正则表达式可以根据HTML标签的不同来进行不同的
正则表达式（Regular Expression），又称正规表示法，常简称为正则表达式、正则式或规则（Reading），其实是一种字符串匹配的工具，它可以用来描述字符序列的模式。
在 Java 中，正则表达式主要用于以下两个方面：
正则表达式由两种基本字符类型组成：
原子指单个的、不可再分的匹配单元，原子表达式就是由原子组成的正则表达式。常见的原子有：
元字符是正则表达式中最为重要和常用的部分，用于匹配单个字符或一组字符。其中常见的元字符如下：
（1）基本元字符
对应单个字符。
（2）量词元字符
用于描述字符的数量。
注意：使用*和+ 时，表达式会尽可能地去匹配所有符合条件的字符串。因此，可能会导致效率低下和执行时间过长的问题。如果确定匹配的字符串不会太长，可以使用贪婪模式（Greedy）来提高正则表达式的性能。例如，a._b 会匹配从a开始到b结束之间的所有内容，包括中间的换行符等；而a._?b 只会匹配第一个a 和第一个b之间的部分。
（3）分组元字符
用于将表达式中若干个子项组成一个整体。常用的分组元字符有：
（4）限定符
用于限制某个元字符在正则表达式中出现的次数。常见的限定符有：
字符 | 匹配 | 示例 |
. | 任意单个字符，除换行符外 | jav.匹配java |
[ ] | [ ] 中的任意一个字符 | java匹配j[abc]va |
- | [ ] 内表示字符范围 | java匹配[a-z]av[a-g] |
^ | 在[ ]内的开头，匹配除[ ]内的字符之外的任意一个字符 | java匹配jb-fva |
| | 或 | x|y匹配x或y |
|将下一字符标记为特殊字符、文本、反向引用或八进制转义符 | (匹配( | |
$ | 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与"\n"或"\r"之前的位置匹配。 | ;$匹配位于一行及外围的;号 |
* | 零次或多次匹配前面的字符 | zo*匹配zoo或z |
+ | 一次或多次匹配前面的字符 | zo+匹配zo或zoo |
? | 零次或一次匹配前面的字符 | zo?匹配z或zo |
p{n} | n 是非负整数。正好匹配 n 次 | o{2}匹配food中的两个o |
p{n,} | n 是非负整数。至少匹配 n 次 | o{2}匹配foood中的所有o |
p{n,m} | M 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次 | o{1,3}匹配fooood中的三个o |
\p{P} | 一个标点字符 !"#$%&'()*+,-./:;<=>?@[]^_'{|}~ | J\p{P}a匹配J?a |
\b | 匹配一个字边界 | va\b匹配java中的va，但不匹配javar中的va |
\B | 非字边界匹配 | va\B匹配javar中的va，但不匹配java中的va |
\d | 数字字符匹配 | 1[\d]匹配13 |
\D | 非数字字符匹配 | [\D]java匹配Jjava |
\w | 单词字符 | java匹配[\w]ava |
\W | 非单词字符 | $java匹配[\W]java |
\s | 空白字符 | Java 2匹配Java\s2 |
\S | 非空白字符 | java匹配 j[\S]va |
\f | 匹配换页符 | 等效于\x0c和\cL |
\n | 匹配换行符 | 等效于\x0a和\cJ |
Matcher 类是一个抽象类，可以通过调用 Pattern 类的 matcher() 方法来获取 Matcher 对象。
常用方法如下：
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class MatcherDemo {
public static void main(String[] args) {
String str = "This is a test string";
// 创建 Pattern 对象
Pattern pattern = Pattern.compile("\\w+");
// 创建 Matcher 对象
Matcher matcher = pattern.matcher(str);
int count = 0;
while (matcher.find()) {
System.out.println("Match " + (++count) + ": " + matcher.group());
System.out.println("Starting index: " + matcher.start());
System.out.println("Ending index: " + matcher.end());
}
}
}上面的代码使用 Pattern 类和 Matcher 类来对字符串进行匹配，输出结果如下：
Match 1: This
Starting index: 0
Ending index: 4
Match 2: is
Starting index: 5
Ending index: 7
Match 3: a
Starting index: 8
Ending index: 8
Match 4: test
Starting index: 10
Ending index: 13
Match 5: string
Starting index: 15
Ending index: 20Pattern 类提供了一些常见的正则表达式。
常用方法如下：
代码示例：
import java.util.Arrays;
import java.util.regex.Pattern;
public class PatternDemo {
public static void main(String[] args) {
String str = "1,2;3,4,5";
// 使用逗号或分号分割字符串
Pattern pattern = Pattern.compile("[,;]");
String[] parts = pattern.split(str);
System.out.println(Arrays.toString(parts));
// 将数字替换为 X
String result = pattern.matcher(str).replaceAll("X");
System.out.println(result);
}
}上面的代码使用 Pattern 类的 split() 和 replaceAll() 方法来对字符串进行操作，输出结果如下：
[1, 2, 3, 4, 5]
X X X X X（1）public static Pattern compile(String regex)
说明：Pattern类的一个静态方法，用于将给定的正则表达式字符串编译为一个Pattern对象。这个方法通常用于将一个常见的正则表达式字符串编译成一个Pattern对象，以便后续的重复使用
Pattern pattern = Pattern.compile("a*b");（2）public static Pattern compile(String regex, int flags)
说明：Pattern.compile(String regex, int flags)是Pattern类的一个静态方法，用于根据给定的正则表达式字符串和标志位来编译成一个Pattern对象。这个方法允许你在编译正则表达式时指定一些标志，以控制匹配的行为。
参数regex是要编译的正则表达式字符串，flags是一个整数，表示匹配的标志位。常用的标志位包括：
使用这个重载的compile方法，可以更灵活地控制正则表达式的匹配行为。
//正则表达式"a*b"编译成一个Pattern对象，并指定了忽略大小写和多行模式的标志位。这样就可以在后续的匹配操作中，按照指定的标志位规则进行匹配
Pattern pattern = Pattern.compile("a*b", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);（3）public static boolean matches(String regex, CharSequence input)
说明：Pattern.matches(String regex, CharSequence input) 是Pattern类的一个静态方法，用于判断给定的输入字符串是否完全匹配指定的正则表达式。
参数regex是要用来进行匹配的正则表达式字符串，参数 input 是要进行匹配的输入字符序列。
这个方法会尝试将整个输入序列与正则表达式进行匹配，如果整个输入字符串与正则表达式完全匹配，则返回 true；否则返回false。
boolean isMatch = Pattern.matches("a*b", "aaaab");
//运行结果： isMatch = true
//上面的代码将会用正则表达式 "ab" 对字符串 "aaaab" 进行匹配，因为 "aaaab" 符合 "a" 的模式，所以 isMatch 会被赋值为 true（4）public static String quote(String s)
说明：Pattern.quote(String s) 是 Pattern 类的一个静态方法，用于返回指定字符串的字面量模式字符串。这个方法可以将输入的字符串转换为字面量模式，以便在正则表达式中进行精确匹配。于正则表达式中可能包含特殊字符，如果需要在正则表达式中精确匹配一个字符串，就需要对字符串进行转义处理，这时可以使用quote方法来实现。
//我们希望匹配字符串 "(.)"，但是这个字符串包含了正则表达式中的特殊字符 "()" 和 "."，为了确保在正则表达式中能够精确匹配这个字符串，我们可以使用 quote 方法来转义这个字符串，得到的 regex 就是 \(\.\*\)，它可以在正则表达式中精确匹配原始的字符串 "(.*)"。
String input = "(.*)";
String regex = Pattern.quote(input);（5）public String pattern()
说明：pattern() 方法是在 Pattern 类中的一个公共方法，它返回该正则表达式对象所表示的模式，你可以使用这个 Pattern 对象调用 pattern() 方法，以获取该正则表达式的字符串表示形式。
String regex = "ab+c";
Pattern pattern = Pattern.compile(regex);
String patternString = pattern.pattern();
System.out.println(patternString); // 输出："ab+c"（6）public Matcher matcher(CharSequence input)
说明：matcher(CharSequence input) 方法是在Pattern 类中的一个公共方法，它用于创建一个匹配器对象，并将指定的输入序列与正则表达式进行匹配。
在 Java 中，可以使用Pattern类的 matcher(CharSequence input) 方法来创建一个 Matcher 对象，该对象可以用于执行匹配操作。CharSequence 表示一个字符序列，可以是字符串或其他类型的字符序列。
String regex = "\\d+";
String input = "12345";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
boolean isMatch = matcher.matches();
System.out.println(isMatch); // 输出：true我们首先定义了一个正则表达式字符串\d+，表示匹配一个或多个数字。然后，我们定义了一个输入字符串 input，其值为"12345"。
接下来，我们使用Pattern.compile()方法编译正则表达式，并将返回的 Pattern 对象赋值给 pattern 变量。然后，我们使用pattern.matcher(input)方法创建一个Matcher对象，该对象用于对输入序列进行匹配。
最后，我们调用matcher.matches()方法来检查输入序列是否完全匹配正则表达式。如果匹配成功，则返回 true，否则返回false。在上述示例中，由于输入字符串"12345"完全匹配正则表达式 \d+，所以输出结果为true。
因此，matcher(CharSequence input) 方法的作用是创建一个匹配器对象，并将指定的输入序列与正则表达式进行匹配。
（7）public Predicate<String> asPredicate()
说明：asPredicate() 方法是在 Pattern 类中的一个公共方法，它返回一个 Predicate<String> 对象，用于将正则表达式作为谓词进行匹配。
在 Java 中，Predicate 是一个函数接口，它接受一个输入参数并返回一个布尔值结果。Predicate<String> 表示该谓词接受一个字符串类型的输入参数。
String regex = "\\d+";
Pattern pattern = Pattern.compile(regex);
Predicate<String> predicate = pattern.asPredicate();
System.out.println(predicate.test("123")); // 输出：true
System.out.println(predicate.test("abc")); // 输出：false
我们首先定义了一个正则表达式字符串\d+，表示匹配一个或多个数字。然后，我们使用 Pattern.compile() 方法编译正则表达式，并将返回的Pattern对象赋给pattern变量。
接下来，我们调用pattern.asPredicate()方法，将正则表达式转换为一个Predicate<String>对象，并将其赋值给 predicate 变量。
最后，我们可以使用predicate.test(String input)方法来测试输入字符串是否与正则表达式匹配。如果匹配成功，则返回true，否则返回false。在上述示例中，由于输入字符串"123"符合正则表达式\d+的模式，所以第一次输出结果为true；而输入字符串"abc"不符合该模式，所以第二次输出结果为false。
因此，asPredicate() 方法的作用是将正则表达式转换为一个Predicate<String>对象，用于对输入字符串进行匹配。
（8）public int flags()
说明：flags() 方法是在 Pattern 类中的一个公共方法，用于返回当前正则表达式模式的标志位（flags）。
在 Java 中，Pattern 类的正则表达式模式可以使用一些标志来修改其行为。这些标志可以通过在正则表达式字符串中添加特殊的标记来指定。
以下是一些常用的标志：
flags() 方法将返回一个整数值，表示当前正则表达式模式的标志位。该整数值是由上述标志的按位或组合而成。
String regex = "abc";
Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
int flags = pattern.flags();
System.out.println(flags); // 输出：2我们首先定义了一个正则表达式字符串 "abc"，然后使用 Pattern.compile() 方法编译该正则表达式，并将 Pattern.CASE_INSENSITIVE | Pattern.MULTILINE 作为第二个参数传递给方法，这样我们同时启用了 CASE_INSENSITIVE 和 MULTILINE 两个标志。
接下来，我们调用 pattern.flags() 方法，返回一个整数值，表示当前正则表达式模式的标志位。
最后，我们打印出 flags 的值，它将输出 2，表示 CASE_INSENSITIVE 和 MULTILINE 两个标志被启用。
因此，flags() 方法的作用是返回当前正则表达式模式的标志位的整数值。
**（9）public String[] split(CharSequence input)**
说明：split(CharSequence input) 方法是在 Pattern 类中的一个公共方法，用于将输入序列根据正则表达式进行拆分，并返回拆分后的字符串数组
在 Java 中，可以使用 Pattern 类的 split(CharSequence input) 方法来将一个字符序列按照正则表达式进行拆分。CharSequence 表示一个字符序列，可以是字符串或其他类型的字符序列。
String regex = "\\s+";
String input = "Hello World Java";
Pattern pattern = Pattern.compile(regex);
String[] parts = pattern.split(input);
for (String part : parts) {
System.out.println(part);
}
/*
运行结果：
Hello
World
Java
*/我们首先定义了一个正则表达式字符串\s+，表示匹配一个或多个空格。然后，我们定义了一个输入字符串 input，其值为 "Hello World Java"，包含多个连续空格。
接下来，我们使用 Pattern.compile() 方法编译正则表达式，并将返回的 Pattern 对象赋给 pattern 变量。然后，我们调用 pattern.split(input) 方法，将输入字符串按照正则表达式进行拆分。拆分后的结果将存储在一个字符串数组 parts 中。
最后，我们使用一个循环遍历输出 parts 数组中的每个元素，以显示拆分后的结果
（10）public String[] split(CharSequence input, int limit)
说明：可以使用 Pattern 类的 split(CharSequence input, int limit) 方法来将一个字符序列按照正则表达式进行拆分，并限制拆分的数量。CharSequence 表示一个字符序列，可以是字符串或其他类型的字符序列，而 limit 参数表示拆分的最大数量
String regex = "\\s+";
String input = "Hello World Java";
Pattern pattern = Pattern.compile(regex);
String[] parts = pattern.split(input, 2);
for (String part : parts) {
System.out.println(part);
}
/*
运行结果：
Hello
World Java
*/我们首先定义了一个正则表达式字符串 \s+，表示匹配一个或多个空格。然后，我们定义了一个输入字符串 input，其值为 "Hello World Java"，包含多个连续空格。
接下来，我们使用 Pattern.compile() 方法编译正则表达式，并将返回的 Pattern 对象赋给 pattern 变量。然后，我们调用 pattern.split(input, 2) 方法，将输入字符串按照正则表达式进行拆分，并限制拆分的最大数量为 2。拆分后的结果将存储在一个字符串数组 parts 中。
最后，我们使用一个循环遍历输出 parts 数组中的每个元素，以显示拆分后的结果。
（11）public String[] split(CharSequence input, int limit)
说明：splitAsStream(final CharSequence input) 方法是在 Pattern 类中的一个公共方法，用于将输入序列根据正则表达式进行拆分，并返回一个 Stream<String> 流，在流中包含了拆分后的字符串元素。
可以使用 Pattern 类的 splitAsStream(final CharSequence input) 方法来将一个字符序列按照正则表达式进行拆分，并生成一个流对象，该流中包含了拆分后的字符串元素。
import java.util.regex.Pattern;
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
String regex = "\\s+";
String input = "Hello World Java";
Pattern pattern = Pattern.compile(regex);
Stream<String> stream = pattern.splitAsStream(input);
stream.forEach(System.out::println);
}
}
/*
运行结果：
Hello
World
Java
*/我们首先定义了一个正则表达式字符串\s+，表示匹配一个或多个空格。然后，我们定义了一个输入字符串 input，其值为 "Hello World Java"，包含多个连续空格。
接下来，我们使用 Pattern.compile() 方法编译正则表达式，并将返回的 Pattern 对象赋给 pattern 变量。然后，我们调用 pattern.splitAsStream(input) 方法，将输入字符串按照正则表达式进行拆分，并生成一个Stream<String> 流对象，其中包含了拆分后的字符串元素。
最后，我们使用 forEach() 方法遍历流中的每个字符串元素，并打印输出。
（12）public static String quoteReplacement(String s)
说明：quoteReplacement(String s) 方法是在 Matcher 类中的一个静态方法，用于将输入字符串转义，以便在替换操作中使用。
在 Java 中，正则表达式的替换操作通常使用 Matcher 类的 replaceAll(String replacement) 或 replaceFirst(String replacement) 方法。当替换字符串中包含一些特殊字符（如 $、\ 等）时，为了正确处理这些字符，需要对替换字符串进行转义。
quoteReplacement(String s) 方法接受一个字符串参数 s，并返回一个转义后的字符串，该字符串可以安全地用作替换操作的替换字符串。
public class RegTest {
public static void main(String[] args) {
String input = "Hello $ World";
String replacement = Matcher.quoteReplacement("$1");
String result = input.replaceAll("\\$", replacement);
System.out.println(replacement); //输出：\$1
System.out.println(result); // 输出：Hello $1 World
}
}
/*
运行结果：
\$1
Hello $1 World
*/代码判断输入字符串 s 中是否包含\和 $ 字符，即(s.indexOf('\') == -1) && (s.indexOf('$') == -1)。如果不包含任何特殊字符，则直接返回原始字符串s。
如果输入字符串中包含了\或$字符，则进入循环处理。代码使用一个 StringBuilder 对象 sb 来构建转义后的字符串。通过遍历输入字符串的每个字符，将特殊字符\或$进行转义处理，并添加到 sb 中。
具体地，当遇到特殊字符时，代码使用 sb.append('\'); 将一个反斜杠字符添加到 sb 中，以进行转义。然后，将当前字符 c 添加到 sb 中。
最后，循环结束后，代码通过 sb.toString() 方法将 StringBuilder 转换为字符串，并返回转义后的结果。
（13）public boolean find()
说明：find() 方法是在 Matcher 类中的一个公共方法，用于在输入字符串中查找与正则表达式模式匹配的下一个子序列
在 Java 中，Matcher 对象表示了对某个输入字符串进行正则表达式匹配的状态。find() 方法通过在输入字符串中寻找与模式匹配的下一个子序列，来进行匹配操作。
该方法返回一个布尔值，如果在输入字符串中找到了匹配的子序列，则返回 true，否则返回 false。
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
String regex = "\\d+";
String input = "12345";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
if (matcher.find()) {
System.out.println("Match found: " + matcher.group());
} else {
System.out.println("No match found.");
}
}
}
/*
运行结果：
Match found: 12345
*/我们使用之前提到的方式创建了一个 Matcher 对象，并调用 find() 方法进行匹配操作。
如果匹配成功（即在输入字符串中找到了匹配的子序列），则通过 matcher.group() 方法获取匹配的结果，并打印输出。否则，输出未找到匹配。
（14）public boolean find(int start)
说明：find(int start) 方法是在 Matcher 类中的一个公共方法，用于在输入字符串中从指定位置开始查找与正则表达式模式匹配的下一个子序列。
该方法接受一个整数参数 start，表示开始查找的位置索引。它会从指定位置开始在输入字符串中查找与正则表达式模式匹配的下一个子序列。
find(int start) 方法返回一个布尔值，如果在指定位置之后的输入字符串中找到了匹配的子序列，则返回 true，否则返回 false。
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
String regex = "\\d+";
String input = "12345";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
int start = 2; // 从索引 2 开始查找
if (matcher.find(start)) {
System.out.println("Match found: " + matcher.group());
} else {
System.out.println("No match found.");
}
}
}
/*
运行结果：
Match found: 345
*/我们使用之前提到的方式创建了一个 Matcher 对象，并定义了一个开始查找的位置索引 start。
然后，我们调用 find(int start) 方法并传入 start 参数来执行匹配操作。如果在指定位置之后的输入字符串中找到了匹配的子序列，则通过 matcher.group() 方法获取匹配的结果，并打印输出。否则，输出未找到匹配。
（15）public String group()
说明：group() 方法是在 Matcher 类中的一个公共方法，用于返回与最后一次匹配操作相匹配的字符串。
在执行匹配操作后，如果 find() 方法返回 true，则表示找到了匹配的子序列。此时，可以使用 group() 方法获取最后一次匹配操作所匹配的字符串。
group() 方法返回一个字符串，即最后一次匹配操作所匹配的子序列。
public class RegTest {
public static void main(String[] args) {
String regex = "\\d";
String input = "12345";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
while(matcher.find()){
System.out.println("Match found: " + matcher.group());
}
}
}
/*
运行结果：
Match found: 1
Match found: 2
Match found: 3
Match found: 4
Match found: 5
*/（16）public String group(int group)
说明：group(int group) 方法是在 Matcher 类中的一个公共方法，用于返回与最后一次匹配操作中指定组号相匹配的字符串。
在正则表达式中，使用圆括号 () 可以创建捕获组（Capture Group）。当进行匹配操作时，每个捕获组都有一个对应的组号，从 1 开始递增。group(int group) 方法接受一个整数参数 group，表示要获取的捕获组的组号。
group(int group) 方法返回一个字符串，即最后一次匹配操作中指定组号所匹配的子序列。
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
String regex = "(\\d+)-(\\w+)";
String input = "12345-abcd";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
if (matcher.find()) {
System.out.println("First group: " + matcher.group(1));
System.out.println("Second group: " + matcher.group(2));
} else {
System.out.println("No match found.");
}
}
}
/*
运行结果：
First group: 12345
Second group: abcd
*/我们使用之前提到的方式创建了一个 Matcher 对象，并调用 find() 方法进行匹配操作。
如果匹配成功（即在输入字符串中找到了匹配的子序列），则通过 matcher.group(int group) 方法获取指定组号的匹配结果，并打印输出。这里分别获取了第一个捕获组和第二个捕获组的结果。不指定捕获组名称，默认捕获组从1开始递增编号
group(int group) 方法的作用是返回与最后一次匹配操作中指定组号相匹配的字符串。它可以用于获取指定组号的匹配结果并进行后续处理。注意，组号必须大于等于 1，且不能超过实际捕获组的数量，否则会抛出 IndexOutOfBoundsException 异常.
（17）public String group(String name)
说明：group(String name) 方法是在 Matcher 类中的一个公共方法，用于返回与最后一次匹配操作中指定命名组名相匹配的字符串。
在正则表达式中，可以使用命名捕获组（Named Capture Group）来标识和引用特定的子表达式。每个命名捕获组都有一个唯一的名称，可以通过该名称来引用对应的匹配结果。
group(String name) 方法接受一个字符串参数 name，表示要获取的命名捕获组的名称。
group(String name) 方法返回一个字符串，即最后一次匹配操作中指定命名组名所匹配的子序列。
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
String regex = "(?<number>\\d+)-(?<word>\\w+)";
String input = "12345-abcd";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
if (matcher.find()) {
System.out.println("Number group: " + matcher.group("number"));
System.out.println("Word group: " + matcher.group("word"));
} else {
System.out.println("No match found.");
}
}
}
/*
运行结果:
Number group: 12345
Word group: abcd
*/我们使用之前提到的方式创建了一个 Matcher 对象，并调用 find() 方法进行匹配操作。
如果匹配成功（即在输入字符串中找到了匹配的子序列），则通过 matcher.group(String name) 方法获取指定命名组名的匹配结果，并打印输出。这里分别获取了名为 “number” 的命名捕获组和名为 “word” 的命名捕获组的结果。
group(String name) 方法的作用是返回与最后一次匹配操作中指定命名组名相匹配的字符串。它可以用于获取指定命名组名的匹配结果并进行后续处理。如果没有找到指定的命名组名，或者命名组名不合法，会抛出 IllegalArgumentException 异常.
（18）public boolean matches()
说明：matches() 方法是在 Matcher 类中的一个公共方法，用于尝试将整个输入序列与正则表达式进行匹配。
该方法会尝试将整个输入序列与正则表达式进行匹配，而不仅仅是寻找匹配的子序列。只有当整个输入序列完全匹配正则表达式时，matches() 方法才返回 true，否则返回 false。
public class RegTest {
public static void main(String[] args) {
String regex = "\\d\\d\\d";
String input = "12345";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
if (matcher.matches()) {
System.out.println("Input matches the regular expression.");
} else {
System.out.println("Input does not match the regular expression.");
}
}
}
/*
运行结果：
Input does not match the regular expression.
*/因为上面的正则表达式无法完全匹配输入的12345，所以matches返回的false
（19）public Pattern pattern()
说明：pattern() 方法是在 Matcher 类中的一个公共方法，用于返回与当前 Matcher 对象关联的正则表达式模式。
正则表达式模式通过 Pattern 类的实例来表示。pattern() 方法返回的就是与当前 Matcher 对象关联的 Pattern 实例。
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
String regex = "\\d+";
String input = "12345";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
Pattern associatedPattern = matcher.pattern();
System.out.println("Associated pattern: " + associatedPattern.pattern());
}
}
/*
运行结果：
Associated pattern: \d+
*/我们首先创建了一个 Pattern 对象，用于表示正则表达式模式。然后，我们将该模式与输入字符串进行匹配操作，得到对应的 Matcher 对象。
接下来，我们调用 pattern() 方法获取与当前 Matcher 对象关联的正则表达式模式，并将其打印输出。
（20）public String replaceAll(String replacement)
说明：replaceAll(String replacement) 方法是在 Matcher 类中的一个公共方法，用于将匹配到的子序列替换为指定的字符串。
该方法会查找输入字符串中与正则表达式模式匹配的所有子序列，并将其替换为指定的字符串 replacement。
replaceAll(String replacement) 方法接受一个字符串参数 replacement，表示要替换匹配子序列的字符串。
replaceAll() 方法返回一个新的字符串，其中所有匹配的子序列都被替换为指定的字符串。
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
String regex = "\\d+";
String input = "Hello 123 World 456";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
String replacedString = matcher.replaceAll("X");
System.out.println("Replaced string: " + replacedString);
}
}
/*
输出内容：
Replaced string: Hello X World X
*/
们使用之前提到的方式创建了一个 Matcher 对象，并调用 replaceAll(String replacement) 方法进行替换操作。
该示例中，正则表达式模式\d+ 可以匹配连续的数字。我们将输入字符串中所有匹配到的数字替换为字符 “X”。
（21）public String replaceAll(Function<MatchResult, String> replacer) （java9/java1.9）
说明：String replaceAll(Function<MatchResult, String> replacer) 方法是在 Matcher 类中提供的一个功能，用于基于指定的模式替换字符串的部分内容。
它接受一个 函数式接口Function 参数 replacer，该参数用于确定每个匹配子串的替换值。replacer 函数接受一个 MatchResult 对象，表示当前的匹配结果，并返回替换后的字符串。
import java.util.function.Function;
import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class MatcherReplaceAllExample {
public static void main(String[] args) {
String text = "Hello, world! How are you?";
// Define a regular expression pattern
Pattern pattern = Pattern.compile("\\b\\w{3}\\b");
// Create a matcher from the input text
Matcher matcher = pattern.matcher(text);
// Use replaceAll with a lambda expression as the replacer
//这里表示在调用函数式接口的方法的时候，将每次匹配的内容以大写的形式返回
String result = matcher.replaceAll(match -> match.group().toUpperCase());
System.out.println(result);
}
}
/*
运行结果：
HELLO, WORLD! HOW ARE YOU?
*/（22）public int start()
说明：返回上次匹配到内容的初始索引，如果上次匹配没有内容，抛出异常。
String text = "Hello, world! How are you?";
// Define a regular expression pattern
Pattern pattern = Pattern.compile("\\b\\w{3}\\b");
// Create a matcher from the input text
Matcher matcher = pattern.matcher(text);
while(matcher.find()){
System.out.println("当前匹配内容：" + matcher.group() +",当前匹配的索引是:" + matcher.start());
}
}
}
/*
运行结果：
当前匹配内容：How,当前匹配的索引是:14
当前匹配内容：are,当前匹配的索引是:18
当前匹配内容：you,当前匹配的索引是:22
*/（23）public int start(int group)
说明：和public String group(int group)类似，上一次匹配结果，捕获组次序为group的的索引值。
（24）public int start(String name)
说明：和public String group(String Name)类似，上一次匹配结果，捕获组名称为name的的索引值。
（25）public int end()
说明：返回上一次匹配结果的结束索引位置，如果上次没有匹配，那么报错
（26）public int end(int group)
说明：和public String group(int group)类似，不做过多解释
（27）public int end(String name)
说明：和public String group(String name)类似，不做过多解释
（28）public int groupCount()
说明：
Matcher类的groupCount()方法是用于获取匹配器中捕获组的数量
String input = "Hello World";
Pattern pattern = Pattern.compile("(Hello) (World)");
Matcher matcher = pattern.matcher(input);
int count = matcher.groupCount();
System.out.println("Number of capturing groups: " + count);
/*
运行结果：
Number of capturing groups: 2
*/
我们使用正则表达式模式"(Hello) (World)“来创建一个Matcher对象。然后，我们使用groupCount()方法获取匹配器中的捕获组数量，并将结果打印出来。在这个例子中，正则表达式包含两个捕获组，因此输出是"Number of capturing groups: 2”。
（29）public int groupCount(int group)
说明：和public String group(int group)类似，不做过多解释
（30）public int groupCount(String name)
说明：和public String group(String name)类似，不做过多解释
（31）public boolean lookingAt()
说明：lookingAt()是Matcher类中的一个方法，用于检查输入字符串的起始部分是否与正则表达式模式匹配。
String input = "Hello World";
Pattern pattern = Pattern.compile("Hello");
Matcher matcher = pattern.matcher(input);
boolean isLookingAt = matcher.lookingAt();
System.out.println("Looking at: " + isLookingAt);
/*
运行结果：
Looking at: true
*/如果将input改为String input = "123Hello World";，则会报错失败。
（32）public Matcher region(int start, int end)
说明：Matcher类的region()方法用于设置匹配器的区域范围，即指定在输入字符串中进行匹配操作的起始位置和结束位置。返回值为Matcher对象本身，因此可以进行链式调用。
参数说明：
String input = "Hello World";
Pattern pattern = Pattern.compile("World");
Matcher matcher = pattern.matcher(input).region(6, 11);
System.out.println("Matches: " + matcher.toString());
/*
运行结果：
Matches: java.util.regex.Matcher[pattern=World region=6,11 lastmatch=]
*/（33）public int regionEnd()
说明：regionEnd()是Matcher类中的一个方法，用于返回匹配器当前设置的区域范围的结束位置（不包括）
String input = "Hello World";
Pattern pattern = Pattern.compile("World");
Matcher matcher = pattern.matcher(input);
matcher.region(6, 11);
int regionEnd = matcher.regionEnd();
System.out.println("Region end: " + regionEnd);
/*
运行结果：
Region end: 11
*/（34）public int regionStart()
说明：regionStart() 是 Matcher 类中的一个方法，用于返回匹配器当前设置的区域范围的起始位置。
String input = "Hello World";
Pattern pattern = Pattern.compile("World");
Matcher matcher = pattern.matcher(input);
matcher.region(6, 11);
int regionStart = matcher.regionStart();
System.out.println("Region start: " + regionStart);
/*
运行结果：
Region start: 6
*/（35）public String replaceFirst(String replacement)
说明：replaceFirst(String replacement) 是 Matcher 类中的一个方法，用于将匹配到的第一个子字符串替换为指定的替换字符串。
String input = "Hello World World World!";
Pattern pattern = Pattern.compile("World");
Matcher matcher = pattern.matcher(input);
String replacedString = matcher.replaceFirst("Universe");
System.out.println("Replaced string: " + replacedString);
/*
运行结果：
Replaced string: Hello Universe World World!
*/（36）public String replaceFirst(Function<MatchResult, String> replacer)
说明：类似于上面的public String replaceAll(Function<MatchResult, String> replacer)
String input = "Hello World World World!";
Pattern pattern = Pattern.compile("World");
Matcher matcher = pattern.matcher(input);
String replacedString = matcher.replaceFirst(match -> match.group().toUpperCase());
System.out.println("Replaced string: " + replacedString);
/*
运行结果：
Replaced string: Hello WORLD World World!
*/
（37）public Matcher reset()
说明：
reset() 是 Matcher 类中的一个方法，用于重置匹配器的状态，将其重新设置为初始状态。
String input = "Hello World";
Pattern pattern = Pattern.compile("World");
Matcher matcher = pattern.matcher(input);
matcher.find();
System.out.println("First match: " + matcher.group());
matcher.reset();
matcher.find();
System.out.println("Reset match: " + matcher.group());
/*
运行结果：
First match: World
Reset match: World
*/我们首先使用正则表达式模式"World"创建一个 Matcher 对象，并将其应用于输入字符串"Hello World"。然后，我们使用 find() 方法进行一次匹配操作，并打印出第一个匹配到的子字符串 “World”。接下来，我们使用 reset() 方法重置匹配器的状态，将其恢复到初始状态。再次使用 find() 方法进行匹配操作，可以看到匹配器又重新从输入字符串中找到了与正则表达式匹配的子字符串 “World”。
（38）public Matcher reset(CharSequence input)
说明：reset(CharSequence input) 是 Matcher 类中的一个方法，用于重置匹配器的状态，并将新的输入字符序列应用于匹配器
String input = "Hello World";
Pattern pattern = Pattern.compile("World");
Matcher matcher = pattern.matcher(input);
matcher.find();
System.out.println("First match: " + matcher.group());
CharSequence newInput = "Hello Universe";
matcher.reset(newInput);
matcher.find();
System.out.println("Reset match: " + matcher.group());
/*
运行结果：
First match: World
Reset match: Universe
*/（39）public Matcher reset(CharSequence input)
说明：toMatchResult() 是 Matcher 类中的一个方法，用于返回当前匹配操作的结果作为 MatchResult 对象。
String input = "Hello World";
Pattern pattern = Pattern.compile("World");
Matcher matcher = pattern.matcher(input);
matcher.find();
MatchResult matchResult = matcher.toMatchResult();
System.out.println("Matched substring: " + matchResult.group());
System.out.println("Start index: " + matchResult.start());
System.out.println("End index: " + matchResult.end());
/*
输出：
Matched substring: World
Start index: 6
End index: 11
*/我们首先使用正则表达式模式"World"创建一个 Matcher 对象，并将其应用于输入字符串"Hello World"。然后，我们使用 find() 方法进行一次匹配操作。接下来，我们使用 toMatchResult() 方法获取当前匹配操作的结果作为 MatchResult 对象。通过 MatchResult 对象，我们可以访问匹配到的子字符串、起始位置和结束位置等信息，并将其打印出来。
请注意，toMatchResult() 方法返回的是一个 MatchResult 对象，其中包含了有关匹配结果的各种信息。通过 MatchResult 对象，您可以获取匹配到的子字符串以及它在输入字符串中的起始位置和结束位置等相关信息。
（40）public Matcher usePattern(Pattern newPattern)
说明：usePattern(Pattern newPattern) 是 Matcher 类中的一个方法，用于将匹配器切换到一个新的正则表达式模式
该方法的函数签名如下：
public Matcher usePattern(Pattern newPattern)
参数 newPattern 表示要切换到的新的正则表达式模式。
返回值为 Matcher 对象本身，因此可以进行链式调用
String input = "Hello World";
Pattern pattern1 = Pattern.compile("World");
Matcher matcher = pattern1.matcher(input);
matcher.find();
System.out.println("First match: " + matcher.group());
Pattern pattern2 = Pattern.compile("Hello");
matcher.usePattern(pattern2);
matcher.find();
System.out.println("New pattern match: " + matcher.group());
/*
运行结果：
First match: World
New pattern match: Hello
*/我们首先使用正则表达式模式 “World” 创建一个 Matcher 对象，并将其应用于输入字符串 “Hello World”。然后，我们使用 find() 方法进行一次匹配操作，并打印出第一个匹配到的子字符串 “World”。接下来，我们创建了另一个正则表达式模式 “Hello” 并使用 usePattern() 方法将匹配器切换到这个新的模式。再次使用 find() 方法进行匹配操作，可以看到匹配器从新的模式中找到了与之匹配的子字符串 “Hello”。
请注意，usePattern(Pattern newPattern) 方法用于切换 Matcher 对象的正则表达式模式。通过使用不同的模式，您可以重复使用同一个 Matcher 对象进行多个不同模式的匹配操作。调用此方法后，匹配器的状态将被重置，并从新的模式开始进行匹配操作。
正则表达式是一种用来匹配字符串的强有力的武器
它的设计思想是用一种描述性的语言定义一个规则，凡是符合规则的字符串，我们就认为它“匹配”了，否则，该字符串就是不合法的
根据正则表达式语法规则，大部分字符仅能够描述自身，这些字符被称为普通字符，如所有的字母、数字等。
元字符就是拥有特动功能的特殊字符，大部分需要加反斜杠进行标识，以便于普通字符进行区别，而少数元字符，需要加反斜杠，以便转译为普通字符使用。JavaScript 正则表达式支持的元字符如表所示。
在 JavaScript中，正则表达式也是对象，构建正则表达式有两种方式：
const re = /\d+/g;
const re = new RegExp("\\d+","g");
const rul = "\\d+"
const re1 = new RegExp(rul,"g");
使用构建函数创建，第一个参数可以是一个变量，遇到特殊字符\需要使用\进行转义
表示字符的方法有多种，除了可以直接使用字符本身外，还可以使用 ASCII 编码或者 Unicode 编码来表示。
下面使用 ASCII 编码定义正则表达式直接量。
var r = /\x61/;var s = "JavaScript";var a = s.match(s);由于字母 a 的 ASCII 编码为 97，被转换为十六进制数值后为 61，因此如果要匹配字符 a，就应该在前面添加“\x”前缀，以提示它为 ASCII 编码。
除了十六进制外，还可以直接使用八进制数值表示字符。
var r = /1/;var s = "JavaScript";var a = s.match(r);使用十六进制需要添加“\x”前缀，主要是为了避免语义混淆，而八进制则不需要添加前缀。
ASCII 编码只能够匹配有限的单字节字符，使用 Unicode 编码可以表示双字节字符。Unicode 编码方式：“\u”前缀加上 4 位十六进制值。
var r = "/\u0061/";var s = "JavaScript";var a = s.match(s);
在 RegExp() 构造函数中使用元字符时，应使用双斜杠。
var r = new RegExp("\u0061"); RegExp() 构造函数的参数只接受字符串，而不是字符模式。在字符串中，任何字符加反斜杠还表示字符本身，如字符串“\u”就被解释为 u 本身，所以对于“\u0061”字符串来说，在转换为字符模式时，就被解释为“u0061”，而不是“\u0061”，此时反斜杠就失去转义功能。解决方法：在字符 u 前面加双反斜杠。
常见的校验规则如下：
规则 | 描述 |
\ | 转义 |
^ | 匹配输入的开始 |
$ | 匹配输入的结束 |
* | 匹配前一个表达式 0 次或多次 |
+ | 匹配前面一个表达式 1 次或者多次。等价于 {1,} |
? | 匹配前面一个表达式 0 次或者 1 次。等价于{0,1} |
. | 默认匹配除换行符之外的任何单个字符 |
x(?=y) | 匹配'x'仅仅当'x'后面跟着'y'。这种叫做先行断言 |
(?<=y)x | 匹配'x'仅当'x'前面是'y'.这种叫做后行断言 |
x(?!y) | 仅仅当'x'后面不跟着'y'时匹配'x'，这被称为正向否定查找 |
(?<!y)x | 仅仅当'x'前面不是'y'时匹配'x'，这被称为反向否定查找 |
x|y | 匹配‘x’或者‘y’ |
{n} | n 是一个正整数，匹配了前面一个字符刚好出现了 n 次 |
{n,} | n是一个正整数，匹配前一个字符至少出现了n次 |
{n,m} | n 和 m 都是整数。匹配前面的字符至少n次，最多m次 |
[xyz] | 一个字符集合。匹配方括号中的任意字符 |
[^xyz] | 匹配任何没有包含在方括号中的字符 |
\b | 匹配一个词的边界，例如在字母和空格之间 |
\B | 匹配一个非单词边界 |
\d | 匹配一个数字 |
\D | 匹配一个非数字字符 |
\f | 匹配一个换页符 |
\n | 匹配一个换行符 |
\r | 匹配一个回车符 |
\s | 匹配一个空白字符，包括空格、制表符、换页符和换行符 |
\S | 匹配一个非空白字符 |
\w | 匹配一个单字字符（字母、数字或者下划线） |
\W | 匹配一个非单字字符 |
标志 | 描述 |
g | 全局搜索。 |
i | 不区分大小写搜索。 |
m | 多行搜索。 |
s | 允许 . 匹配换行符。 |
u | 使用unicode码的模式进行匹配。 |
y | 执行“粘性(sticky)”搜索,匹配从目标字符串的当前位置开始。 |
使用方法如下：
var re = /pattern/flags;
var re = new RegExp("pattern", "flags");
在了解下正则表达式基本的之外，还可以掌握几个正则表达式的特性：
在了解贪婪模式前，首先举个例子：
const reg = /ab{1,3}c/
在匹配过程中，尝试可能的顺序是从多往少的方向去尝试。首先会尝试bbb，然后再看整个正则是否能匹配。不能匹配时，吐出一个b，即在bb的基础上，再继续尝试，以此重复
如果多个贪婪量词挨着，则深度优先搜索
const string = "12345";
const regx = /(\d{1,3})(\d{1,3})/;
console.log( string.match(reg) );
// => ["12345", "123", "45", index: 0, input: "12345"]
其中，前面的\d{1,3}匹配的是"123"，后面的\d{1,3}匹配的是"45"
惰性量词就是在贪婪量词后面加个问号。表示尽可能少的匹配
var string = "12345";
var regex = /(\d{1,3}?)(\d{1,3})/;
console.log( string.match(regex) );
// => ["1234", "1", "234", index: 0, input: "12345"]其中\d{1,3}?只匹配到一个字符"1"，而后面的\d{1,3}匹配了"234"
分组主要是用过()进行实现，比如beyond{3}，是匹配d字母3次。而(beyond){3}是匹配beyond三次
在()内使用|达到或的效果，如(abc | xxx)可以匹配abc或者xxx
反向引用，巧用$分组捕获
let str = "John Smith";
// 交换名字和姓氏
console.log(str.replace(/(john) (smith)/i, '$2, $1')) // Smith, John
正则表达式常被用于某些方法，我们可以分成两类：
方法 | 描述 |
exec | 一个在字符串中执行查找匹配的RegExp方法，它返回一个数组（未匹配到则返回 null）。 |
test | 一个在字符串中测试是否匹配的RegExp方法，它返回 true 或 false。 |
match | 一个在字符串中执行查找匹配的String方法，它返回一个数组，在未匹配到时会返回 null。 |
matchAll | 一个在字符串中执行查找所有匹配的String方法，它返回一个迭代器（iterator）。 |
search | 一个在字符串中测试匹配的String方法，它返回匹配到的位置索引，或者在失败时返回-1。 |
replace | 一个在字符串中执行查找匹配的String方法，并且使用替换字符串替换掉匹配到的子字符串。 |
split | 一个使用正则表达式或者一个固定字符串分隔一个字符串，并将分隔后的子字符串存储到数组中的 String 方法。 |
str.match(regexp) 方法在字符串 str 中找到匹配 regexp 的字符
如果 regexp 不带有 g 标记，则它以数组的形式返回第一个匹配项，其中包含分组和属性 index（匹配项的位置）、input（输入字符串，等于 str）
let str = "I love JavaScript";
let result = str.match(/Java(Script)/);
console.log( result[0] ); // JavaScript（完全匹配）
console.log( result[1] ); // Script（第一个分组）
console.log( result.length ); // 2
// 其他信息：
console.log( result.index ); // 7（匹配位置）
console.log( result.input ); // I love JavaScript（源字符串）
如果 regexp 带有 g 标记，则它将所有匹配项的数组作为字符串返回，而不包含分组和其他详细信息
let str = "I love JavaScript";
let result = str.match(/Java(Script)/g);
console.log( result[0] ); // JavaScript
console.log( result.length ); // 1如果没有匹配项，则无论是否带有标记 g ，都将返回 null
let str = "I love JavaScript";
let result = str.match(/HTML/);
console.log(result); // null返回一个包含所有匹配正则表达式的结果及分组捕获组的迭代器
const regexp = /t(e)(st(\d?))/g;
const str = 'test1test2';
const array = [...str.matchAll(regexp)];
console.log(array[0]);
// expected output: Array ["test1", "e", "st1", "1"]
console.log(array[1]);
// expected output: Array ["test2", "e", "st2", "2"]
返回第一个匹配项的位置，如果未找到，则返回 -1
let str = "A drop of ink may make a million think";
console.log( str.search( /ink/i ) ); // 10（第一个匹配位置）
这里需要注意的是，search 仅查找第一个匹配项
替换与正则表达式匹配的子串，并返回替换后的字符串。在不设置全局匹配g的时候，只替换第一个匹配成功的字符串片段
const reg1=/javascript/i;
const reg2=/javascript/ig;
console.log('hello Javascript Javascript Javascript'.replace(reg1,'js'));
//hello js Javascript Javascript
console.log('hello Javascript Javascript Javascript'.replace(reg2,'js'));
//hello js js js
使用正则表达式（或子字符串）作为分隔符来分割字符串
console.log('12, 34, 56'.split(/,\s*/)) // 数组 ['12', '34', '56']regexp.exec(str) 方法返回字符串 str 中的 regexp 匹配项，与以前的方法不同，它是在正则表达式而不是字符串上调用的
根据正则表达式是否带有标志 g，它的行为有所不同
如果没有 g，那么 regexp.exec(str) 返回的第一个匹配与 str.match(regexp) 完全相同
如果有标记 g，调用 regexp.exec(str) 会返回第一个匹配项，并将紧随其后的位置保存在属性regexp.lastIndex 中。 下一次同样的调用会从位置 regexp.lastIndex 开始搜索，返回下一个匹配项，并将其后的位置保存在 regexp.lastIndex 中
let str = 'More about JavaScript at https://javascript.info';
let regexp = /javascript/ig;
let result;
while (result = regexp.exec(str)) {
console.log( `Found ${result[0]} at position ${result.index}` );
// Found JavaScript at position 11
// Found javascript at position 33
}查找匹配项，然后返回 true/false 表示是否存在
let str = "I love JavaScript";
// 这两个测试相同
console.log( /love/i.test(str) ); // true通过上面的学习，我们对正则表达式有了一定的了解
下面再来看看正则表达式一些案例场景：
验证QQ合法性（5~15位、全是数字、不以0开头）：
const reg = /^[1-9][0-9]{4,14}$/
const isvalid = patrn.exec(s)校验用户账号合法性（只能输入5-20个以字母开头、可带数字、“_”、“.”的字串）：
var patrn=/^[a-zA-Z]{1}([a-zA-Z0-9]|[._]){4,19}$/;
const isvalid = patrn.exec(s)将url参数解析为对象
const protocol = '(?<protocol>https?:)';
const host = '(?<host>(?<hostname>[^/#?:]+)(?::(?<port>\\d+))?)';
const path = '(?<pathname>(?:\\/[^/#?]+)*\\/?)';
const search = '(?<search>(?:\\?[^#]*)?)';
const hash = '(?<hash>(?:#.*)?)';
const reg = new RegExp(`^${protocol}\/\/${host}${path}${search}${hash}$`);
function execURL(url){
const result = reg.exec(url);
if(result){
result.groups.port = result.groups.port || '';
return result.groups;
}
return {
protocol:'',host:'',hostname:'',port:'',
pathname:'',search:'',hash:'',
};
}
console.log(execURL('https://localhost:8080/?a=b#xxxx'));
protocol: "https:"
host: "localhost:8080"
hostname: "localhost"
port: "8080"
pathname: "/"
search: "?a=b"
hash: "#xxxx"再将上面的search和hash进行解析
function execUrlParams(str){
str = str.replace(/^[#?&]/,'');
const result = {};
if(!str){ //如果正则可能配到空字符串，极有可能造成死循环，判断很重要
return result;
}
const reg = /(?:^|&)([^&=]*)=?([^&]*?)(?=&|$)/y
let exec = reg.exec(str);
while(exec){
result[exec[1]] = exec[2];
exec = reg.exec(str);
}
return result;
}
console.log(execUrlParams('#'));// {}
console.log(execUrlParams('##'));//{'#':''}
console.log(execUrlParams('?q=3606&src=srp')); //{q: "3606", src: "srp"}
console.log(execUrlParams('test=a=b=c&&==&a='));//{test: "a=b=c", "": "=", a: ""}
1. dotAll模式(s选项)
这个特性已经在ECMAScript 2018正式发布了。
默认情况下，.可以匹配任意字符，除了换行符:
/foo.bar/u.test('foo\nbar'); // false另外，.不能匹配Unicode字符，需要使用u选项启用Unicode模式才行。
ES2018引入了dotAll模式，通过s选项可以启用，这样，.就可以匹配换行符了。
/foo.bar/su.test('foo\nbar'); // true2. Lookbehind断言
这个特性已经在ECMAScript 2018正式发布了。
ECMAScript目前仅支持lookahead断言。
下面示例是Positive lookahead，匹配字符串“42 dollars”中紧跟着是”dollars”的数字：
const pattern = /\d+(?= dollars)/u;
const result = pattern.exec('42 dollars');
console.log(result[0]); // 打印42下面示例是Negative lookahead，匹配字符串“42 pesos”中紧跟着的不是”dollars”的数字:
const pattern = /\d+(?! dollars)/u;
const result = pattern.exec('42 pesos');
console.log(result[0]); // 打印42ES2018添加了lookbehind断言。
下面示例是Positive lookbehind，匹配字符串“”中前面是”$”的数字:
const pattern = /(?<=\$)\d+/u;
const result = pattern.exec('$42');
console.log(result[0]); // 打印42下面示例是Negative lookbehind，匹配字符串“”中前面不是是”$”的数字:
const pattern = /(?<!\$)\d+/u;
const result = pattern.exec('€42');
console.log(result[0]); // 打印42Fundebug专注于网页、微信小程序、微信小游戏，支付宝小程序，React Native，Node.js和Java线上BUG实时监控，欢迎免费试用
3. Named capture groups
这个特性已经在ECMAScript 2018正式发布了。
目前，正则表达式中小括号匹配的分组是通过数字编号的：
const pattern = /(\d{4})-(\d{2})-(\d{2})/u;
const result = pattern.exec('2017-01-25');
console.log(result[0]); // 打印"2017-01-25"
console.log(result[1]); // 打印"2017"
console.log(result[2]); // 打印"01"
console.log(result[3]); // 打印"25"这样很方便，但是可读性很差，且不易维护。一旦正则表达式中小括号的顺序有变化时，我们就需要更新对应的数字编号。
ES2018添加named capture groups, 可以指定小括号中匹配内容的名称，这样可以提高代码的可读性，也便于维护。
const pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/u;
const result = pattern.exec('2017-01-25');
console.log(result.groups.year); // 打印"2017"
console.log(result.groups.month); // 打印"01"
console.log(result.groups.day); // 打印"25"4. Unicode property escapes
这个特性已经在ECMAScript 2018正式发布了。
Unicode标准为每一个字符分配了多个属性。比如，当你要匹配希腊语字符时，则可以搜索Script_Extensions属性为Greek的字符。
Unicode property escapes使得我们可以使用ECMAScript正则表达式直接匹配Unicode字符的属性：
const regexGreekSymbol = /\p{Script_Extensions=Greek}/u;
console.log(regexGreekSymbol.test('π')); // 打印true5. String.prototype.matchAll
这个特性还处在Stage 3 Draft
g和y选项通常用于匹配一个字符串，然后遍历所有匹配的子串，包括小括号匹配的分组。String.prototype.matchAll让这个操作变得更加简单了。
const string = 'Magic hex numbers: DEADBEEF CAFE 8BADF00D';
const regex = /\b[0-9a-fA-F]+\b/g;
for (const match of string.matchAll(regex)) {
console.log(match);
}每一个迭代所返回的match对象与regex.exec(string)所返回的结果相同：
// Iteration 1:
[
'DEADBEEF',
index: 19,
input: 'Magic hex numbers: DEADBEEF CAFE 8BADF00D'
]
// Iteration 2:
[
'CAFE',
index: 28,
input: 'Magic hex numbers: DEADBEEF CAFE 8BADF00D'
]
// Iteration 3:
[
'8BADF00D',
index: 33,
input: 'Magic hex numbers: DEADBEEF CAFE 8BADF00D'
]注意，这个特性还处在Stage 3 Draft，因此还存在变化的可能性，示例代码是根据最新的提案写的。另外，浏览器也还没有支持这个特性。String.prototype.matchAll最快可以被加入到ECMAScript 2019中。
6. 规范RegExp遗留特性
这个提案还处在Stage 3 Draft
这个提案规范了RegExp的遗留特性，比如RegExp.prototype.compile方法以及它的静态属性从RegExp.到RegExp.。虽然这些特性已经弃用(deprecated)了，但是为了兼容性我们不能将他们去。因此，规范这些RegExp遗留特性是最好的方法。因此，这个提案有助于保证兼容性。
/**
* @param {string} path
* @returns {Boolean}
*/
export function isExternal(path) {
return /^(https?:|mailto:|tel:)/.test(path)
}
/**
* @param {string} str
* @returns {Boolean}
*/
export function validUsername(str) {
const valid_map = ['admin', 'editor']
return valid_map.indexOf(str.trim()) >= 0
}
/**
* @param {string} url
* @returns {Boolean}
*/
export function validURL(url) {
const reg = /^(https?|ftp):\/\/([a-zA-Z0-9.-]+(:[a-zA-Z0-9.&%$-]+)*@)*((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{2}))(:[0-9]+)*(\/($|[a-zA-Z0-9.,?'\\+&%$#=~_-]+))*$/
return reg.test(url)
}
/**
* @param {string} str
* @returns {Boolean}
*/
export function validLowerCase(str) {
const reg = /^[a-z]+$/
return reg.test(str)
}
/**
* @param {string} str
* @returns {Boolean}
*/
export function validUpperCase(str) {
const reg = /^[A-Z]+$/
return reg.test(str)
}
/**
* @param {string} str
* @returns {Boolean}
*/
export function validAlphabets(str) {
const reg = /^[A-Za-z]+$/
return reg.test(str)
}
/**
* @param {string} email
* @returns {Boolean}
*/
export function validEmail(email) {
const reg = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
return reg.test(email)
}
/**
* @param {string} str
* @returns {Boolean}
*/
export function isString(str) {
if (typeof str === 'string' || str instanceof String) {
return true
}
return false
}
/**
* @param {Array} arg
* @returns {Boolean}
*/
export function isArray(arg) {
if (typeof Array.isArray === 'undefined') {
return Object.prototype.toString.call(arg) === '[object Array]'
}
return Array.isArray(arg)
}
TS版
/**
* @param {string} path
* @returns {Boolean}
*/
export function isExternal(path) {
return /^(https?:|mailto:|tel:)/.test(path);
}
/**
* @param {string} str
* @returns {Boolean}
*/
export function validUsername(str) {
const valid_map = ['admin', 'editor'];
return valid_map.indexOf(str.trim()) >= 0;
}
/**
* @param {string} url
* @returns {Boolean}
*/
export function validURL(url) {
const reg =
/^(https?|ftp):\/\/([a-zA-Z0-9.-]+(:[a-zA-Z0-9.&%$-]+)*@)*((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{2}))(:[0-9]+)*(\/($|[a-zA-Z0-9.,?'\\+&%$#=~_-]+))*$/;
return reg.test(url);
}
/**
* @param {string} str
* @returns {Boolean}
*/
export function validLowerCase(str) {
const reg = /^[a-z]+$/;
return reg.test(str);
}
/**
* @param {string} str
* @returns {Boolean}
*/
export function validUpperCase(str) {
const reg = /^[A-Z]+$/;
return reg.test(str);
}
/**
* @param {string} str
* @returns {Boolean}
*/
export function validAlphabets(str) {
const reg = /^[A-Za-z]+$/;
return reg.test(str);
}
/**
* @param {string} email
* @returns {Boolean}
*/
export function validEmail(email) {
const reg =
/^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
return reg.test(email);
}
/**
* @param {string} phone
* @returns {Boolean}
*/
export function validPhone(phone) {
const reg = /^1[3-9][0-9]{9}$/;
return reg.test(phone);
}
/**
* @param {string} str
* @returns {Boolean}
*/
export function isString(str) {
if (typeof str === 'string' || str instanceof String) {
return true;
}
return false;
}
/**
* @param {Array} arg
* @returns {Boolean}
*/
export function isArray(arg) {
if (typeof Array.isArray === 'undefined') {
return Object.prototype.toString.call(arg) === '[object Array]';
}
return Array.isArray(arg);
}
// [修改]-新增-开始
/**
* 英文验证
* @param min
* @param max
* @param value
*/
export function english(value: string, min = 6, max = 12): boolean {
return new RegExp('^[a-z|A-Z]{' + min + ',' + max + '}$').test(value);
}
/**
* 中文验证
* @param min
* @param max
* @param value
*/
export function chinese(value: string, min = 2, max = 12): boolean {
return new RegExp('^[\u4e00-\u9fa5]{' + min + ',' + max + '}$').test(value);
}
/**
* 非中文
* @param value 内容
* @returns boolean
*/
export function notChinese(value: string): boolean {
return !/[\u4e00-\u9fa5]/.test(value);
}
/**
* 必需数字
* @param min
* @param max
* @param value
*/
export function number(value: string, min = 1, max = 20): boolean {
return new RegExp('^d{' + min + ',' + max + '}$').test(value);
}
/**
* 必需小数点最大值
* @param min
* @param max
* @param value
*/
export function precision(value: string, max = 8, precision = 8): boolean {
return new RegExp(
'(^[0-9]{1,' + max + '}$)|(^[0-9]{1,' + max + '}[.]{1}[0-9]{1,' + precision + '}$)',
).test(value);
}
/**
* 复杂密码验证
* @param value
*/
export function pwd(value: string): boolean {
if (value && value.length > 15) {
const en = /[a-z]/.test(value);
const num = /[0-9]/.test(value);
const daxie = /[A-Z]/.test(value);
const teshu = /[~!@#$%^&*()_+=-\[\]\\,.\/;':{}]/.test(value);
return en && num && daxie && teshu;
}
return false;
}
// [修改]-新增-结束
给大家分享我收集整理的各种学习资料，前端小白交学习流程，入门教程等回答-下面是学习资料参考。
前端学习交流、自学、学习资料等推荐 - 知乎
*请认真填写需求信息，我们会在24小时内与您取得联系。
