正則表示式

ABAP中可以使用regex的地方

除了下面兩個語句可以使用regex外：

• FIND

下面主函式的引數也可以使用regex：

• count()

• find()

• match()

另外，還有兩個類也可以使用regex：

正則式語法規則

下面都是針對單個字元匹配的：

(?=…)、(?!...)

注：SAP反向搜尋(?<=...)、(?<!...)目前不支援，只支援正向搜尋(?=...)、(?!...)，但Java都支援

DATA text TYPE string. 
DATA result_tab TYPE match_result_tab WITH HEADER LINE. 

text = `Shalalala!`. 

FIND ALL OCCURRENCES OF REGEX '(?:la)(?=!)' 
     IN text RESULTS result_tab[]. 

LOOP AT result_tab .
  WRITE: /  result_tab-offset, result_tab-length.
ENDLOOP.
7           2

\A 、\z、\Z與^ 、$區別

^ 指定的匹配必須出現在字串的開頭或行的開頭（即 \n後面第一個字元）。

$ 指定的匹配必須出現在以下位置：字串結尾、字串結尾的 \n 之前或行的結尾（不會匹配到\n，如果最末有\n，只會匹配到它之前）。
\A 指定匹配必須出現在字串的開頭（忽略 Multiline 選項）。 

\z 指定匹配必須出現在字串的結尾（忽略 Multiline 選項）。
\Z 指定匹配必須出現在字串的結尾或字串結尾的 \n 之前（忽略 Multiline 選項）。 

\A 、\z、\Z與^ 、$不同的是，只搜尋第一行

DATA text TYPE string.

"在ABAP中如果要在字元中插入回車換行字元時，需要使用 ||，而不是使用單引號引起來
text = |zzz\nabc\n|.
IF contains( val = text regex = '^abc' ) .
  WRITE:/ 'Yes'.
ELSE.
  WRITE:/ 'No'.
ENDIF.

"如果是將 ^換成 \A 時，則結果不會匹配
IF contains( val = text regex = '\Aabc' ).
  WRITE:/ 'Yes'.
ELSE.
  WRITE:/ 'No'.
ENDIF.
IF contains( val = text regex = 'z$' ).
  WRITE:/ 'Yes'.
ELSE.
  WRITE:/ 'No'.
ENDIF.
IF contains( val = text regex = 'c$' ).
  WRITE:/ 'Yes'.
ELSE.
  WRITE:/ 'No'.
ENDIF.
IF contains( val = text regex = 'z\z' ).
  WRITE:/ 'Yes'.
ELSE.
  WRITE:/ 'No'.
ENDIF.
IF contains( val = text regex = 'z\Z' ).
  WRITE:/ 'Yes'.
ELSE.
  WRITE:/ 'No'.
ENDIF.
IF contains( val = text regex = 'c\z' ).
  WRITE:/ 'Yes'.
ELSE.
  WRITE:/ 'No'.
ENDIF.
IF contains( val = text regex = 'c\Z' ).
  WRITE:/ 'Yes'.
ELSE.
  WRITE:/ 'No'.
ENDIF.

Yes

No

Yes

Yes

No

No

No

Yes

$0…、$&、$`、$′

替換串裡可以出現$、&、`、 ′

$0、$&：表示的是整個正則式所匹配到的子串，即好比整個正則式使用 ( ) 括起來一樣，但不使用 ( ) 括起來整個regex所匹配的子串還是$0，即$0與整個regex是否使用了 ( ) 括起來沒有關係，但是，如果使用了( )將整個regex括起來了，則對後面的$1…是有影響的，整個regex此時會是$1，這與Java是不一樣的

DATA text TYPE string.

text = `Yeah!+`.
REPLACE REGEX `((Y)e(a)h(!))` IN text WITH `-&-&-0-1−1−2-3−3−4-`.
WRITE:/ text.
text = `Yeah!`. 
REPLACE REGEX `\w+` IN text WITH `-&-&-0-`.
WRITE:/ text.

-Yeah!-Yeah!-Yeah!-Y-a-!-+

-Yeah-Yeah-!

