介绍#

正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为”元字符”），可以用来描述和匹配字符串的特定模式。

正则表达式是一种用于模式匹配和搜索文本的工具。

正则表达式提供了一种灵活且强大的方式来查找、替换、验证和提取文本数据。

正则表达式可以应用于各种编程语言和文本处理工具中，如 JavaScript、Python、Java、Perl 等。

1
// 从字符串 str 中提取数字部分的内容(匹配一次)：
2
var str = "abc123def";
3
var patt1 = /[0-9]+/;
4
document.write(str.match(patt1));

在线工具#

在线工具

正则表达式的模式#

正则表达式的模式可以包括以下内容：

• 字面值字符：例如字母、数字、空格等，可以直接匹配它们自身。
• 特殊字符：例如点号 .、星号 *、加号 +、问号 ? 等，它们具有特殊的含义和功能。
• 字符类：用方括号 包围的字符集合，用于匹配方括号内的任意一个字符。
• 元字符：例如 \d、\w、\s 等，用于匹配特定类型的字符，如数字、字母、空白字符等。
• 量词：例如 {n}、{n,}、{n,m} 等，用于指定匹配的次数或范围。
• 边界符号：例如 ^、$、\b、\B 等，用于匹配字符串的开头、结尾或单词边界位置。

正则表达式元字符和特性#

1. 字符匹配
   • 普通字符：普通字符按照字面意义进行匹配，例如匹配字母 “a” 将匹配到文本中的 “a” 字符。
   • 元字符：元字符具有特殊的含义，例如 \d 匹配任意数字字符，\w 匹配任意字母数字字符，. 匹配任意字符（除了换行符）等。
2. 量词
   • ：匹配前面的模式零次或多次。
   • +：匹配前面的模式一次或多次。
   • ?：匹配前面的模式零次或一次。
   • {n}：匹配前面的模式恰好 n 次。
   • {n,}：匹配前面的模式至少 n 次。
   • {n,m}：匹配前面的模式至少 n 次且不超过 m 次。
3. 字符类
   • [ ]：匹配括号内的任意一个字符。例如，[abc] 匹配字符 “a”、“b” 或 “c”。
   • [^ ]：匹配除了括号内的字符以外的任意一个字符。例如，[^abc] 匹配除了字符 “a”、“b” 或 “c” 以外的任意字符。
4. 边界匹配
   • ^：匹配字符串的开头。
   • $：匹配字符串的结尾。
   • \b：匹配单词边界。
   • \B：匹配非单词边界。
5. 分组和捕获
   • ( )：用于分组和捕获子表达式。
   • (?: )：用于分组但不捕获子表达式。
6. 特殊字符
   • \：转义字符，用于匹配特殊字符本身。
   • .：匹配任意字符（除了换行符）。
   • |：用于指定多个模式的选择。

为什么使用正则表达式？#

典型的搜索和替换操作要求您提供与预期的搜索结果匹配的确切文本。虽然这种技术对于对静态文本执行简单搜索和替换任务可能已经足够了，但它缺乏灵活性，若采用这种方法搜索动态文本，即使不是不可能，至少也会变得很困难。

通过使用正则表达式，可以：

• 测试字符串内的模式。 例如，可以测试输入字符串，以查看字符串内是否出现电话号码模式或信用卡号码模式。这称为数据验证。
• 替换文本。 可以使用正则表达式来识别文档中的特定文本，完全删除该文本或者用其他文本替换它。
• 基于模式匹配从字符串中提取子字符串。 可以查找文档内或输入域内特定的文本。

例如，您可能需要搜索整个网站，删除过时的材料，以及替换某些 HTML 格式标记。在这种情况下，可以使用正则表达式来确定在每个文件中是否出现该材料或该 HTML 格式标记。此过程将受影响的文件列表缩小到包含需要删除或更改的材料的那些文件。然后可以使用正则表达式来删除过时的材料。最后，可以使用正则表达式来搜索和替换标记。

应用领域#

目前，正则表达式已经在很多软件中得到广泛的应用，包括 *nix（Linux, Unix等）、HP 等操作系统，PHP、C#、Java 等开发环境，以及很多的应用软件中，都可以看到正则表达式的影子。

