全面掌握正则表达式：多语言模块详解

需积分: 9 90 浏览量更新于2024-07-19 收藏 792KB PDF 举报

正则表达式 Regular Expressions 是一种强大的文本处理工具，用于在各种编程语言中进行模式匹配、搜索和替换操作。本教程深入介绍了正则表达式的概念、工作原理以及在Java、JavaScript、MySQL、C#、Perl、PHP、Python、Ruby、VB、VBScript和XML等编程语言中的应用。 **1. 正则表达式基础** - **教程1：正则表达式概论** - 开篇部分会提供一个全面的介绍，让你理解正则表达式的概念，包括它们是如何被设计用来识别和操作文本模式的。 **2. 字面字符** - 在这一章节，你将学习如何编写和使用基本的字符，如字母、数字、特殊字符等，这些是构成正则表达式的基本单元。了解如何匹配特定字符及其转义规则至关重要。 **3. 正则引擎内部工作原理** - 这一部分解释了正则表达式引擎的工作机制，它如何解析输入的模式并查找与之匹配的文本。你将了解元字符（如 . \ * + ? ^ $ | 等）在引擎中的作用，以及它们如何控制匹配的灵活性。 **4. 字符类或“量词”** - 本节关注字符类，如[abc]表示匹配a、b或c中的任一字符，以及量词的概念，如*（零次或多次）、+（一次或多次）、?（零次或一次）等，这些都是构建复杂模式的关键。 **5. 特殊字符和转义** - 学习如何处理特殊字符，如括号、分组、反向引用和反斜杠（\）的作用，以及它们如何改变字符的含义，使你能够更精确地定义匹配条件。 **6. 步进和范围** - 了解如何使用特殊符号来指定字符序列的范围，如[a-z]（小写字母）和[A-Z]（大写字母），以及如何使用连续字符类（如[0-9]）匹配数字。 **7. 分组和选择** - 分组允许你组合字符或子表达式，并可以重用它们进行重复匹配或提取子字符串。通过非贪婪匹配和正向/负向前瞻（lookahead/behind）实现选择性匹配。 **8. 跨语言支持** - 对于每种编程语言，如Java的java.util.regex包、JavaScript的RegExp对象、MySQL的REGEXP函数等，都会详细解释内置正则表达式库的功能和语法差异，以便你在实际项目中得心应手。 **9. 实战应用** - 通过实例演示如何在实际场景中使用正则表达式，如数据验证、文本搜索替换、解析URL、HTML标签处理等，帮助你掌握在不同环境下的应用技巧。 **版权和使用条款** - 作者Jan Goyvaerts强调了版权保护，并指出未经许可不得复制或传输书中的任何内容。本书旨在提供准确的信息，但不承担任何责任，且提供的信息基于“现状”原则。这个《正则表达式完全教程》涵盖了正则表达式的基础到高级概念，以及其在多种编程语言中的具体应用。无论是初学者还是经验丰富的开发者，都能从中受益匪浅。

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页未读，继续阅读

Getdone

粉丝: 0

全面掌握正则表达式：多语言模块详解

Mastering Regular Expressions - 英文版技术参考

Mastering Regular Expressions - 英文版PDF教程

正则表达式权威指南：Mastering Regular Expressions

Regular expressions

RegularExpressions

nanoFramework.System.Text.RegularExpressions:nanoFramework System.Text.RegularExpressions类库

Mastering Regular Expressions

Regular Expressions Cookbook

Java Regular Expressions

Introducing Regular Expressions

最新资源