編譯正則表達式

⑴ 正則表達式方法

正則表達式： 使用單個字元串來描述、匹配一系列·符合·某個句法規則的字元串搜索模式。
語法： /正則表達式主體/修飾符
修飾符： i表示執行對大小寫不敏感的匹配。g表示執行全局匹配（查找所有匹配而非在找到第一個匹配後停止）。m表示執行多行匹配。

1.search()方法，用於檢索指定字元串的子字元串，並返回子字元串的起始位置。
    語法：str.search(regexp);
     例如： 使用正則表達式搜索 "Runoob" 字元串，且不區分大小寫：

2.replace()方法，用在字元串中的一些字元替換另一些字元，或替換與正則表達式匹配的字元串。
    語法：str.replace(regexp);
     例如： 使用正則表達式且不區分大小寫將字元串中的 Microsoft 替換為 Runoob :

3.match()方法，可在字元串內檢索指定的值，或找到一個或多個正則表達式的匹配，並以數組形式返回匹配結果。
    語法：str.match(regexp);
     例如： 使用正則表達式且不區分大小寫將全文字元串中的here查找出來 :

4.split()方法，用於把一個字元串分割成字元串數組。
    語法：str.split(separator,limit);  separator為字元串或正則表達式，limit指定返回數組的最大長度。
     例如：

RegExp對象是一個預定義了屬性和方法的正則表達式對象。
語法：var patt = new RegExp(pattern,modifiers); 或 var patt = /pattern/modifiers;
      pttern為表達式，modifiers為修飾符用於指定全局匹配g，區分大小寫i，和多行比配m。

1.test()方法，用於檢測字元是否匹配某個模式，有則返回true，否則返回false。
    語法：patt.test(str)
     例如： 搜索字元串中的字元 "e"：

2.exec()方法，用於檢索字元串中是否有正則表達式的匹配值，有則返回匹配值，否則返回null。
    語法：patt.exec(str)
     例如：

3.compile()方法，用於在腳本執行過程中編譯正則表達式，也可用於改變和重新編譯正則表達式。
    語法：patt.compile(regexp,modifier)
     例如：

例題
1.給定字元串 str，檢查其是否符合如下格式：XXX-XXX-XXXX，其中 X 為 Number 類型。
   解析 ：開頭^和結尾$必須加上來限定字元串，3個數可表示為d{3}，4個數則為d{4}，{n}表示前面內容出現的次數。

2.給定字元串 str，檢查其是否包含 連續3個數字 ，如果包含，返回最新出現的 3 個數字的字元串，如果不包含，返回 false。
   解析 ：match()返回的是正則表達式匹配的字元串數組，連續的三個任意數字用正則表達式表示為/d{3}/。

3.給定字元串 str，檢查其是否符合美元書寫格式:以 $ 開始;整數部分，從個位起，滿 3 個數字用 , 分隔;如果為小數，則小數部分長度為2;正確的格式如：$1,023,032.03 或者 $2.03,錯誤的格式如：$3,432,12.12 或者 $34,344.3。
   解析 ：開頭必是 表示結尾，需要進行轉義，因此開頭為^$;
        然後dollar符後必然接數字，並且最少一位，最多三位數，可用{m,n}表示,最少m位，最多n位，因此此段為d{1,3};
        接著，後面如還有數，則必然有，分隔，並且後面必有3個數，類似於，XXX的格式會出現0或者n次，因此此段可表示為(,d{3})*;
        最後，如有小數部分，則注意對小數點進行轉義，此段可表示為(.d{2})?;
        使用test方法去檢測str

⑵ java中的正則表達式跟編譯原理有什麼聯系

首先，正則表達式不僅在Java里有，其它語言裡面也有，它是一個數學上的概念，各個語言中的正則表達式是它的不同形式的實現。
其次，編譯原理的詞法分析里，會用到正則表達式去匹配源程序中的各種token(記號)，比如說
int a = 8;
里識別出：
類型名：int
變數名：a
運算符：=
數字：8
結尾分號：;
總之，二者有聯系，但不是一回事。

