構造復雜正則表達式的方法

2024-09-07 17:40:14

字體：大中小

來源：轉載

供稿：網友

相信在大家的印象中正則表達式都是非常簡單的吧，其實正則表達式也有很復雜的，那么你知道怎么構造復雜的正則表達式嗎？下面我們就一起去看看構造復雜正則表達式的方法。

避重就輕

Snopo給出的文本是這樣的：or and name='zhangsan' and id=001 or age>20 or area='%renmin%' and like，問，如何提取其中正確的SQL查詢語句。

簡要分析可知，中間部分是合乎要求的，只是兩端的有若干個like, or, and。構造能夠解析合乎SQL語法的查詢語句的正則表達式，應該是比較復雜的。可是，對于具體的問題，也可以更簡單。上述的不良構的SQL語句，應該是使用程序自動生成的，它的兩端會有一些不符合題意的文本。只要將這些文本去除就可以了。

于是，我寫出了正則表達式：s/^(?:(?:or|and|like)/s*)+|/s*(?:(?:or|and|like)/s*)+$//mi;，這樣就把多行字串首尾的like, or, and以及可能的空白字符全部去掉了，剩下的內容即為所求。

分而治之

答案發過去之后，Snopo顯然不是很滿意這種“偷懶”的辦法。他繼續問道，能否寫出正則式，用來匹配合符SQL語法要求的條件查詢語句？（只考慮where部分即可，不必寫完整的select。）

的確，從快速解決問題的角度來說，只要能夠行之有效地解決，用什么辦法都可以；不過從學習知識的角度來說，不避重就輕，而是刨根問底，才是正途。既如此，就看一下如何使用正則，將該SQL查詢語句解決掉。

最簡單的查詢語句，應該是真假判斷，即 where 1; where True; where false，等等。這樣的語句使用正則式，直接/(?:-?/d+|True|False)/i。

稍復雜些的單條語句，可以是左右比較，即
?

name like 'zhang%', 或 age>25 ，或 work in ('it', 'hr', 'R&D')

。將其簡單化，結構就變為A OP B。其中A代表變量，OP代表比較操作符，B代表值。

?A: 最簡單的A，應該是/w+?？紤]到實際情況，變量包含點號或脫字符，例如`table.salary`，可以記為/[/w.`]+/。這是比較籠統的細化。如果要求比較苛刻，還可以做到讓脫字符同時在左右兩邊出現（條件判斷）。
?OP: Where 常用的幾種關系比較為：=, <>, >, <, >=, <=, Between, Like, in。使用簡單的正則描述之，成為：/(?:[<>=]{1,2}|Between|Like|In)/i。
?B: B 的情況又可分為3種：變量，數字，字符串，列表。為簡單起見，這里就不考慮算術表達式了。

?變量的話，直接延用A的定義即可。不贅述。
?數字：使用//d+/來定義。不考慮小數和負數了。

?字符串：包括單引號字串和雙引號字串。中間可以包括被轉義的引號。我寫了一個符合這一要求的引號字串正則表達式，形如：/(['"])(?://['"]|[^//1])*?/1/。不過，由于它只是龐大機器的一個零件，這樣寫的風險是極其大的。首先，它使用了反向引用；其次，該反向引用使用了全局的反向引用編號。我寫了自動生成全局編號的函數，來解決這一問題。不過，這里談細節是不是太深入了。應該先談框架，再說細節才對。不應該一入手就陷進細節的汪洋大海。

?列表：列表是形如(1, 3 , 4) 或 ("it", "hr", "r&d")之類的東東，它由簡單變量以逗號相連，兩邊加上括號組成。列表的單項以I表示，它代表數字|字符串。此時，列表就變為：//(I(?:,I)*?/)/。它表示，左括號，一個I，一系列由逗號、I組成的其它列表項（0個或多個），右括號。簡單起見沒有考慮空白字符。
?至此，可以總結出單條語句的正則框架：S =~ /A OP B/i。S在此代表單條語句。
更為復雜的是多條語句，可以由單條語句組成，中間使用 and 或 or 連接。合理地構造單條語句，將其穩定地編制為多條語句，任務就完成了。

沿用上面的示例，以S代表單條語句，那么復合語句C就是 C =~ S(?:(?:or|and) S)*?/。至此，一個初具規模的條件語句解析器就誕生了。下面以python為例，一步一步實現出來。

Python實現
重申一句：雖然給出了實現，但是仍請注重思路，忽略代碼。

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
#author: rex
#blog: http://iregex.org
#filename test.py
#created: 2010-08-06 17:12

#generage quoted string;
#including ' and " string
#allow /' and /" inside
index=0
def gen_quote_str():

global index
index+=1
char=chr(96+index)
return r"""(?P<quote_%s>['"])(?://['"]|[^'"])*?(?P=quote_%s)"""% (char, char)


#simple variable
def a():
return r'[/w.`]+'

#operators
def op():
return r'(?:[<>=]{1,2}|Between|Like|In)'