$`表示所匹配到的子串之前的所有字串，如果多次相同匹配，則所取到的是未經替換過的前面部分源串：

DATA text TYPE string. 
text = `again and abc and def`. 
REPLACE ALL OCCURRENCES OF REGEX 'and' IN text WITH '($0 $`)'. 
WRITE:/ text.

again (and again ) abc (and again and abc ) def

$'表示所匹配到的子串之後的所有字串：

DATA: text TYPE string. 
text = `again and again abc`. 
REPLACE ALL OCCURRENCES OF REGEX `again ` IN text WITH `($' $0)`. 
WRITE:/ text.

(and again abc again )and (abc again )abc

\1、\2、\3…

在分組正則式裡，可以使用\1, \2, \3…方式引用regex分組，與$分組不一新的是，只要用括號括起來的最左且最外的Regex為\1，而不是\0

As of Release 7.00, ABAP supports POSIX-style regular expressions

正則中的特殊字元：. * + ? | ^ $ ( ) [ ] { } \，可以使用\將這些特殊字元轉義普通的字元

FIND

FIND [{FIRST OCCURRENCE}|{ALL OCCURRENCES} OF]

{[SUBSTRING] sub_string} | {REGEX regex}

  IN [SECTION [OFFSET off] [LENGTH len] OF] dobj

  [IN {BYTE|CHARACTER} MODE]

  [{RESPECTING|IGNORING} CASE]

  [MATCH COUNT  mcnt]

  { {[MATCH OFFSET moff][MATCH LENGTH mlen]}

      | [RESULTS result_tab|result_wa] }

  [SUBMATCHES s1 s2 ...].

[{FIRST OCCURRENCE}|{ALL OCCURRENCES} OF]

如果未指定或者指定為FIRST OCCURRENCE，則只搜尋第一次出現的。

{[SUBSTRING] sub_string} | {REGEX regex}

FIRST OCCURRENCE或者未指定時，如果sub_string是空String型別的字串或者內容為空格的固定長度型別（c, d, n, or t）的字串時，sub_string將會被看作是empty 型別的字串，並且查詢的位置將定位到dobj的首字元前。但如果sub_string是空字串（包括字元型別字串型別），使用ALL OCCURRENCES選項，則會拋異常。

DATA: textTYPE string VALUE`Hey hey`,
      moff TYPEi,
      mlen TYPEi,
      mcnt TYPEi.
FINDFIRST OCCURRENCE OF  SUBSTRING  ''INtext
     MATCH OFFSET moff
     MATCH LENGTH mlen
     MATCH COUNT  mcnt.
WRITE: moff, mlen,mcnt.
FINDFIRST OCCURRENCE OF  SUBSTRING  ' 'INtext
     MATCH OFFSET moff
     MATCH LENGTH mlen
     MATCH COUNT  mcnt.
WRITE: moff, mlen,mcnt.
FINDFIRST OCCURRENCE OF  SUBSTRING  ``INtext
     MATCH OFFSET moff
     MATCH LENGTH mlen
     MATCH COUNT  mcnt.
WRITE: moff, mlen,mcnt.
FINDFIRST OCCURRENCE OF  SUBSTRING  ` `INtext
     MATCH OFFSET moff
     MATCH LENGTH mlen
     MATCH COUNT  mcnt.
WRITE: moff, mlen,mcnt.
"以下三個語句執行時會拋異常
"FIND ALL OCCURRENCES OF SUBSTRING  `` IN text MATCH OFFSET moff.
"FIND ALL OCCURRENCES OF SUBSTRING  '' IN text MATCH OFFSET moff.
"FIND ALL OCCURRENCES OF SUBSTRING  ' ' IN text MATCH OFFSET moff.

           0           0           1           0           0           1           0           0           1           3           1         1

sub_string為固定長度型別的字串時，尾部空格將被忽略，如果不想忽略尾部空格，則使用String型別的sub_string。

regex不允許為空的String型別的字串或者內容只有空格的固定長度型別（c, d, n, or t）的字串，以下編譯時會出錯：

DATA: textTYPE string VALUE`Hey hey`,
      moff TYPEi.