⑶ 正則表達式怎麼編寫

<%
Function RegExpTest(patrn, strng)
Dim regEx, Match, Matches '建立變數。
Set regEx = New RegExp '建立正則表達式。
regEx.Pattern = patrn '設置模式。
regEx.IgnoreCase = True '設置是否區分字元大小寫。
regEx.Global = True '設置全局可用性。
Set Matches = regEx.Execute(strng) '執行搜索。
For Each Match in Matches '遍歷匹配集合。
RetStr = RetStr & "Match found at position "
RetStr = RetStr & Match.FirstIndex & ". Match Value is '"
RetStr = RetStr & Match.Value & "'." & "<BR>"
Next
RegExpTest = RetStr
End Function
response.write RegExpTest("[ij]s.", "IS1 Js2 IS3 is4")
%>
在這個例子中，我們查找字元串中有無is或者js這兩個詞，忽略大小寫。運行的結果如下：
Match found at position 0. Match Value is 'IS1'.
Match found at position 4. Match Value is 'Js2'.
Match found at position 8. Match Value is 'IS3'.
Match found at position 12. Match Value is 'is4'.
下面我們就介紹這三個對象和集合。
1、RegExp對象是最重要的一個對象，它有幾個屬性，其中：
○Global 屬性，設置或返回一個 Boolean 值，該值指明在整個搜索字元串時模式是全部匹配還是只匹配第一個。如果搜索應用於整個字元串，Global 屬性的值為 True，否則其值為 False。默認的設置為 False。
○IgnoreCase 屬性，設置或返回一個Boolean值，指明模式搜索是否區分大小寫。如果搜索是區分大小寫的，則 IgnoreCase 屬性為 False；否則為 True。預設值為 False。
○Pattern 屬性，設置或返回被搜索的正則表達式模式。必選項。總是一個 RegExp 對象變數。
2、Match 對象
匹配搜索的結果是存放在Match對象中，提供了對正則表達式匹配的只讀屬性的訪問。 Match 對象只能通過 RegExp 對象的 Execute 方法來創建，該方法實際上返回了 Match 對象的集合。所有的 Match 對象屬性都是只讀的。在執行正則表達式時，可能產生零個或多個 Match 對象。每個 Match 對象提供了被正則表達式搜索找到的字元串的訪問、字元串的長度，以及找到匹配的索引位置等。
○FirstIndex 屬性，返回在搜索字元串中匹配的位置。FirstIndex 屬性使用從零起算的偏移量，該偏移量是相對於搜索字元串的起始位置而言的。換言之，字元串中的第一個字元被標識為字元 0
○Length 屬性，返回在字元串搜索中找到的匹配的長度。
○Value 屬性，返回在一個搜索字元串中找到的匹配的值或文本。
3、Matches 集合
正則表達式 Match 對象的集合。Matches 集合中包含若干獨立的 Match 對象，只能使用 RegExp 對象的 Execute 方法來創建之。與獨立的 Match 對象屬性相同，Matches `集合的一個屬性是只讀的。在執行正則表達式時，可能產生零個或多個 Match 對象。每個 Match 對象都提供了與正則表達式匹配的字元串的訪問入口、字元串的長度，以及標識匹配位置的索引。
學習了這三個對象和集合，如何應用於字元串的判斷和替換呢？regExp對象的三個方法正好解決了這個問題，它們是Replace方法、Test方法和Execute方法。
1、Replace 方法
替換在正則表達式查找中找到的文本。我們還是先看個例子：下面的例子說明了 Replace 方法的用法。
<%
Function ReplaceTest(patrn, replStr)
Dim regEx, str1 ' 建立變數。
str1 = "The quick brown fox jumped over the lazy dog."
Set regEx = New RegExp ' 建立正則表達式。
regEx.Pattern = patrn ' 設置模式。
regEx.IgnoreCase = True ' 設置是否區分大小寫。
ReplaceTest = regEx.Replace(str1, replStr) ' 作替換。
End Function
Response.write ReplaceTest("fox", "cat") & "<BR>" ' 將 'fox' 替換為 'cat'。
Response.write ReplaceTest("(\S+)(\s+)(\S+)", "$3$2$1") ' 交換詞對.
%>
2、Test 方法
對指定的字元串執行一個正則表達式搜索，並返回一個 Boolean 值指示是否找到匹配的模式。正則表達式搜索的實際模式是通過RegExp對象的Pattern屬性來設置的。RegExp.Global屬性對Test方法沒有影響。
如果找到了匹配的模式，Test方法返回True；否則返回False。下面的代碼說明了Test 方法的用法。
<%
Function RegExpTest(patrn, strng)
Dim regEx, retVal ' 建立變數。
Set regEx = New RegExp ' 建立正則表達式。
regEx.Pattern = patrn ' 設置模式。
regEx.IgnoreCase = False ' 設置是否區分大小寫。
retVal = regEx.Test(strng) ' 執行搜索測試。
If retVal Then
RegExpTest = "找到一個或多個匹配。"
Else
RegExpTest = "未找到匹配。"
End If
End Function
Response.write RegExpTest("is.", "IS1 is2 IS3 is4")
%>
3、Execute 方法
對指定的字元串執行正則表達式搜索。正則表達式搜索的設計模式是通過 RegExp 對象的 Pattern 來設置的。
Execute 方法返回一個 Matches 集合，其中包含了在 string 中找到的每一個匹配的 Match 對象。如果未找到匹配，Execute 將返回空的 Matches 集合。

⑷ 編譯原理中，a和b的個數相等的正則表達式該怎麼寫

判定a和b的個數相等不能使用正則語言，需要使用上下文無關語言，下推自動機利用堆棧記憶和處理a和b的個數之間的關系。
所以沒有能夠描述你所要求的正則表達式。

⑸ 編譯原理 正則表達式

/^(?!.*001)[01]+$/

⑹ 如何在c語言中使用正則表達式

看到大家討論這方面的東西，作點貢獻聊表各位高手對這個版快的無私奉獻 :oops:

如果用戶熟悉Linux下的sed、awk、grep或vi，那麼對正則表達式這一概念肯定不會陌生。由於它可以極大地簡化處理字元串時的復雜
度，因此現在已經在許多Linux實用工具中得到了應用。千萬不要以為正則表達式只是Perl、Python、Bash等腳本語言的專利，作為C語言程序
員，用戶同樣可以在自己的程序中運用正則表達式。

標準的C和C++都不支持正則表達式，但有一些函數庫可以輔助C/C++程序員完成這一功能，其中最著名的當數Philip Hazel的Perl-Compatible Regular Expression庫，許多Linux發行版本都帶有這個函數庫。

編譯正則表達式

為了提高效率，在將一個字元串與正則表達式進行比較之前，首先要用regcomp()函數對它進行編譯，將其轉化為regex_t結構：

int regcomp(regex_t *preg, const char *regex, int cflags);

參數regex是一個字元串，它代表將要被編譯的正則表達式；參數preg指向一個聲明為regex_t的數據結構，用來保存編譯結果；參數cflags決定了正則表達式該如何被處理的細節。

如果函數regcomp()執行成功，並且編譯結果被正確填充到preg中後，函數將返回0，任何其它的返回結果都代表有某種錯誤產生。

匹配正則表達式

一旦用regcomp()函數成功地編譯了正則表達式，接下來就可以調用regexec()函數完成模式匹配：

int regexec(const regex_t *preg, const char *string, size_t nmatch,regmatch_t pmatch[], int eflags);
typedef struct {
regoff_t rm_so;
regoff_t rm_eo;
} regmatch_t;

參數preg指向編譯後的正則表達式，參數string是將要進行匹配的字元串，而參數nmatch和pmatch則用於把匹配結果返回給調用程序，最後一個參數eflags決定了匹配的細節。

在調用函數regexec()進行模式匹配的過程中，可能在字元串string中會有多處與給定的正則表達式相匹配，參數pmatch就是用來保
存這些匹配位置的，而參數nmatch則告訴函數regexec()最多可以把多少個匹配結果填充到pmatch數組中。當regexec()函數成功返
回時，從string+pmatch[0].rm_so到string+pmatch[0].rm_eo是第一個匹配的字元串，而從
string+pmatch[1].rm_so到string+pmatch[1].rm_eo，則是第二個匹配的字元串，依此類推。

釋放正則表達式

無論什麼時候，當不再需要已經編譯過的正則表達式時，都應該調用函數regfree()將其釋放，以免產生內存泄漏。

⑺ C語言怎麼用正則表達式

由於它可以極大地簡化處理字元串時的復雜度，因此現在已經在許多 L i n u x 實用工具中得到了應用。千萬不要以為正則表達式只是 P e r l 、 P y t h o n 、 B a s h 等腳本語言的專利，作為 C 語言程序員，用戶同樣可以在自己的程序中運用正則表達式。標準的 C 和 C + + 都不支持正則表達式，但有一些函數庫可以輔助 C / C + + 程序員完成這一功能，其中最著名的當數 P h i l i p H a z e l 的 P e r l - C o m p a t i b l e R e g u l a r E x p r e s s i o n 庫，許多 L i n u x 發行版本都帶有這個函數庫。編譯正則表達式為了提高效率，在將一個字元串與正則表達式進行比較之前，首先要用 r e g c o m p ( ) 函數對它進行編譯，將其轉化為 r e g e x _ t 結構： i n t r e g c o m p ( r e g e x _ t * p r e g , c o n s t c h a r * r e g e x , i n t c f l a g s ) ; 參數 r e g e x 是一個字元串，它代表將要被編譯的正則表達式；參數 p r e g 指向一個聲明為 r e g e x _ t 的數據結構，用來保存編譯結果；參數 c f l a g s 決定了正則表達式該如何被處理的細節。如果函數 r e g c o m p ( ) 執行成功，並且編譯結果被正確填充到 p r e g 中後，函數將返回 0 ，任何其它的返回結果都代表有某種錯誤產生。匹配正則表達式一旦用 r e g c o m p ( ) 函數成功地編譯了正則表達式，接下來就可以調用 r e g e x e c ( ) 函數完成模式匹配： i n t r e g e x e c ( c o n s t r e g e x _ t * p r e g , c o n s t c h a r * s t r i n g , s i z e _ t n m a t c h , r e g m a t c h _ t p m a t c h [ ] , i n t e f l a g s ) ; t y p e d e f s t r u c t { r e g o f f _ t r m _ s o ; r e g o f f _ t r m _ e o ; } r e g m a t c h _ t ; 參數 p r e g 指向編譯後的正則表達式，參數 s t r i n g 是將要進行匹配的字元串，而參數 n m a t c h 和 p m a t c h 則用於把匹配結果返回給調用程序，最後一個參數 e f l a g s 決定了匹配的細節。在調用函數 r e g e x e c ( ) 進行模式匹配的過程中，可能在字元串 s t r i n g 中會有多處與給定的正則表達式相匹配，參數 p m a t c h 就是用來保存這些匹配位置的，而參數 n m a t c h 則告訴函數 r e g e x e c ( ) 最多可以把多少個匹配結果填充到 p m a t c h 數組中。當 r e g e x e c ( ) 函數成功返回時，從 s t r i n g + p m a t c h [ 0 ] . r m _ s o 到 s t r i n g + p m a t c h [ 0 ] . r m _ e o 是第一個匹配的字元串，而從 s t r i n g + p m a t c h [ 1 ] . r m _ s o 到 s t r i n g + p m a t c h [ 1 ] . r m _ e o ，則是第二個匹配的字元串，依此類推。釋放正則表達式無論什麼時候，當不再需要已經編譯過的正則表達式時，都應該調用函數 r e g f r e e ( ) 將其釋放，以免產生內存泄漏。 v o i d r e g f r e e ( r e g e x _ t * p r e g ) ; 函數 r e g f r e e ( ) 不會返回任何結果，它僅接收一個指向 r e g e x _ t 數據類型的指針，這是之前調用 r e g c o m p ( ) 函數所得到的編譯結果。如果在程序中針對同一個 r e g e x _ t 結構調用了多次 r e g c o m p ( ) 函數， P O S I X 標准並沒有規定是否每次都必須調用 r e g f r e e ( ) 函數進行釋放，但建議每次調用 r e g c o m p ( ) 函數對正則表達式進行編譯後都調用一次 r e g f r e e ( ) 函數，以盡早釋放佔用的存儲空間。報告錯誤信息如果調用函數 r e g c o m p ( ) 或 r e g e x e c ( ) 得到的是一個非 0 的返回值，則表明在對正則表達式的處理過程中出現了某種錯誤，此時可以通過調用函數 r e g e r r o r ( ) 得到詳細的錯誤信息。 s i z e _ t r e g e r r o r ( i n t e r r c o d e , c o n s t r e g e x _ t * p r e g , c h a r * e r r b u f , s i z e _ t e r r b u f _ s i z e ) ; 參數 e r r c o d e 是來自函數 r e g c o m p ( ) 或 r e g e x e c ( ) 的錯誤代碼，而參數 p r e g 則是由函數 r e g c o m p ( ) 得到的編譯結果，其目的是把格式化消息所必須的上下文提供給 r e g e r r o r ( ) 函數。在執行函數 r e g e r r o r ( ) 時，將按照參數 e r r b u f _ s i z e 指明的最大位元組數，在 e r r b u f 緩沖區中填入格式化後的錯誤信息，同時返回錯誤信息的長度。應用正則表達式最後給出一個具體的實例，介紹如何在 C 語言程序中處理正則表達式。 # i n c l u d e < s t d i o . h > ; # i n c l u d e < s y s / t y p e s . h > ; # i n c l u d e < r e g e x . h > ; / * 取子串的函數 * / s t a t i c c h a r * s u b s t r ( c o n s t c h a r * s t r , u n s i g n e d s t a r t , u n s i g n e d e n d ) { u n s i g n e d n = e n d - s t a r t ; s t a t i c c h a r s t b u f [ 2 5 6 ] ; s t r n c p y ( s t b u f , s t r + s t a r t , n ) ; s t b u f [ n ] = 0 ; r e t u r n s t b u f ; } / * 主程序 * / i n t m a i n ( i n t a r g c , c h a r * * a r g v ) { c h a r * p a t t e r n ; i n t x , z , l n o = 0 , c f l a g s = 0 ; c h a r e b u f [ 1 2 8 ] , l b u f [ 2 5 6 ] ; r e g e x _ t r e g ; r e g m a t c h _ t p m [ 1 0 ] ; c o n s t s i z e _ t n m a t c h = 1 0 ; / * 編譯正則表達式 * / p a t t e r n = a r g v [ 1 ] ; z = r e g c o m p ( & r e g , p a t t e r n , c f l a g s ) ; i f ( z ! = 0 ) { r e g e r r o r ( z , & r e g , e b u f , s i z e o f ( e b u f ) ) ; f p r i n t f ( s t d e r r , " % s : p a t t e r n ' % s ' \ n " , e b u f , p a t t e r n ) ; r e t u r n 1 ; } / * 逐行處理輸入的數據 * / w h i l e ( f g e t s ( l b u f , s i z e o f ( l b u f ) , s t d i n ) ) { + + l n o ; i f ( ( z = s t r l e n ( l b u f ) ) > ; 0 & & l b u f [ z - 1 ] = = ' \ n ' ) l b u f [ z - 1 ] = 0 ; / * 對每一行應用正則表達式進行匹配 * / z = r e g e x e c ( & r e g , l b u f , n m a t c h , p m , 0 ) ; i f ( z = = R E G _ N O M A T C H ) c o n t i n u e ; e l s e i f ( z ! = 0 ) { r e g e r r o r ( z , & r e g , e b u f , s i z e o f ( e b u f ) ) ; f p r i n t f ( s t d e r r , " % s : r e g c o m ( ' % s ' ) \ n " , e b u f , l b u f ) ; r e t u r n 2 ; } / * 輸出處理結果 * / f o r ( x = 0 ; x < n m a t c h & & p m [ x ] . r m _ s o ! = - 1 ; + + x ) { i f ( ! x ) p r i n t f ( " % 0 4 d : % s \ n " , l n o , l b u f ) ; p r i n t f ( " $ % d = ' % s ' \ n " , x , s u b s t r ( l b u f , p m [ x ] . r m _ s o , p m [ x ] . r m _ e o ) ) ; } } / * 釋放正則表達式 * / r e g f r e e ( & r e g ) ; r e t u r n 0 ; } 上述程序負責從命令行獲取正則表達式，然後將其運用於從標准輸入得到的每行數據，並列印出匹配結果。執行下面的命令可以編譯並執行該程序： # g c c r e g e x p . c - o r e g e x p # . / r e g e x p ' r e g e x [ a - z ] * ' < r e g e x p . c 0 0 0 3 : # i n c l u d e < r e g e x . h > ; $ 0 = ' r e g e x ' 0 0 2 7 : r e g e x _ t r e g ; $ 0 = ' r e g e x ' 0 0 5 4 : z = r e g e x e c ( & r e g , l b u f , n m a t c h , p m , 0 ) ; $ 0 = ' r e g e x e c ' 小結對那些需要進行復雜數據處理的程序來說，正則表達式無疑是一個非常有用的工具。本文重點在於闡述如何在 C 語言中利用正則表達式來簡化字元串處理，以便在數據處理方面能夠獲得與 P e r l 語言類似的靈活性。

⑻ 編譯原理，正則表達式的低級基礎問題

1、正則表達式：0(0|1)*1
2、由於不方便畫圖，最簡DFA用狀態表表示如下：
（1）開始狀態S------輸入0------->狀態A
（2）狀態A-------輸入0-------->狀態A
（3）狀態A-------輸入1-------->狀態B（可接受狀態）
（4）狀態B-------輸入0-------->狀態A
（5）狀態B-------輸入1-------->狀態B（可接受狀態）

⑼ 編譯原理正則表達式化簡

你好，語言L={a}{a,b}∗({ϵ}∪({.,_}{a,b}{a,b}∗))L={a}{a,b}
∗
({ϵ}∪({.,_}{a,b}{a,b}
∗
))
這個語言是指，由a開頭，後接任意長度的a、b串，然後再接空串（代表結束）。或者是接以.或_開頭的，後接長度大於等於1的a、b串。

正則表達式（Regular Expression, RE）是一種用來描述正則語言的更緊湊的表示方法。

⑽ 編譯原理：c語言標識符的正則表達式

C語言中的標識符:
標識符由字母、數字、下劃線「_」組成，並且首字母不能是數字.
java語言中的標識符:
標識符由字母、數字、下劃線「_」、美元符號「$」組成，並且首字母不能是數字。
一般標識符由字母、數字、下劃線「_」組成
如果只能以下劃線、英文字母開頭，後跟單詞字元的話：
^[A-Za-z_][A-Za-z0-9_]*$