详解正则表达式：全面教程

需积分: 10 134 浏览量更新于2024-07-23 收藏 920KB PDF 举报

正则表达式完全指南是Jan Goyvaerts编写的权威教程，它深入探讨了这一强大的文本处理工具。正则表达式（regex 或者简称为regexp）是一种特殊文本字符串，用于描述复杂的搜索模式，可以被视作增强版的通配符。它们在日常工作中广泛应用于文件搜索、数据验证、文本分析等领域。在理解正则表达式之前，我们先熟悉一些基本概念。1. **字面字符**：这些是最基础的元素，例如，"." 表示匹配任何单个字符，"*" 代表前面的字符可重复零次或多次。2. **第一眼看正则引擎的工作原理**：正则表达式并非直接与文本逐字符匹配，而是通过内部解析器来构建模式，引擎会在输入文本中查找匹配这些模式的部分。 3. **字符类**或"[]": 这部分允许我们指定一组特定字符进行匹配，如 "[abc]" 会匹配 "a", "b", 或 "c"。此外，还可以使用范围和排除符号，如 "[a-z]" 匹配所有小写字母，"[^a-z]" 则匹配除了小写字母之外的任何字符。 4. **元字符**：正则表达式中有一些特殊字符具有特殊的含义，比如 "\d" 表示数字，"\w" 包含字母、数字和下划线，"\s" 代表空白字符。这些元字符可以帮助我们编写更复杂且灵活的模式。 5. **量词和重复**： "+" 表示前面的字符至少出现一次，"*" 表示零次或多次，而 "?" 则是可选一次。组合使用时，如 "a+?"，允许一个或多个"a"，但只会匹配一个。 6. **分组和引用**：圆括号 "( )" 用于创建分组，方便后续提取或重复操作。回头引用，如 "\1"，用于匹配前面相同组的文本。 7. **锚点和边界**： "^" 和 "$" 分别表示行首和行尾，确保匹配的是整个字符串。`\b` 是单词边界，只匹配单词的开始或结束。 8. **选择和分支**："|" 可以用来表示“或”关系，例如 "cat|dog" 会匹配 "cat" 或 "dog"。 9. **正则表达式的语法和标志**：不同的编程语言可能支持不同的正则语法和标志，例如Perl、JavaScript、Python等，了解这些差异对于实际应用至关重要。正则表达式完全指南不仅介绍了基本概念，还涵盖了高级主题，如零宽度断言、预查、反向引用等。通过学习和实践，掌握正则表达式能极大提升文本处理和数据挖掘的效率。然而，正如版权页所述，本书的内容不能未经许可进行复制或传播，而且作者不承担因使用信息导致的任何损失或责任。要深入了解，请访问官方网站 <http://www.regular-expressions.info/print.html> 获取完整教程。

most flavors, it also includes a carriage return or a line feed as in «

[ \t\r\n]». Some flavors include

additional, rarely used non-printable characters such as vertical tab and form feed.

Shorthand character classes can be used both inside and outside the square brackets. «

\s\d» matches a

whitespace character followed by a digit. «

[\s\d]» matches a single character that is either whitespace or a

digit. When applied to “

1 + 2 = 3”, the former regex will match „ 2” (space two), while the latter matches

„

1” (one). «[\da-fA-F]» matches a hexadecimal digit, and is equivalent to «[0-9a-fA-F]».

Negated Shorthand Character Classes

The above three shorthands also have negated versions. «\D» is the same as «[^\d]», «\W» is short for

[^\w]» and «\S» is the equivalent of «[^\s]».

Be careful when using the negated shorthands inside square brackets. «

[\D\S]» is not the same as «[^\d\s]».

The latter will match any character that is not a digit or whitespace. So it will match „

x”, but not “8”. The

former, however, will match any character that is either not a digit, or is not whitespace. Because a digit is not

whitespace, and whitespace is not a digit, «

[\D\S]» will match any character, digit, whitespace or otherwise.

Repeating Character Classes

If you repeat a character class by using the «?», «*» or «+» operators, you will repeat the entire character class,

and not just the character that it matched. The regex «

[0-9]+» can match „837” as well as „222”.

If you want to repeat the matched character, rather than the class, you will need to use backreferences. «

([0-

9])\1+

» will match „222” but not “837”. When applied to the string “833337”, it will match „3333” in the

middle of this string. If you do not want that, you need to use lookahead and lookbehind.