FINDFIRST OCCURRENCE OF  REGEX  ''INtext
     MATCH OFFSET moff.
FINDFIRST OCCURRENCE OF  REGEX  ``INtext
     MATCH OFFSET moff.

IN [SECTION [OFFSET off] [LENGTH len] OF] dobj

如果未加上SECTION選項，將對整個dobj字串進行匹配操作。如果指定了SECTION選項，則OFFSET與LENGTH必須選擇一個。如果指定如果指定了OFFSET，但未指定LENGTH時，查詢的區域從OFFSET到dobj的最後；如果指定了LENGTH，但未指定OFFSET時，OFFSET將隱含為0。OFFSET與LENGTH需要大於或等於0，通過OFFSET與LENGTH定位到的子字串段必須要位於dobj裡。

[{RESPECTING|IGNORING} CASE]

是否區分大小寫，預設區分

[MATCH COUNT  mcnt]

成功查詢的次數，如果使用了FIRST OCCURRENCE選項，則通常是1

[MATCH OFFSET moff]

最後一次匹配的子串（是指整體正則分組，即Java中的第0組）起始位置。如果沒有查詢到，則為以前的值。

注：FIND不影響sy-fdpos系統欄位

[MATCH LENGTH mlen]

最後一次匹配到的子串（是指整體正則分組，即Java中的第0組）的長度（注：與REPLACE不同的是，REPLACE指的是替換的長度）。

[RESULTS result_tab|result_wa]

result_tab接收所有匹配結果，而result_wa只能接收最後一次匹配結果

FIRST OCCURRENCE 一般與result_wa 一起使用，如果與result_tab結合，則最多隻有一條結果。

如果查詢不成功，則result_tab為initial，result_wa為以前的值。

result_wa適合於與FIRST OCCURRENCE結合使用，而result_tab適合於與ALL OCCURRENCES結合使用。

result_tab必須是MATCH_RESULT_TAB型別的內表

• OFFSET 匹配到的子字串位置dobj的位置
• LENGTH 匹配到的子字串長度
• SUBMATCHES 型別為SUBMATCH_RESULT_TAB 的內表，行型別為SUBMATCH_RESULT。該型別儲存了所有子分組匹配（只要是括號括起來的，就是一個子分組，那怕括起來的是整個正則式——如果整個正則式不括起來，則不會像Java那樣自動成為一個子分組）
• LINE 僅在使用FIND IN TABLE才有意思

[SUBMATCHES s1 s2 ...]

SUBMATCHES 選項只在REGEX regex情況下使用，並且只會接收使用括號進行分組的子組。

如果變數s1 s2 ...比分組的數量多，則多餘的變數被initial；如果變數s1 s2 ...比分組的數量少，則多餘的分組將被忽略。

DATA: text TYPE string,
      moff TYPE i,
      mlen TYPE i,

mcnt TYPE i,
      s1   TYPE string,
      s2   TYPE string,
      s3   TYPE string,
      s4   TYPE string.
text = `Hey hey, my my, Rock Hey hey, my my,`.
FIND ALL OCCURRENCES OF REGEX `(\w+)\W+\1\W+(\w+)\W+\2`
     IN text
     IGNORING CASE

"以下兩個變數儲存的是第二次匹配到的子串（整體正則式）相關資訊
     MATCH OFFSET moff
     MATCH LENGTH mlen

"會發生2次匹配

MATCH COUNT  mcnt
     "會發生兩次匹配，第一次為：Hey hey, my my，第二次為：Hey hey, my my

     "注，雖然這裡使用使用了4個變數接收分組，但正則式中每次只會有兩個

     "分組，所以接收每次匹配結果只需要2個變數，s3與s4不會用到，而不是第二次

     "時將匹配到的結果存放到s3與s4中
     SUBMATCHES s1 s2 s3 s4.
WRITE: / moff, / mlen,/ s1, / s2, / s3,/ s4.

        21

        14

         2

Hey

my

精確查詢（一次性解析）