| 命令或环境 | . | [ ] | ^ | $ | ( ) | { } | ? | + | | | ( ) | | ---------- | - | --- | - | - | ----- | -------------------------------------------------------------------------------- | - | - | - | --- | | vi | √ | √ | √ | √ | √ | | | | | | | Visual C++ | √ | √ | √ | √ | √ | | | | | | | awk | √ | √ | √ | √ | | awk是支持该语法的，只是要在命令行加入 —posix or —re-interval参数即可，可见man awk中的interval expression | √ | √ | √ | √ | | sed | √ | √ | √ | √ | √ | √ | | | | | | delphi | √ | √ | √ | √ | √ | | √ | √ | √ | √ | | python | √ | √ | √ | √ | √ | √ | √ | √ | √ | √ | | java | √ | √ | √ | √ | √ | √ | √ | √ | √ | √ | | javascript | √ | √ | √ | √ | √ | | √ | √ | √ | √ | | php | √ | √ | √ | √ | √ | | | | | | | perl | √ | √ | √ | √ | √ | | √ | √ | √ | √ | | C# | √ | √ | √ | √ | | | √ | √ | √ | √ |

普通字符#

普通字符包括没有显式指定为元字符的所有可打印和不可打印字符。这包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号。

• [ABC] 匹配 […] 中的所有字符，例如 [aeiou] 匹配字符串 “google runoob taobao” 中所有的 e o u a 字母。
• [^ABC] 匹配除了 […] 中字符的所有字符，例如 [^aeiou] 匹配字符串 “google runoob taobao” 中除了 e o u a 字母的所有字符。
• [A-Z] [A-Z] 表示一个区间，匹配所有大写字母，[a-z] 表示所有小写字母
• . 匹配除换行符（\n、\r）之外的任何单个字符，相等于 [^\n\r]。
• [\s\S] 匹配所有。\s 是匹配所有空白符，包括换行，\S 非空白符，不包括换行。
• \w 匹配字母、数字、下划线。等价于 [A-Za-z0-9_]
• \d 匹配任意一个阿拉伯数字（0 到 9）。等价于 [0-9]

非打印字符#

非打印字符也可以是正则表达式的组成部分。下表列出了表示非打印字符的转义序列：

特殊字符#

所谓特殊字符，就是一些有特殊含义的字符，如上面说的 runoo*b 中的 *，简单的说就是表示任何字符串的意思。如果要查找字符串中的*符号，则需要对*进行转义，即在其前加一个\\，runo\\*ob匹配字符串runo*ob。

许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符”转义”，即，将反斜杠字符\ 放在它们前面。下表列出了正则表达式中的特殊字符：

限定符#

限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有 * 或 + 或 ? 或 {n} 或 {n,} 或 {n,m} 共6种。

正则表达式的限定符有：

• * 匹配前面的子表达式零次或多次。例如，zo_能匹配 “z” 以及 “zoo”。_ 等价于 {0,}。
• + 匹配前面的子表达式一次或多次。例如，zo+ 能匹配 “zo” 以及 “zoo”，但不能匹配 “z”。+ 等价于 {1,}。
• ? 匹配前面的子表达式零次或一次。例如，do(es)? 可以匹配 “do” 、 “does”、 “doxy” 中的 “do” 和 “does”。? 等价于 {0,1}。
• {n} n 是一个非负整数。匹配确定的 n 次。例如，o{2} 不能匹配 “Bob” 中的 o，但是能匹配 “food” 中的两个 o。
• {n,} n 是一个非负整数。至少匹配n 次。例如，o{2,}不能匹配”Bob”中的 o，但能匹配 “foooood”中的所有o。o{1,} 等价于 o+。o{0,}则等价于o*。
• {n,m} m 和 n 均为非负整数，其中 n <= m。最少匹配 n 次且最多匹配 m 次。例如，o{1,3} 将匹配 “fooooood” 中的前三个 o。o{0,1}等价于o?。请注意在逗号和两个数之间不能有空格。

* 和 + 限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个 ? 就可以实现非贪婪或最小匹配。

定位符#

定位符使您能够将正则表达式固定到行首或行尾。它们还使您能够创建这样的正则表达式，这些正则表达式出现在一个单词内、在一个单词的开头或者一个单词的结尾。

定位符用来描述字符串或单词的边界，^ 和 $ 分别指字符串的开始与结束，\b 描述单词的前或后边界，\B 表示非单词边界。

正则表达式的定位符有：

• ^ 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与 \n 或 \r 之后的位置匹配。
• $ 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与 \n 或 \r 之前的位置匹配。
• \b 匹配一个单词边界，即字与空格间的位置。
• \B 非单词边界匹配。

选择#

用圆括号 () 将所有选择项括起来，相邻的选择项之间用 | 分隔。

() 表示捕获分组，() 会把每个分组里的匹配的值保存起来， 多个匹配值可以通过数字 n 来查看(n 是一个数字，表示第 n 个捕获组的内容)。

但用圆括号会有一个副作用，使相关的匹配会被缓存，此时可用 ?: 放在第一个选项前来消除这种副作用。

其中 ?: 是非捕获元之一，还有两个非捕获元是 ?= 和 ?!，这两个还有更多的含义，前者为正向预查，在任何开始匹配圆括号内的正则表达式模式的位置来匹配搜索字符串，后者为负向预查，在任何开始不匹配该正则表达式模式的位置来匹配搜索字符串。