But I digress. I did not yet explain how character classes work inside the regex engine. Let us take a look at

that first.

Looking Inside The Regex Engine

As I already said: the order of the characters inside a character class does not matter. «gr[ae]y» will match

„

grey” in “Is his hair grey or gray?”, because that is the leftmost match. We already saw how the

engine applies a regex consisting only of literal characters. Below, I will explain how it applies a regex that has

more than one permutation. That is: «

gr[ae]y» can match both „gray” and „grey”.

Nothing noteworthy happens for the first twelve characters in the string. The engine will fail to match «

g» at

every step, and continue with the next character in the string. When the engine arrives at the 13th character,

„

g” is matched. The engine will then try to match the remainder of the regex with the text. The next token in

the regex is the literal «

r», which matches the next character in the text. So the third token, «[ae]» is

attempted at the next character in the text (“

e”). The character class gives the engine two options: match «a»

or match «

e». It will first attempt to match «a», and fail.

But because we are using a regex-directed engine, it must continue trying to match all the other permutations

of the regex pattern before deciding that the regex cannot be matched with the text starting at character 13.

5. The Dot Matches (Almost) Any Character

In regular expressions, the dot or period is one of the most commonly used metacharacters. Unfortunately, it

is also the most commonly misused metacharacter.

The dot matches a single character, without caring what that character is. The only exception are

newlinecharacters. In all regex flavors discussed in this tutorial, the dot will not match a newline character by

default. So by default, the dot is short for the negated character class «

[^\n]» (UNIX regex flavors) or

[^\r\n]» (Windows regex flavors).

This exception exists mostly because of historic reasons. The first tools that used regular expressions were

line-based. They would read a file line by line, and apply the regular expression separately to each line. The

effect is that with these tools, the string could never contain newlines, so the dot could never match them.

Modern tools and languages can apply regular expressions to very large strings or even entire files. All regex

flavors discussed here have an option to make the dot match all characters, including newlines. In

RegexBuddy, EditPad Pro or PowerGREP, you simply tick the checkbox labeled “dot matches newline”.

In Perl, the mode where the dot also matches newlines is called "single-line mode". This is a bit unfortunate,

because it is easy to mix up this term with “multi-line mode”. Multi-line mode only affects anchors, and

single-line mode only affects the dot. You can activate single-line mode by adding an s after the regex code,

like this:

m/^regex$/s;.

Other languages and regex libraries have adopted Perl’s terminology. When using the regex classes of the

.NET framework, you activate this mode by specifying

RegexOptions.Singleline, such as in

Regex.Match("string", "regex", RegexOptions.Singleline).

In all programming languages and regex libraries I know, activating single-line mode has no effect other than

making the dot match newlines. So if you expose this option to your users, please give it a clearer label like

was done in RegexBuddy, EditPad Pro and PowerGREP.

JavaScript and VBScript do not have an option to make the dot match line break characters. In those

languages, you can use a character class such as «

[\s\S]» to match any character. This character matches a

character that is either a whitespace character (including line break characters), or a character that is not a

whitespace character. Since all characters are either whitespace or non-whitespace, this character class

matches any character.

Use The Dot Sparingly

The dot is a very powerful regex metacharacter. It allows you to be lazy. Put in a dot, and everything will

match just fine when you test the regex on valid data. The problem is that the regex will also match in cases

where it should not match. If you are new to regular expressions, some of these cases may not be so obvious

at first.

I will illustrate this with a simple example. Let’s say we want to match a date in mm/dd/yy format, but we

want to leave the user the choice of date separators. The quick solution is «

\d\d.\d\d.\d\d». Seems fine at

first. It will match a date like „

02/12/03” just fine. Trouble is: „02512703” is also considered a valid date by

this regular expression. In this match, the first dot matched „

5”, and the second matched „7”. Obviously not

what we intended.

\d\d[- /.]\d\d[- /.]\d\d» is a better solution. This regex allows a dash, space, dot and forward slash

as date separators. Remember that the dot is not a metacharacter inside a character class, so we do not need

to escape it with a backslash.

This regex is still far from perfect. It matches „

99/99/99” as a valid date. «[0-1]\d[- /.][0-3]\d[-

/.]\d\d

» is a step ahead, though it will still match „19/39/99”. How perfect you want your regex to be

depends on what you want to do with it. If you are validating user input, it has to be perfect. If you are

parsing data files from a known source that generates its files in the same way every time, our last attempt is