{[SUBSTRING] sub_string} | {REGEX regex}：為FIND的兩種使用方式。第一種表式在dobj串中精確查詢子字串sub_string（SUBSTRING可以省略），此種方式sub_string不支援正則試，即使使用也會當作普通字串。如：

  DATA: result_tab TYPE match_result_tab.
  FIELD-SYMBOLS <match> LIKE LINE OF result_tab.
  FIND ALL OCCURRENCES OF `now` IN`Everybody knows this is nowhere`
       RESULTS result_tab.
  LOOP AT result_tab ASSIGNING <match>.
    WRITE: / <match>-offset, <match>-length.
  ENDLOOP.

        11           3

        24           3

精確查詢（迴圈查詢）

上面程式可以使用以下迴圈方式來代替（這種方式適合以7.0以前版本），而不是將結果一次性存入到match_result_tab型別的內表中：

  DATA: off  TYPE i,
        moff TYPE i,
        mlen TYPE i.
  off = 0.
  WHILE sy-subrc = 0.
    FIND `now` IN SECTION OFFSET off OF
         `Everybody knows this is nowhere`
        MATCH OFFSET moff
         MATCH LENGTH mlen.
    IF sy-subrc = 0.
      WRITE: / moff,mlen.
      off = moff + mlen.
    ENDIF.
  ENDWHILE.

        11           3

        24           3

使用正則式

DATA: moff TYPE i,
      mlen TYPE i,
      s1 TYPE string,
      s2 TYPE string,
      s3 TYPE string,
      s4 TYPE string.
"(a).|([ab]+)等效於 ((a).)|([ab]+)。正則式是按最貪婪（最多或者最長匹配）
"方式來匹配，所以 (a).|([ab]+) 會選擇後者。另外，分組數只與括號有關，並
"按括號從左到右，從外到裡順次為第一組，第二組，第...，與 | 沒有關係，即分
"組數不會隨著 | 的正則式選擇不同而改變
FIND REGEX '(((a).)|([ab]+))' IN 'oooababboo'
     MATCH OFFSET moff
     MATCH LENGTH mlen
     SUBMATCHES s1 s2 s3 s4.
WRITE: / 's1=',s1,'s2=',s2,'s3=',s3,'s4=',s4, / moff,mlen.

s1= ababb s2=  s3=  s4= ababb

         3           5

DATA: result_tab TYPE match_result_tab.
FIND ALL OCCURRENCES OF REGEX `((ab)|(ba))`
IN 'abba'
     RESULTS result_tab.

因為正則表示式中的子分組使用或連線的，每次匹配過程中，雖然有3個子分組，但每次只有其中某兩個才能真正匹配上。

匹配部分分組(SUBMATCHES )

DATA: moff TYPE i,
        mlen TYPE i,
        s1   TYPE string,
        s2   TYPE string.
  FIND REGEX `((\w+)\W+\2\W+(\w+)\W+\3)`
       IN `Hey hey, my my, Rock and roll can never die`
       IGNORING CASE
       MATCH OFFSET moff
       MATCH LENGTH mlen
       SUBMATCHES s1 s2."根據從外到內，從左到右的括號順序依次儲存到s1 s2…中，注：取出部分一定要使用括號括起來，即使是取出匹配整個正則式的部分也得括起來，這與Java不同，正則式外層預設情況下是沒有括號括起來，但Java預設情況下整體就是一個分組，且是第0分組，但ABAP是從1開始編號子分組的（指使用括號括起來的才算，如果整個正則式未使用括號，則不會算做一個子分組）
  WRITE: /  s1, / s2,/ moff ,/ mlen.

Hey hey, my my

Hey

         0

        14

匹配所有分組(RESULTS result_tab)公共函式

START-OF-SELECTION.
  DATA: result TYPE STANDARD TABLE OF string WITH HEADER LINE .
  "與Java不同，只要是括號括起來的都稱為子匹配（即整體也得用括號括起來了），不管括號巢狀多少層，統
  "稱為子匹配，且匹配到的所有子串都會儲存到MATCH_RESULT-SUBMATCHES中，
  "即使最外層的括號匹配子串也會儲存到SUBMATCHES內表中。括號解析的順序為：
  "從外到內，從左到右的優先順序順序來解析匹配結構。Java中的group(0)儲存的
  "是整體匹配串，即使整體未（或使用）使用括號括起來
  PERFORM get_match TABLES result 
          USING '20110921' '^(((\d{2})(\d{2}))(\d{2})(\d{2}))$'.
  LOOP AT result .
    WRITE: / result.
  ENDLOOP.