以下列出 ?=、?<=、?!、?<! 的使用区别

• exp1(?=exp2)：查找 exp2 前面的 exp1。
• (?<=exp2)exp1：查找 exp2 后面的 exp1。
• exp1(?!exp2)：查找后面不是 exp2 的 exp1。
• (?<!exp2)exp1：查找前面不是 exp2 的 exp1。

反向引用#

对一个正则表达式模式或部分模式两边添加圆括号将导致相关匹配存储到一个临时缓冲区中，所捕获的每个子匹配都按照在正则表达式模式中从左到右出现的顺序存储。缓冲区编号从1开始，最多可存储99个捕获的子表达式。每个缓冲区都可以使用\n访问，其中n为一个标识特定缓冲区的一位或两位十进制数。

可以使用非捕获元字符 ?:、?= 或 ?! 来重写捕获，忽略对相关匹配的保存。

反向引用的最简单的、最有用的应用之一，是提供查找文本中两个相同的相邻单词的匹配项的能力。

Is is the cost of of gasoline going up up?

上面的句子很显然有多个重复的单词。如果能设计一种方法定位该句子，而不必查找每个单词的重复出现，那该有多好。下面的正则表达式使用单个子表达式来实现这一点：

1
// 查找重复的单词：
2
var str = "Is is the cost of of gasoline going up up";
3
var patt1 = /\\b([a-z]+) \\1\\b/igm;
4
document.write(str.match(patt1));

捕获的表达式，正如 [a-z]+ 指定的，包括一个或多个字母。正则表达式的第二部分是对以前捕获的子匹配项的引用，即，单词的第二个匹配项正好由括号表达式匹配。\1指定第一个子匹配项。

单词边界元字符确保只检测整个单词。否则，诸如 “is issued” 或 “this is” 之类的词组将不能正确地被此表达式识别。

正则表达式后面的全局标记 g 指定将该表达式应用到输入字符串中能够查找到的尽可能多的匹配。

表达式的结尾处的不区分大小写 i 标记指定不区分大小写。

多行标记 m 指定换行符的两边可能出现潜在的匹配。

反向引用还可以将通用资源指示符 (URI) 分解为其组件。假定您想将下面的 URI 分解为协议（ftp、http 等等）、域地址和页/路径：

https://www.runoob.com:80/html/html-tutorial.html

下面的正则表达式提供该功能：