#list item within (,)
#eg: 'a', 23, a.b, "asdfasdf/"aasdf"
def item():
return r"(?:%s|%s)" % (a(), gen_quote_str())


#a complite list, like
#eg: (23, 24, 44), ("regex", "is", "good")
def items():
return r"""/( /s*
%s
(?:,/s* %s)* /s*
/)""" % (item(), item())

#simple comparison
#eg: a=15 , b>23
def s():
return r"""%s /s* %s /s* (?:/w+| %s | %s )""" % (a(), op(), gen_quote_str(), items())

#complex comparison
# name like 'zhang%' and age>23 and work in ("hr", "it", 'r&d')
def c():
return r"""
(?ix) %s
(?:/s*
(?:and|or)/s*
%s /s*
)*
""" % (s(), s())

print "A:/t", a()
print "OP:/t", op()
print "ITEM:/t", item()
print "ITEMS:/t", items()
print "S:/t", s()
print "C:/t", c()

該代碼在我的機器上(Ubuntu 10.04, Python 2.6.5)運行的結果是：

A: [/w.`]+
OP: (?:[<>=]{1,2}|Between|Like|In)
ITEM: (?:[/w.`]+|(?P<quote_a>['"])(?://['"]|[^'"])*?(?P=quote_a))
ITEMS: /( /s*
(?:[/w.`]+|(?P<quote_b>['"])(?://['"]|[^'"])*?(?P=quote_b))
(?:,/s* (?:[/w.`]+|(?P<quote_c>['"])(?://['"]|[^'"])*?(?P=quote_c)))* /s*
/)
S: [/w.`]+ /s* (?:[<>=]{1,2}|Between|Like|In) /s* (?:/w+| (?P<quote_d>['"])(?://['"]|[^'"])*?(?P=quote_d) | /( /s*
(?:[/w.`]+|(?P<quote_e>['"])(?://['"]|[^'"])*?(?P=quote_e))
(?:,/s* (?:[/w.`]+|(?P<quote_f>['"])(?://['"]|[^'"])*?(?P=quote_f)))* /s*
/) )
C:
(?ix) [/w.`]+ /s* (?:[<>=]{1,2}|Between|Like|In) /s* (?:/w+| (?P<quote_g>['"])(?://['"]|[^'"])*?(?P=quote_g) | /( /s*
(?:[/w.`]+|(?P<quote_h>['"])(?://['"]|[^'"])*?(?P=quote_h))
(?:,/s* (?:[/w.`]+|(?P<quote_i>['"])(?://['"]|[^'"])*?(?P=quote_i)))* /s*
/) )
(?:/s*
(?:and|or)/s*
[/w.`]+ /s* (?:[<>=]{1,2}|Between|Like|In) /s* (?:/w+| (?P<quote_j>['"])(?://['"]|[^'"])*?(?P=quote_j) | /( /s*
(?:[/w.`]+|(?P<quote_k>['"])(?://['"]|[^'"])*?(?P=quote_k))
(?:,/s* (?:[/w.`]+|(?P<quote_l>['"])(?://['"]|[^'"])*?(?P=quote_l)))* /s*
/) ) /s*
)*

請看匹配效果圖：

算術表達式

我記得剛才好像提到“為簡單起見，這里就不考慮算術表達式了”。不過，解析算術表達式是個非常有趣的話題，只要是算法書，都會提及（中綴表達式轉前綴表達式，諸如此類）。當然它也可以使用正則表達式來描述。

其主要思路是：

expr -> expr + term | expr - term | term
term -> term * factor | term / factor | factor
factor -> digit | ( expr )

以及代碼：

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
#author: rex
#blog: http://jb51.net
#filename math.py
#created: 2010-08-07 00:44

integer=r"/d+"

factor=r"%s (?:/. %s)?" % (integer, integer)

term= "%s(?: /s* [*/] /s* %s)* " % (factor, factor)

expr= "(?x) %s(?: /s* [+-] /s* %s)* " % (term, term)

print expr

看一下它的輸出和匹配效果圖：

小貼士

?如果不用復雜的正則式就能解決問題，一定不要用。
?如果必須寫比較復雜的正則式，請參考以下原則。
?從大處著眼，先理解待解析的文本的整體結構是什么樣子，劃分為小部件；
?從細處著手，試圖實現每一個小部件，力求每一部分都是完整、堅固的，且放在全局也不會沖突。
?合理組裝這些部件。
?分而治之的好處：只有某個模塊出錯，其它部分沒錯時，可以迅速定位錯誤，消除BUG。
?謹慎使用捕獲括號，除非你知道自己在做什么，知道它會有什么副作用，以及是否有可行的解決措施。對于短小的正則式來說，一兩個多余的括號是無傷大雅的；但是對于復雜的正則式來說，一對多余的括號可能就是致命的錯誤。
?盡量使用free-space模式。此時你可以自由地添加注釋和空白字符，以便提高正則表達式的可讀性。