FORM get_match  TABLES p_result"預設會帶表頭
                USING    p_str
                         p_reg.
  DATA: result_tab TYPE match_result_tab WITH HEADER LINE.
  DATA: subresult_tab TYPE submatch_result_tab WITH HEADER LINE.

"注意：帶表頭時 result_tab 後面一定要帶上中括號，否則啟用時出現奇怪的問題
  FIND ALL OCCURRENCES OF REGEX p_reg IN p_str RESULTS result_tab[].
  LOOP AT result_tab .
    p_result = p_str+result_tab-offset(result_tab-length).
    APPEND p_result.
    subresult_tab[] = result_tab-submatches.
    LOOP AT subresult_tab.
      p_result = p_str+subresult_tab-offset(subresult_tab-length).
      APPEND p_result.
    ENDLOOP.
  ENDLOOP.
ENDFORM.

20110921

20110921

2011

20

11

09

21

REPLACE

REPLACE [{FIRST OCCURRENCE}|{ALL OCCURRENCES} OF]

{[SUBSTRING] sub_string} | {REGEX regex}
        IN [SECTION [OFFSET off] [LENGTH len] OF] dobj

WITH new
        [IN {BYTE|CHARACTER} MODE]
        [{RESPECTING|IGNORING} CASE]
        [REPLACEMENT COUNT rcnt]
        { {[REPLACEMENT OFFSET roff]
           [REPLACEMENT LENGTH rlen]}
        | [RESULTS result_tab|result_wa] }.

語法與FIND相似。

如果new尾部空格需要保留，則要使用String型別的new，其他固定長度型別的new字元，會忽略掉尾部空格。

{FIRST OCCURRENCE}|{ALL OCCURRENCES} OF

FIRST OCCURRENCE或者未指定時，只替換第一次匹配的；ALL OCCURRENCES則替換所有子匹配串

{[SUBSTRING] sub_string} | {REGEX regex}

[SUBSTRING] sub_string：以固定的字串為匹配模式進行搜尋並替換，與前面替換指定的字串的REPLACE是一樣的。

FIRST OCCURRENCE或者未指定時，如果sub_string是空String型別的字串或者內容為空格的固定長度型別（c, d, n, or t）的字串時，sub_string將會被看作是empty 型別的字串，並且查詢替換的位置將定位到dobj的首字元前，並且將new插入到dobj最前面。但如果sub_string是空字串（包括字元型別字串型別），使用ALL OCCURRENCES選項，則會拋異常。

sub_string為固定長度型別的字串時，尾部空格將被忽略（這與老式的REPLACE規則不同），如果不想忽略尾部空格，則使用String型別的sub_string。

REGEX regex：使用正則表示式進行匹配替換。

regex不允許為空String型別的字串或者內容只有空格的固定長度型別（c, d, n, or t）的字串。

DATA text TYPE string VALUE '-uu-'.
"U*表示0個或多個U，當為0個時，字元間的空隙就相匹配"U*與UU相匹配，替換的結果為第三個 x
REPLACE ALL OCCURRENCES OF REGEX 'u*' IN text WITH 'x'.
WRITE:/ text.

x-xx-x

IN [SECTION [OFFSET off] [LENGTH len] OF] dobj

如果未加上SECTION選項，將對整個dobj字串進行匹配替換操作。如果指定了SECTION選項，則OFFSET與LENGTH必須選擇一個。如果指定如果指定了OFFSET，但未指定LENGTH時，替換的區域從OFFSET到dobj的最後；如果指定了LENGTH，但未指定OFFSET時，OFFSET將隱含為0。OFFSET與LENGTH需要大於或等於0，通過OFFSET與LENGTH定位到的子字串段必須要位於dobj裡。該選項與前面替換某個區間上的字串的REPLACE是一樣的，與FIND也相同。