1
// 输出所有匹配的数据：
2
var str = "<https://www.runoob.com:80/html/html-tutorial.html>";
3
var patt1 = /(\\w+):\\/\\/([^/:]+)(:\\d*)?([^# ]*)/;
4
arr = str.match(patt1);
5
for (var i = 0; i < arr.length ; i++) {
6
    document.write(arr[i]);
7
    document.write("<br>");
8
}

第三行代码 str.match(patt1) 返回一个数组，实例中的数组包含 5 个元素，索引 0 对应的是整个字符串，索引 1 对应第一个匹配符（括号内），以此类推。

第一个括号子表达式捕获 Web 地址的协议部分。该子表达式匹配在冒号和两个正斜杠前面的任何单词。

第二个括号子表达式捕获地址的域地址部分。子表达式匹配非 : 和 / 之后的一个或多个字符。

第三个括号子表达式捕获端口号（如果指定了的话）。该子表达式匹配冒号后面的零个或多个数字。只能重复一次该子表达式。

最后，第四个括号子表达式捕获 Web 地址指定的路径和 / 或页信息。该子表达式能匹配不包括 # 或空格字符的任何字符序列。

将正则表达式应用到上面的 URI，各子匹配项包含下面的内容：

• 第一个括号子表达式包含 https
• 第二个括号子表达式包含 www.runoob.com
• 第三个括号子表达式包含 :80
• 第四个括号子表达式包含 /html/html-tutorial.html

基本模式匹配#

模式，是正则表达式最基本的元素，它们是一组描述字符串特征的字符。模式可以很简单，由普通的字符串组成，也可以非常复杂，往往用特殊的字符表示一个范围内的字符、重复出现，或表示上下文。

字符簇#

在 INTERNET 的程序中，正则表达式通常用来验证用户的输入。当用户提交一个 FORM 以后，要判断输入的电话号码、地址、EMAIL 地址、信用卡号码等是否有效，用普通的基于字面的字符是不够的。

所以要用一种更自由的描述我们要的模式的办法，它就是字符簇。

确定重复出现#

到现在为止，你已经知道如何去匹配一个字母或数字，但更多的情况下，可能要匹配一个单词或一组数字。一个单词有若干个字母组成，一组数字有若干个单数组成。跟在字符或字符簇后面的花括号({})用来确定前面的内容的重复出现的次数。

Introduction#

A regular expression is a text pattern that includes literal characters (for example, letters between a and z) and special characters (called metacharacters), and can be used to describe and match specific patterns in strings.

Regular expressions are a tool for pattern matching and searching text.

Regular expressions provide a flexible and powerful way to search, replace, validate, and extract text data.

Regular expressions can be applied in various programming languages and text-processing tools, such as JavaScript, Python, Java, Perl, etc.

1
// From the string str, extract the numeric part (match once):
2
var str = "abc123def";
3
var patt1 = /[0-9]+/;
4
document.write(str.match(patt1));

Online Tools#

Online tools

Regex Patterns#

Regex patterns can include the following:

• Literal characters: for example letters, digits, spaces, etc., which can be matched directly to themselves.
• Special characters: for example dot ., asterisk *, plus +, question ? etc., which have special meanings and functions.
• Character classes: a set of characters enclosed in square brackets, used to match any one character within the brackets.
• Metacharacters: such as \d, \w, \s, etc., used to match specific types of characters like digits, letters, whitespace, etc.
• Quantifiers: such as {n}, {n,}, {n,m}, used to specify the number of times to match or a range.
• Boundary symbols: such as ^, $, \b, \B, used to match the start, end of a string or word boundary positions.

Regex Metacharacters and Features#

1. Character matching
   • Literal characters: Literal characters are matched according to their literal meaning. For example, matching the letter “a” will match the “a” character in the text.
   • Metacharacters: Metacharacters have special meanings, for example, \d matches any digit character, \w matches any alphanumeric character, and . matches any character (except newline), etc.
2. Quantifiers
   • *: matches the preceding pattern zero or more times.
   • +: matches the preceding pattern one or more times.
   • ?: matches the preceding pattern zero or one time.
   • {n}: matches the preceding pattern exactly n times.
   • {n,}: matches the preceding pattern at least n times.
   • {n,m}: matches the preceding pattern at least n times and at most m times.
3. Character classes
   • [ ]: matches any one character within the brackets. For example, [abc] matches the characters “a”, “b”, or “c”.
   • [^ ]: matches any character not in the brackets. For example, [^abc] matches any character except “a”, “b”, or “c”.
4. Boundary matching
   • ^: matches the start of the string.
   • $: matches the end of the string.
   • \b: matches a word boundary.
   • \B: matches a non-word boundary.
5. Grouping and capturing
   • ( ): used for grouping and capturing subexpressions.
   • (?: ): used for grouping without capturing the subexpression.
6. Special characters
   • : escape character, used to match the special character itself.
   • .: matches any character (except newline).
   • |: used to specify a choice between multiple patterns.

Why Use Regular Expressions?#

Typical search-and-replace operations require you to provide literal text that matches the expected search result. While this technique may be sufficient for simple static text searches and replacements, it lacks flexibility; applying it to dynamic text can be difficult, if not impossible.

Using regular expressions, you can:

• Test patterns within strings. For example, test the input string to see whether a phone number pattern or a credit card number pattern appears. This is called data validation.
• Replace text. You can use regular expressions to identify specific text in a document, completely delete it, or replace it with other text.
• Extract substrings from strings based on patterns. You can search for particular text within a document or within an input field.

For example, you may need to search an entire website to remove outdated material and replace certain HTML formatting tags. In this case, you can use regular expressions to determine whether the material or HTML formatting tags appear in each file. This process narrows the list of affected files to those that contain the material to be deleted or changed. You can then use regular expressions to delete the outdated material. Finally, you can use regular expressions to search and replace the tags.

Applications#

Today, regular expressions have been widely used in many software environments, including *nix (Linux, Unix, etc.), HP operating systems, PHP, C#, Java development environments, and many applications where you can see the shadow of regular expressions.

| Command or Environment | . | [ ] | ^ | $ | ( ) | { } | ? | + | | | ( ) | | ---------- | - | --- | - | - | ----- | -------------------------------------------------------------------------------- | - | - | - | --- | | vi | √ | √ | √ | √ | √ | | | | | | | Visual C++ | √ | √ | √ | √ | √ | | | | | | | awk | √ | √ | √ | √ | | awk supports this syntax; just add —posix or —re-interval on the command line, see interval expression in the man page for awk | √ | √ | √ | √ | | sed | √ | √ | √ | √ | √ | √ | | | | | | delphi | √ | √ | √ | √ | √ | | √ | √ | √ | √ | | python | √ | √ | √ | √ | √ | | √ | √ | √ | √ | | java | √ | √ | √ | √ | √ | | √ | √ | √ | √ | | javascript | √ | √ | √ | √ | √ | | √ | √ | √ | √ | | php | √ | √ | √ | √ | √ | | | | | | | perl | √ | √ | √ | √ | √ | | √ | √ | √ | √ | | C# | √ | √ | √ | √ | | | √ | √ | √ | √ |

Ordinary characters#

Ordinary characters include all printable and non-printable characters that are not explicitly specified as metacharacters. This includes all upper- and lower-case letters, all digits, all punctuation marks, and some other symbols.

• [ABC] Matches any of the characters inside the brackets; for example, [aeiou] matches the letters e, o, u, a in the string “google runoob taobao”.
• [^ABC] Matches any character except the ones inside the brackets; for example, [^aeiou] matches any character in the string “google runoob taobao” except the letters e, o, u, a.
• [A-Z] [A-Z] denotes a range, matching all uppercase letters; [a-z] denotes all lowercase letters.
• . Matches any single character except newline ( \n or \r ), equivalent to [^\n\r].
• [\s\S] Matches any character. \s matches any whitespace, including newline; \S matches non-whitespace, not including newline.
• \w Matches letters, digits, and underscore. Equivalent to [A-Za-z0-9_].
• \d Matches any Arabic digit (0 to 9). Equivalent to [0-9].

Non-printable characters#

Non-printable characters can also be parts of a regex. The following table lists escape sequences that represent non-printable characters:

Special characters#

Special characters are those with special meanings, such as the * in runoob above. In simple terms, they denote any string. If you want to search for the literal '' symbol in a string, you need to escape it by preceding it with a backslash, i.e., runo\ob matches the string runoob.

Many metacharacters require special treatment when attempting to match them. To match these special characters, you must first escape the character by placing a backslash in front of them. The following table lists the special characters in regular expressions:

Quantifiers#

Quantifiers specify how many times a given component of the regex must appear to satisfy a match. There are six kinds: *, +, ?, {n}, {n,}, and {n,m}.

The regex quantifiers are:

• Matches the preceding subexpression zero or more times. For example, zo_ can match “z” and “zoo”. _ is equivalent to {0,}.
• Matches the preceding subexpression one or more times. For example, zo+ can match “zo” and “zoo”, but not “z”. + is equivalent to {1,}.
• ? Matches the preceding subexpression zero or one time. For example, do(es)? can match “do” and “does” and “doxy”. ? is equivalent to {0,1}.
• {n} n is a non-negative integer. Matches exactly n times. For example, o{2} cannot match the two o’s in “Bob”, but can match the two o’s in “food”.
• {n,} n is a non-negative integer. At least n times. For example, o{2,} cannot match the o’s in “Bob”, but can match all the o’s in “foooood”. o{1,} is equivalent to o+. o{0,} is equivalent to o*.
• {n,m} m and n are non-negative integers with n <= m. Matches at least n times and at most m times. For example, o{1,3} will match the first three o’s in “fooooood”. o{0,1} is equivalent to o?. Note there should be no spaces between the comma and the numbers.

The * and + quantifiers are greedy, because they will match as much text as possible; adding a ? after them makes the matching non-greedy or minimal.

紹介#

正規表現（Regular Expression）は、テキストパターンであり、通常文字（例えば英字の a から z までの文字）と特殊文字（「メタ文字」と呼ばれる）を含み、文字列の特定のパターンを記述・一致させるために使用します。

正規表現は、パターンマッチングとテキスト検索に用いられるツールです。

正規表現は、テキストデータの検索・置換・検証・抽出を行う柔軟で強力な方法を提供します。

正規表現は、JavaScript、Python、Java、Perl など、さまざまなプログラミング言語やテキスト処理ツールに応用できます。

1
// 从字符串 str 中提取数字部分的内容(匹配一次)：
2
var str = "abc123def";
3
var patt1 = /[0-9]+/;
4
document.write(str.match(patt1));

オンラインツール#

オンラインツール

正規表現のパターン#

正規表現のパターンは以下の内容を含むことができます：

• リテラル文字：例えば文字、数字、空白など、それらを自身と直接一致させます。
• 特殊文字：例えばドット .、アスタリスク *、プラス記号 +、クエスチョンマーク ? など、それらには特別な意味と機能があります。
• 文字クラス：角括弧 [] で囲まれた文字集合で、括弧内のいずれかの文字と一致させます。
• メタ文字：例えば \d、\w、\s など、数字、英字・数字・アンダースコア、空白文字などの特定のタイプの文字に一致させます。
• 量詞：例えば {n}、{n,}、{n,m} など、マッチの回数や範囲を指定します。
• 境界記号：例えば ^、$、\b、\B など、文字列の先頭・末尾・単語境界の位置に一致させます。

正規表現元字符と特性#

1. 文字マッチ
   • 普通文字：普通文字は文字通りにマッチします。例えば文字 “a” にマッチすると、テキスト中の “a” に一致します。
   • メタ文字：メタ文字は特殊な意味を持ちます。例えば \d は任意の数字、\w は英数字とアンダースコア、. は改行を除く任意の文字などです。
2. 量詞
   • *：前のパターンを0回以上マッチします。
   • +：前のパターンを1回以上マッチします。
   • ?：前のパターンを0回または1回マッチします。
   • {n}：前のパターンをちょうど n 回マッチします。
   • {n,}：前のパターンを少なくとも n 回マッチします。
   • {n,m}：前のパターンを少なくとも n 回、最大で m 回マッチします。
3. 文字クラス
   • [ ]：括弧内の任意の1文字に一致します。例えば [abc] は ‘a’、‘b’、または ‘c’ に一致します。
   • [^ ]：括弧内の文字以外の任意の1文字に一致します。
4. 境界マッチ
   • ^：文字列の先頭に一致します。
   • $：文字列の末尾に一致します。
   • \b：単語境界に一致します。
   • \B：非単語境界に一致します。
5. グループ化とキャプチャ
   • ( )：グループ化とサブ式のキャプチャに使用します。
   • (?: )：キャプチャを行わずにグループ化する非捕獲グループです。
6. 特殊文字
   • \：特殊文字自体をマッチさせるためのエスケープ文字です。
   • .：改行を除く任意の1文字にマッチします。
   • |：複数のパターンのいずれかを選択します。

为什么使用正则表达式？#

典型的な検索・置換操作では、期待する検索結果と厳密に一致するテキストを提供する必要があります。この技術は静的なテキストに対しては簡単な検索・置換タスクには十分かもしれませんが、柔軟性に欠け、動的なテキストを検索するときは困難になります。

正規表現を使用することで、次のことが可能になります：

• 文字列内のパターンをテストする。 例えば、入力文字列に電話番号パターンやクレジットカード番号パターンが現れるかを検証します。これをデータ検証と呼びます。
• テキストを置換する。 正規表現を用いて文書内の特定のテキストを識別し、そのテキストを完全に削除するか、別のテキストに置換します。
• パターンマッチに基づいて文字列からサブ文字列を抽出する。 文書内や入力フィールド内の特定のテキストを探します。

例えば、サイト全体を検索して古い素材を削除し、いくつかの HTML フタグを置換する必要がある場合、正規表現を用いてファイルごとにその素材や HTML フタグが現れるかを特定できます。これにより、対象ファイルのリストを削減し、次に正規表現を使って古い素材を削除します。最後に、正規表現を使ってタグを検索・置換します。

アプリケーション領域#

現在、正規表現は多くのソフトウェアで広く利用されています。Unix系（Linux、Unix など）、HP などのオペレーティングシステム、PHP、C#、Java などの開発環境、および多くのアプリケーションソフトウェアに正規表現の影子を見ることができます。

| コマンドや環境 | . | [ ] | ^ | $ | ( ) | { } | ? | + | | | ( ) | | ---------- | - | --- | - | - | ----- | -------------------------------------------------------------------------------- | - | - | - | --- | | vi | √ | √ | √ | √ | √ | | | | | | | Visual C++ | √ | √ | √ | √ | √ | | | | | | | awk | √ | √ | √ | √ | | awkは支持该语法，只是在命令行加入 —posix or —re-interval 参数即可，可见man awk中的interval expression | √ | √ | √ | √ | | sed | √ | √ | √ | √ | √ | √ | | | | | | delphi | √ | √ | √ | √ | √ | | √ | √ | √ | √ | | python | √ | √ | √ | √ | √ | √ | √ | √ | √ | √ | | java | √ | √ | √ | √ | √ | √ | √ | √ | √ | √ | | javascript | √ | √ | √ | √ | √ | | √ | √ | √ | √ | | php | √ | √ | √ | √ | √ | | | | | | | perl | √ | √ | √ | √ | √ | | √ | √ | √ | √ | | C# | √ | √ | √ | √ | | | √ | √ | √ | √ |

普通文字#

普通文字には、メタ文字として明示的に指定されていないすべての可視・不可視文字が含まれます。これには、すべての大文字・小文字の英字、すべての数字、すべての句読点、その他の記号が含まれます。

• [ABC]
  • 複合クラス内のすべての文字に一致します。例えば、[aeiou] は文字列 “google runoob taobao” の中の e、o、u、a の文字すべてに一致します。
• [^ABC]
  • 複合クラス内の文字を除くすべての文字に一致します。例えば、[^aeiou] は文字列 “google runoob taobao” の中の e、o、u、a 以外のすべての文字に一致します。
• [A-Z]
  • [A-Z] は1つのレンジを表し、大文字アルファベット全体に一致します。 [a-z] は小文字全体を表します。
• .
  • 改行文字（\n、\r）を除く任意の1文字に一致します。これは [^\n\r] と同等です。
• [\s\S]
  • すべてに一致します。 \s は空白文字全体に、改行を含み、\S は非空白文字で、改行を含みません。
• \w
  • 英字・数字・アンダースコアに一致します。等価には [A-Za-z0-9_]。
• \d
  • アラビア数字（0 から 9）に一致します。等価には [0-9]。

非表示文字#

非表示文字も正規表現の構成要素として現れ得ます。下表は不可視文字を表すエスケープシーケンスを示します：

特殊字符#

いわゆる特殊文字とは、上記の runoob のように特別な意味を持つ文字のことです。単純に言えば、任意の文字列を表すことがあります。文字列中の '' 記号を検索する場合は、エスケープする必要があります。つまり、“runo*ob” は「runo*ob」という文字列に一致します。

多くのメタ文字は、マッチさせる際に特別扱いが必要です。これらの特殊文字をマッチさせたい場合は、まず文字を「エスケープ」します。つまり、バックスラッシュ \ を前に置きます。以下の表は正規表現での特殊文字を列挙します：

限定符#

限定符は、正規表現の特定の要素がマッチするために何回現れるべきかを指定します。* や + や ? や {n} や {n,} や {n,m} の6種類があります。

正規表現の限定符は：

• *
  前のサブ表現を0回以上マッチします。例えば、zo* は “z” あるいは “zoo” にマッチします。_ は {0,} に相当します。
• +
  前のサブ表現を1回以上マッチします。例えば、zo+ は “zo” あるいは “zoo” にマッチします。+ は {1,} に相当します。
• ?
  前のサブ表現を0回または1回マッチします。例えば、do(es)? は “do”、“does”、“doxy” の “do” と “does” にマッチします。? は {0,1} に相当します。
• {n}
  n は非負整数。前のパターンをちょうど n 回マッチします。例えば、o{2} は “Bob” の中の “oo” にはマッチしませんが、“food” の中の “oo” にはマッチします。
• {n,}
  n は非負整数。少なくとも n 回マッチします。例えば、o{2,} は “Bob” の中の o にはマッチしませんが、“foooood” のすべての o にはマッチします。o{1,} は o+ に、o{0,} は o* に相当します。
• {n,m}
  m と n はともに非負整数で、n <= m。最小で n 回、最大で m 回マッチします。例えば、o{1,3} は “fooooood” の先頭の3つの o にマッチします。o{0,1} は o? に相当します。カンマの後の数値同士の間にはスペースを入れないでください。

• と + の限定符は共に貪欲です。可能な限り多くの文字とマッチします。これに対して、後ろに ? を付けると非貪欲（最小マッチ）になります。

定位符#

定位符（アンカー）は、正規表現を行の先頭または末尾に固定するために使用します。また、単語内、単語の先頭、あるいは単語の末尾に現れるような正規表現を作成することも可能にします。

定位符は文字列や単語の境界を記述します。^ と $ はそれぞれ文字列の開始と終了を示し、\b は単語の前後の境界、\B は非単語境界を表します。

正規表現の定位符は：

• ^
  入力文字列の開始位置に一致します。RegExp オブジェクトの Multiline 属性が設定されている場合、^ は \n や \r の後の位置にも一致します。
• $
  入力文字列の末尾位置に一致します。RegExp オブジェクトの Multiline 属性が設定されている場合、$ は \n や \r の前の位置にも一致します。
• \b
  単語境界に一致します。すなわち、単語と空白の間の位置です。
• \B
  非単語境界に一致します。

選択#

丸括弧 () で全ての選択肢を囲み、隣接する選択肢は | で区切ります。

() はキャプチャグループを表し、各グループ内の一致した値を保存します。複数のマッチ値は数字 n で参照できます（n は数字で、n 番目のキャプチャグループの内容を指します）。

ただし丸括弧を使うと副作用として関連するマッチがキャッシュされます。この副作用を解消するには、先頭に ?: を付けて非キャプチャにします。

?: は非捕獲元の1つで、他にも ?= および ?! という2つの非捕獲元があります。これらにはさらに意味があり、前者は正向先読みで、先にマッチする正規表現パターンの位置で検索文字列をマッチさせます。後者は後方先読みで、マッチしていない正規表現パターンの位置で検索文字列をマッチさせます。

以下は ?=、?<=、?!、?<! の使用区別です。

• exp1(?=exp2)：exp2 の前の exp1 を探します。
• (?<=exp2)exp1：exp2 の後の exp1 を探します。
• exp1(?!exp2)：exp2 でない後ろの exp1 を探します。
• (?<!exp2)exp1：exp2 でない前の exp1 を探します。

反向引用#

正規表現のパターンまたは部分パターンの両側に括弧を追加すると、関連するマッチが一時バッファに格納されます。捕捉された各サブマッチは、正規表現パターンの左から右へ現れる順序で格納されます。バッファ番号は1から始まり、最大99個の捕捉サブ表現を格納できます。各バッファには \n でアクセスできますが、n は特定のバッファを識別する1桁または2桁の十進数です。

非捕獲元?:、?=、?! を使用して、キャプチャを回避し、対応するマッチを保存しないように書き換えることができます。

後方参照の最も基本的で有用な応用の1つは、テキスト内の2つの同じ隣接する単語をマッチさせる機能を提供することです。

Is is the cost of of gasoline going up up?

上の文には明らかに複数の繰り返し単語があります。この文を特定する方法を設計して、各単語の繰り返しを1つずつ探さなくてもよいとしたら、どれだけいいでしょう。以下の正規表現は、単一のサブ表現を使ってこれを実現します：

1
// 查找重复的单词：
2
var str = "Is is the cost of of gasoline going up up";
3
var patt1 = /\\b([a-z]+) \\1\\b/igm;
4
document.write(str.match(patt1));

捕捉された表現は、[a-z]+ が指定するように、1つ以上の文字を含みます。正規表現の第二部は、以前に捕捉されたサブマッチの参照であり、単語の2つ目のマッチはちょうど括弧式に一致します。\1 は最初のサブマッチを指定します。

単語境界メタ文字は、単語全体のみを検出することを保証します。そうでない場合、“is issued” や “this is” のような語句は、この式では正しく認識されません。

正規表現の後ろにつく global 修飾子 g は、この式を入力文字列に適用して、可能な限り多くの一致を見つけることを指定します。

式の末尾の i 修飾子は、大文字・小文字を区別しないことを指定します。

multiline 修飾子 m は、改行文字の両側に潜在的なマッチが現れることを指定します。

反向引用はまた、一般的な URI 指定子を分解して成分にします。以下の URI を、プロトコル（ftp、http など）、ドメイン、ページ/パスに分解したいとします：

https://www.runoob.com:80/html/html-tutorial.html

以下の正規表現はこの機能を提供します：

1
// 输出所有匹配的数据：
2
var str = "<https://www.runoob.com:80/html/html-tutorial.html>";
3
var patt1 = /(\\w+):\\/\\/([^/:]+)(:\\d*)?([^# ]*)/;
4
arr = str.match(patt1);
5
for (var i = 0; i < arr.length ; i++) {
6
    document.write(arr[i]);
7
    document.write("<br>");
8
}

第三行代码 str.match(patt1) は配列を返します。例の配列には5つの要素が含まれ、インデックス 0 は全体の文字列、インデックス 1 は最初のマッチ（括弧内）に対応します。以降も同様です。

最初の括弧のサブ表現は Web アドレスのプロトコル部分をキャプチャします。このサブ表現はコロンと2つのスラッシュの前の任意の単語に一致します。

2番目の括弧のサブ表現は住所のドメイン部分をキャプチャします。サブ表現は「:」と「/」の後ではない、1つ以上の文字に一致します。

3番目の括弧のサブ表現はポート番号をキャプチャします（指定されている場合）。このサブ表現はコロンの後の0個以上の数字に一致します。これを1回だけ繰り返します。

最後に、4番目の括弧のサブ表現は Web アドレスが指定するパスと/またはページ情報をキャプチャします。このサブ表現は「#」または空白文字を含まない任意の文字列に一致します。

正規表現を上記の URI に適用すると、各サブマッチには以下が含まれます：

• 最初の括弧のサブ表現には https
• 2 番目の括弧のサブ表現には www.runoob.com
• 3 番目の括弧のサブ表現には :80
• 4 番目の括弧のサブ表現には /html/html-tutorial.html

基本パターンマッチ#

パターンは正規表現の最も基本的な要素であり、文字列の特徴を記述する文字の集合です。パターンは、単純な文字列から成ることもあれば、非常に複雑で、特殊文字を用いて特定の範囲内の文字、繰り返し、あるいは文脈を表すこともあります。

文字簇#

INTERNET のプログラムでは、正規表現は通常、ユーザーの入力を検証するために使用されます。ユーザーがフォームを送信した後、入力された電話番号、住所、EMAIL アドレス、クレジットカード番号などが有効かどうかを判断するには、通常のリテラル文字だけでは足りません。

そこで、求めるパターンをより自由に表現する方法として、文字簇を用います。

確定的な繰り返し#

ここまでで、1文字または数字をマッチさせる方法は分かりましたが、多くの場合、単語や数字の列をマッチさせる必要があります。単語は複数の文字で構成され、数字の列は複数の数字で構成されます。文字または文字簇の後に続く波括弧（{}）は、前の内容が繰り返される回数を決定します。