probably more than sufficient to parse the data without errors. You can find a better regex to match dates in

the example section.

Use Negated Character Sets Instead of the Dot

I will explain this in depth when I present you the repeat operators star and plus, but the warning is important

enough to mention it here as well. I will illustrate with an example.

Suppose you want to match a double-quoted string. Sounds easy. We can have any number of any character

between the double quotes, so «

".*"» seems to do the trick just fine. The dot matches any character, and the

star allows the dot to be repeated any number of times, including zero. If you test this regex on “

Put a

"string" between double quotes

”, it will match „"string"” just fine. Now go ahead and test it on

“

Houston, we have a problem with "string one" and "string two". Please respond.”

Ouch. The regex matches „

"string one" and "string two"”. Definitely not what we intended. The

reason for this is that the star is greedy.

In the date-matching example, we improved our regex by replacing the dot with a character class. Here, we

will do the same. Our original definition of a double-quoted string was faulty. We do not want any number of

any character between the quotes. We want any number of characters that are not double quotes or newlines

between the quotes. So the proper regex is «

"[^"\r\n]*"».

6. Start of String and End of String Anchors

Thus far, I have explained literal characters and character classes. In both cases, putting one in a regex will

cause the regex engine to try to match a single character.

Anchors are a different breed. They do not match any character at all. Instead, they match a position before,

after or between characters. They can be used to “anchor” the regex match at a certain position. The caret «

^»

matches the position before the first character in the string. Applying «

^a» to “abc” matches „a”. «^b» will

not match “

abc” at all, because the «b» cannot be matched right after the start of the string, matched by «^».

See below for the inside view of the regex engine.

Similarly, «

$» matches right after the last character in the string. «c$» matches „c” in “abc”, while «a$» does

not match at all.

Useful Applications

When using regular expressions in a programming language to validate user input, using anchors is very

important. If you use the code

if ($input =~ m/\d+/) in a Perl script to see if the user entered an integer

number, it will accept the input even if the user entered “

qsdf4ghjk”, because «\d+» matches the 4. The

correct regex to use is «

^\d+$». Because “start of string” must be matched before the match of «\d+», and

“end of string” must be matched right after it, the entire string must consist of digits for «

^\d+$» to be able

to match.

It is easy for the user to accidentally type in a space. When Perl reads from a line from a text file, the line

break will also be stored in the variable. So before validating input, it is good practice to trim leading and

trailing whitespace. «

^\s+» matches leading whitespace and «\s+$» matches trailing whitespace. In Perl, you

could use

$input =~ s/^\s+|\s+$//g. Handy use of alternation and /g allows us to do this in a single

line of code.

Using ^ and $ as Start of Line and End of Line Anchors

If you have a string consisting of multiple lines, like “first line\nsecond line” (where \n indicates a

line break), it is often desirable to work with lines, rather than the entire string. Therefore, all the regex

engines discussed in this tutorial have the option to expand the meaning of both anchors. «

^» can then match

at the start of the string (before the “

f” in the above string), as well as after each line break (between “\n”

and “

s”). Likewise, «$» will still match at the end of the string (after the last “e”), and also before every line

break (between “

e” and “\n”).

In text editors like EditPad Pro or GNU Emacs, and regex tools like PowerGREP, the caret and dollar

always match at the start and end of each line. This makes sense because those applications are designed to

work with entire files, rather than short strings.

In all programming languages and libraries discussed in this book , except Ruby, you have to explicitly

activate this extended functionality. It is traditionally called "multi-line mode". In Perl, you do this by adding

an m after the regex code, like this:

m/^regex$/m;. In .NET, the anchors match before and after newlines

when you specify

RegexOptions.Multiline, such as in Regex.Match("string", "regex",

RegexOptions.Multiline)

剩余196页未读，继续阅读

gwd727

粉丝: 0
资源: 1

详解正则表达式：全面教程

Python正则表达式操作指南%2B-%2BUbuntu中文.pdf

完全自动的正则表达式编写工具

Python正则表达式完全指南

JavaScript正则表达式完全指南

JS正则表达式完全指南

JAVA正则表达式完全指南

(源码)基于QT框架的云存储系统.zip

2010-2023国自科立项名单管理学部.xlsx

二、现有一份上市企业年度财务报告文本中管理层讨论与分析文本大数据，请测度以下相关的数据(60分)

多个SVCTTS的C推理库.zip

最新资源