字符串處理語句、函數

``：表示的是一個empty字符，屬於String類型，但若是將它賦值給一個C(1)類型變量後，感受 `` 是一個空格，這實質上是一種誤解，這是由於 `` 自己是一個 empty 字符（表示什麼也沒有，即沒有任何內容），但若是此時賦值給一個 C(1) 類型的變量時，會發生基本類型賦值規則轉換：String→C（按此轉換規則，源String字段長度爲0，因此使用空格來填充目標C字段）

0 1 0 0 0 0

爲何''=`` ?

''屬於固定長度的C類型字符串，而``屬於變量的String類型字符串，當`` = ''放在if語句中進行比較時，會發生類型轉換（轉換規則爲不一樣類型數據之間的轉換）：至關於將C(1)固定長度字符串（內容爲一個空格）轉換爲String類型變量字符串，在轉換過程當中按C→String規則：尾部空格會去掉（至關於 str = ''，最後仍是一個empty字符串），因此`` = ''爲真，這也解釋了爲何strlen( '' ) = 0 而不是等於1爲緣由（由於在計算前''也會轉換爲 String類型後再進行計算，在轉換過程當中會將C類型字符串尾部空格去掉）。

在給String類型變量賦值時，最好使用``將字符串引發來，這樣尾部空格不會去掉，由於沒有發生類型轉換；而將''單引號引發來的C類型類型串賦值給一個String類型變量時，會發生類型轉換（C類型會轉換爲String），在轉換過程當中會忽略C類型尾部空格。

字符型字面常量(Text Symbols文本符號)

字符型字面常量是使用單引號''起來的字符串，它其實是一種C類型的字面常量，因此賦值給C類型的變量時，不會發生類型轉換什麼的。注：沒有空的字符型字面常量，也就是說，即便使用'' 來想表達「空」的概念，也是不容許的，它實質上是一個空格的字面常量，即與' '徹底相同

使用兩個單引號''引發來的字符型字面常量的個數必定不能超過255個，不然編譯不能經過。若是須要將多個字符型字面常量鏈接起來看成一個字符型常量，則可使用&字符將多個使用單引號（注：使用&鏈接的串要麼是字符型字面常量——使用單引號引發來的串，要麼是字符串型字面常量——使用反引號引發來的串，二者不能混着使用，不然編譯不能經過）引發來的字符型字面常量鏈接起來，但整體的長度仍是不能大於255個

文本符號

若是使用單引號''（不是``）引發來的字面常量後面跟了三位數編號，則會先去所對應程序的文本符號中去找這個編號對應的文本是否存在，若是存在則使用文本符號中的文本，不然使用單引號''中的字面常量：

或者上圖中使用WRITE: text-001.效果也是同樣的

字符串型字面常量

字符型字面常量是使用反引號``引發來的字符串，它是一種String類型的字面常量。若是兩個反引號之間沒有任何內容，即 `` 表示是一個長度爲0的空字符串，這與兩個單引號''之間沒有任何內容但實質上仍是有一個空格是有區別的。

使用兩個反引號``引發來的字符串型字面常量的個數必定不能超過255個，不然編譯不能經過。若是須要將多個字符串型字面常量鏈接起來看成一個字符串型常量，則可使用&字符將多個使用反引號（注：使用&鏈接的串要麼是字符型字面常量——使用單引號引發來的串，要麼是字符串型字面常量——使用反引號引發來的串，二者不能混着使用，不然編譯不能經過）引發來的字符串型字面常量鏈接起來，但整體的長度仍是不能大於255個

C(1)空字符

split拆分字符串

SPLIT dobj AT sep INTO

{ {result1 result2 ...} | {TABLE result_tab} }

[IN {CHARACTER|BYTE} MODE].

要將全部部分放到不一樣目標字段中，必須指定足夠目標字段。不然，用字段dobj的剩餘部分填充最後目標字段幷包含分界符。

若是全部目標字段足夠長且沒必要截斷任何拆分的字符串就能夠容納，則將 SY-SUBRC 設置爲0。

DATA: string(60),
      p1(20) VALUE '++++++++++++++++++++',
      p2(20) VALUE '++++++++++++++++++++',
      p3(20) VALUE '++++++++++++++++++++',
      p4(20) VALUE '++++++++++++++++++++',
      del(3) VALUE '***'.
string = ' Part 1 *** Part 2 *** Part 3 *** Part 4 *** Part 5'.
WRITE string.
SPLIT string AT del INTO p1 p2 p3 p4.
WRITE / p1.
WRITE / p2.
WRITE / p3.
WRITE / p4.

Part 1 *** Part 2 *** Part 3 *** Part 4 *** Part 5

Part 1

Part 2

Part 3

Part 4 *** Part 5

能夠將拆分的字符串放到一個內表中，這樣就不須要定義多個目標字段了，該內表就比如是一個數組，並且能夠自動增加，而且該內表只有一個組件元素:

DATA: string(60) VALUE ' Part 1 *** Part 2 *** Part 3 *** Part 4 *** Part 5'.
DATA: itab TYPE TABLE OF string,wa like LINE OF itab.
SPLIT string AT '***' INTO TABLE itab .
LOOP AT itab INTO wa.
WRITE: / wa.
ENDLOOP.

Part 1

Part 2

Part 3

Part 4

Part 5

segment()函數

segment( val = text index = idx [sep|space = sep] )

根據指定的字符串sep或者指定的字符sapce來將text拆分，並返回第idx（從1開始）個片段

sep：爲分隔字符串，整個sep會看成分界符，若是text中兩個sep分隔字符串緊挨着時，empty segment is created and an empty string is returned for this segment

space：與sep不一樣的是，sapce是一個字符集，分隔符不是整個sapce，而是sapce裏的每一個字符都是一個分界符，即分界符是單個字符，只不過sapce能夠同時指定多個分隔符組成一個字符集。另外，與sep不一樣的是，若是sapce中指定的分隔符緊挨着時，no empty segment is created and no result is returned.

DATA: result TYPE string,
      text TYPE string VALUE 'AB\brCD\br\brEF\brGH'.
WRITE: text.
NEW-LINE.
DO.
TRY.
      result = segment( val   = text
                        index = sy-index "返回第幾個片段，從1開始，不能越界，不然拋異常
                        sep = `\br` ).
      WRITE: result.
    CATCH cx_sy_strg_par_val.
      EXIT.
ENDTRY.

ENDDO.

NEW-LINE.
text = 'AB CD - EF _   - GH'.
WRITE: / text.
NEW-LINE.
DO.
TRY.
      result = segment( val   = text
                        index = sy-index
                        space = ` -_` )."三個分隔符
      WRITE: result.
    CATCH cx_sy_strg_par_val.
      EXIT.
ENDTRY.
ENDDO.

AB\brCD\br\brEF\brGH

AB CD EF GH

AB CD - EF _ - GH

AB CD EF GH

shift字符串移動

默認狀況下，對於固定長度字符串類型，shift產生的空位會使用空格或十六進制的0（若是爲X類型串時）來填充。

SHIFT dobj [

{[{BY num PLACES}|{UP TO sub_string}][[LEFT|RIGHT] [CIRCULAR]]}

{ {LEFT DELETING LEADING}|{RIGHT DELETING TRAILING} } pattern

]
[IN {BYTE|CHARACTER} MODE].

注：若是dobj爲X或XString時，則只能使用IN BYTEMODE

BY num PLACES：

若是指定移動的位數大於了源字符串長度或等於0，則源字符串不會發生改變。

UP TO sub_string：

若是找到子串，則sy-subrc = 0，不然爲4。

將源字符串移動到指定的子字符串位置，要注意的是向右移動時，固定長度類型字符串與String結果是不同（String類型右移後不會被截斷，只是字串前面補相應數量的空格）。

DATA text TYPE string .
text = `I know you know `.
WRITE: / text.
SHIFT text UP TO 'you' LEFT.
WRITE: / text.
text = `I know you know `.
"因爲是字符串類型，其長度不是固定的，因此向右移動時，不會截斷子串後面的字符串，但若是是C類型時，則會截斷
SHIFT text UP TO 'you' RIGHT.
WRITE: / text.
DATA text2(16) TYPE c VALUE `I know you know `.
SHIFT text2 UP TO 'you' RIGHT.
WRITE: / text2.

I know you know

you know

I know you know

I know you

[LEFT|RIGHT][CIRCULAR]：

若是未指定LEFT or RIGHT，則默認爲LEFT。CIRCULAR選項將移出的字符串放在左邊或者左邊。

對於String與Xstring類型，使用左移時而且若是未指定CIRCULAR，字符串將會被縮短，但右移後會延長（縮短與延長的長度與左移或右移的位數相同）。

DATA text TYPE string VALUE `I know you know `.
WRITE: / text.
SHIFT text UP TO 'you' LEFT CIRCULAR.
WRITE: / text.
text = `I know you know `.
SHIFT text UP TO 'you' RIGHT CIRCULAR.
WRITE: / text.

I know you know

you know I know

know I know you

{ {LEFT DELETING LEADING}|{RIGHT DELETING TRAILING} } pattern：

向左移出前導（或向右移出尾部）匹配pattern模式的字符串（只要前導或尾部字符在指定的pattern字符集裏就會被去掉，直到第一個不在模式pattern的字符止）。右移後前面會補空格，左移後後面是否被空格要看是不是固定長度類型的字符串仍是變長的String類型串（左移後String類型串會縮短）。

DATA text TYPE string VALUE `I know you know`.
WRITE: / text.
"只要是 [no kw] 這五個字符都會被去掉
SHIFT text RIGHT DELETING TRAILING 'no kw'.
WRITE: / text.
text = `I know you know`.
SHIFT text LEFT DELETING LEADING 'kI '.
WRITE: / text.

I know you know

I know you

now you know

replace字符串替換

返回碼：

0 ——替換成功，而且結果未被截斷

2 ——替換成功，但結果右邊被截斷

4 ——未找到要替換的字符串

替換指定的字符串（老式的，已過期的）

REPLACE sub_string WITH new INTO dobj
[IN {BYTE|CHARACTER} MODE]
[LENGTH len].

在dobj中查找第一次出現的sub_string字符串。首先在dobj中搜索子串 sub_string 前 len個字符，若是未定長度len，則按sub_string 全長進行搜索；當第一次發現sub_string或sub_string的前len個字符，則sub_string或sub_string的前len字符在字符串dobj中第一次出現的位置用字符串 new替換，若是指定了len，則只替換dobj指定的長度len。

若是未指定長度len，則使用new替換換整個被匹配到的子串；若是len爲0，則匹配到的子串不會被替換，而且替換的內容new 會插入到匹配到的子字符串sub_string的前面；若是len比sub_string要長，默認會等於sub_string長度。

若是sub_string爲空（``）字符串，則會將new插入到dobj最前面；若是爲''，則不會這樣。``表示字符間隙，爲空字符串，而''實際上則表示一個空格：

DATA: text TYPE String VALUE 'aaabbbccc'.
REPLACE '' WITH 'ddd' INTO text.
WRITE: / text.
REPLACE `` WITH 'ddd' INTO text.
WRITE: / text.

aaabbbccc

dddaaabbbccc

若是dobj, sub_string and new的類型爲 c, d, n or t固定長度類型時，尾部的空格將不會被忽略

SY-SUBRC非 0 的返回代碼值意味着未替換，這樣就可使用循環方式替換全部：

DATA name TYPE string.
name = 'Mic-hael-Cheo-ng'.
WHILE sy-subrc = 0.
REPLACE '-' WITH ' ' INTO name.
ENDWHILE.
WRITE / name.

Mic hael Cheo ng

替換某個區間上的字符串

REPLACE SECTION [OFFSET off] [LENGTH len] OF dobj WITH new
[IN {BYTE|CHARACTER} MODE].

OFFSET or LENGTH必需要指定一個，若是指定了OFFSET，但未指定LENGTH時，替換的內容從OFFSET到dobj的最後；若是指定了LENGTH，但未指定OFFSET時，OFFSET將隱含爲0。OFFSET與LENGTH須要大於或等於0，經過OFFSET與LENGTH定位到的子字符串段必需要位於dobj裏。

該函數通常與FIND函數結合使用：

DATA: text1 TYPE string,
      off TYPE i,
      len TYPE i.
text1 = 'I know you know'.
FIND 'know' IN text1 MATCH OFFSET off
                     MATCH LENGTH len.
WRITE: / text1.
REPLACE SECTION OFFSET off LENGTH len OF
      text1 WITH 'should know that'.
WRITE: / text1.

I know you know

I should know that you know

第三種是基於用正則表達式的替換，請參考後面正則表達式REPLACE

replace()函數regex

replace( val = text [off = off] [len = len] with = new )

replace( val = text {sub = substring}|{regex = regex} with = new [case = case] [occ = occ] )

使用new替換指定的子符串，返回String類型。

off、len：offset off and the length len，這兩個至少要輸入一個。若是僅指定off或者指定了len但爲0時，至關於insert()函數；若是僅指定了len或者指定了off但爲0時，會將text開頭的len個字符替換爲new；若是off爲text的長度，則此時的len只能是0或者省略，此時的new會append到text尾部。

occ：替換第幾回出現的子串，若是爲0，則全部出現的都會被替換

另外，若是使用了regex模式，則new中可使用替換模式（如$0 $1 $&…）

DATA: html TYPE string,
 repl TYPE string.

html = `<title>This is the Title</title>`.
WRITE: / html.
repl = `i`.
"repl = `(i)`."結果會是同樣
html = replace( val = html
 regex = repl && `(?![^<>]*>)`"注：SAP反向搜索(?<=...)、(?<!...)目前不支持，只支持正向搜索(?=...)、(?!...)，但Java都支持
 with = `$0`"$0爲匹配到的整個捕獲組，這與Java同樣，因此也能夠將 i 使用()括起來
 occ = 0 ).
WRITE: / html.

<title>This is the Title</title>

<title>This is the Title</title>

search搜索字符串

SEARCH <c> FOR <str> <options>.

該語句在字符串<c>中搜索<str>中的字符串。若是成功，則將 SY-SUBRC 的返回代碼值爲0，並將 SY-FDPOS 設置爲字段<c>中該字符串的位置（字符串索引位置是從0開始的）。

搜索串<str>可爲下列格式之一：

<str>	目的
<pattern>	搜索<pattern>，忽略<pattern>尾部空格。
.<pattern>.	搜索<pattern>，可是不忽略<pattern>尾部空格。
*<pattern>	搜索以<pattern>結尾的詞。
<pattern>*	搜索以<pattern>開始的詞。

單詞之間用空格、逗號、句號、分號、冒號、問號、歎號、括號、斜槓、加號和等號等分隔。

DATA string(30) VALUE 'This is a little sentence.'.
WRITE: / 'Searched', 'SY-SUBRC', 'SY-FDPOS'.
ULINE /1(26).
SEARCH string FOR 'X'.
WRITE: / 'X', sy-subrc UNDER 'SY-SUBRC',
               sy-fdpos UNDER 'SY-FDPOS'.
SEARCH string FOR 'itt   '.
WRITE: / 'itt   ', sy-subrc UNDER 'SY-SUBRC',
                   sy-fdpos UNDER 'SY-FDPOS'.
SEARCH string FOR '.e .'.
WRITE: / '.e .', sy-subrc UNDER 'SY-SUBRC',
                  sy-fdpos UNDER 'SY-FDPOS'.
SEARCH string FOR '*e'.
WRITE: / '*e', sy-subrc UNDER 'SY-SUBRC',
                sy-fdpos UNDER 'SY-FDPOS'.
SEARCH string FOR 's*'.
WRITE: / 's*', sy-subrc UNDER 'SY-SUBRC',
                sy-fdpos UNDER 'SY-FDPOS'.

Searched SY-SUBRC SY-FDPOS

————————————

X 4 0

itt 0 11

.e . 0 15

*e 0 10

s* 0 17

<options>選項：

n ABBREVIATED：在字符串<c>中搜索包含<str>中指定字符串的單詞（<str>比如縮寫），包含<str>的單詞和字符串<str>中的第一個字母必須相同。

n STARTING AT <n1>：在字符串<c>中搜索從<n1>開始的<str>。結果 SY-FDPOS 參照相對於<n1>的偏移量而不是字符的開始。

n ENDING AT <n2>：在字符<c>搜索<str>直到位置<n2>。

n AND MARK：若是找到搜索串，則將搜索串中的全部字符（和使用 ABBREVIATED 時的全部字符）轉換爲大寫形式。

DATA: string(30) VALUE 'This is a fastx first example.',
pos TYPE i,
off TYPE i.
WRITE / string.
"STARTING AT選項是從1開始的，但字符串位置索引是從0開始的
"STARTING AT選項默認就是1，而且查找時從（包括）第1個字符開始

"ENDING AT選項指定的位置結束（也包括），查找時會在這指定的區間（包括兩端）
"進行搜索，若是將下面的14修改爲13則會找到不到
SEARCH string FOR 'fst' ABBREVIATED STARTING AT 1ENDING AT 14.
"與上面語句等價
*SEARCH string FOR 'fst' ABBREVIATED.
"SY-FDPOS的值是指所查找到的位置的索引(若是指定了STARTING AT,則STARTING AT指定位置的字符就表示索引爲0的字符)
WRITE: / 'SY-FDPOS:', sy-fdpos.

"求查找到的首字符在整個字符串中的索引號，注：索引是從0開始的
off = sy-fdpos.
WRITE: / 'Off:', off.
"第二次查找位置從fastx中的a字母（包括）開始的
pos = sy-fdpos + 2.
SEARCH string FOR 'fst' ABBREVIATED STARTING AT pos AND MARK.
WRITE / string.
WRITE: / 'SY-FDPOS:', sy-fdpos, sy-subrc.
off = pos – 1+ sy-fdpos.
WRITE: / 'Off:', off.

This is a fastx first example.

SY-FDPOS: 10

Off: 10

This is a fastx FIRST example.

SY-FDPOS: 5 0

Off: 16

請注意，在找到單詞‘fastx’以後，爲了查找包含‘ft’的第二個單詞，必須在偏移量 SY-FDPOS 上加2（若是是加1仍是找第一個，由於STARTING AT選項在查找時會包括pos位置所在字符），而後從位置 POS 開始查找。不然，會再次找到單詞‘fastx’。要得到‘first’相對於字符串<c>開始的偏移量，則要使用 pos + sy-fdpos – 1 表達式來計算。

contains()函數regex

contains( val = text sub|start|end = substring [case = case] [off = off] [len = len] [occ = occ] )

在text 字符串指定的搜索區域（off開始len個字符）內搜索是否存在substring子串至少occ次，若是是則返回true。start、start分別表示在指定區域的開頭或末尾是否區別（此時occ也可指定，表示在頭或尾連續屢次出現），而sub則能夠出如今指定區域的任何位置。occ默認值都爲0（包括下面其它函數也是）。substring不能爲empty。

case：默認大小寫敏感，X表示區分

contains( val = text regex = regex [case = case] [off = off] [len = len] [occ = occ] )

與上面的contains函數同樣，只不過變成了regex

contains_any_of( val = text sub|start|end = substring [off = off] [len = len] [occ = occ] )

與上面兩個不一樣的是，不會檢查整個substring是否匹配，而是把substring看做是一個字符集，只要這裏的任意一個字符在指定的搜索區域內出現過，就算一次。sub|start|end的意思與上面的同樣

contains_any_not_of( val = text sub|start|end = substring [off = off] [len = len] [occ = occ] )

與contains_any_of函數類似，只不過是相反的，只要substring全部單個字符都不出如今指定搜索區域內時，則算一次

上面這些函數只能使用在 if where 等條件語句中

下面幾個與過去的字符串比較操做符做用相同：

字符串比較操做符	等同於
o1 CO o2	NOTcontains_any_not_of( val = o1 sub = o2 )
o1 CN o2	contains_any_not_of( val = o1 sub = o2 )
o1 CA o2	contains_any_of( val = o1 sub = o2 )
o1 NA o2	NOTcontains_any_of( val = o1 sub = o2 )
o1 CS o2	contains( val = to_upper( o1 ) sub = to_upper( o2 ) )
o1 NS o2	NOT contains( val = to_upper( o1 ) sub = to_upper( o2 ) )

因爲CS、NS是不區分大小寫的，因此先全轉大寫（或小寫）。若是使用函數的形式，則固定長度字符類型的尾部空格會被忽略掉，但字符串比較操做符有可能不太同樣，在使用時需注意。

CP 、NP兩個比較操做符可使用regex的contains函數

DATA html TYPE string.
html = '<body>Text</body>'.
IF contains_any_not_of( val = to_upper( html ) start = sy-abcde ) AND
contains_any_not_of( val = to_upper( html ) end = sy-abcde ).
WRITE:/ '是 HTML 格式的字符串'.
ENDIF.

是 HTML 格式的字符串

matches()函數regex

matches( val = text regex = regex [case = case] [off = off] [len = len] )

text是否與regex匹配（regex表達式要與text徹底匹配，這與contains是不同的）。off與len指定了匹配的區域。

注：該函數與contains函數同樣，也只能在 if where 條件語句中使用。matches()只是判斷是否匹配，返回匹配與否，而matche()函數返回匹配到的子串

IF matches( val = sy-abcde regex = `[A-Z]{26,26}` ).
WRITE: / 'OK'.
ENDIF.

count()函數regex

count( val = text {sub = substring}|{regex = regex} [case = case] [off = off] [len = len] )

匹配指定字符串substring或正則式regex出現的子串次數。返回的類型爲i整型類型

case：是否大小寫敏感。省略時默認是大小寫敏感的。'X'表示區別大小寫，' '表示不區別大小寫

off、len：offset off and the length len，指定了搜索的區域，即從哪裏開始搜索，而且搜索多長

count_any_of( val = text sub = substring [off = off] [len = len] )

匹配指定字符集substring中任意字符的次數。

DATA: text TYPE c LENGTH 120 VALUE `Cathy's cat with the hat sat on Matt's mat.`,
substring TYPE c LENGTH 120 VALUE `oat`.
DATA: result TYPE i.
result = count_any_of( val = text sub = substring ).
WRITE / result .

count_any_not_of( val = text sub = substring [off = off] [len = len] )

匹配指定字符集substring中全部均未出現的字符次數

DATA: text TYPE string VALUE `Cathy's cat with the hat sat on Matt's mat.`,
substring TYPE string VALUE `oat`.
DATA: result TYPE i.
result = count_any_not_of( val = text sub = substring off = 32 ).
WRITE / result .

示例請參數match()函數

find()函數regex

find( val = text {sub = substring}|{regex = regex} [case = case] [off = off] [len = len] [occ = occ] )

查找substring或者匹配regex的子串的位置。返回的類型爲i整型類型。若是未找到，則返回 -1，返回的爲offset，因此從0開始。

occ：表示需匹配到第幾回出現的子串。若是爲正，則從頭日後開始計算，若是爲負，則從尾部向前計算，好比爲1、2時，分別表示只匹配到從左往右數第1次或第2次的子串，若是爲-1、-2時，則分別表示只匹配到從右往左數第1次或第2次的子串。省略時默認只取最開始的第一個。

case、off、len：請參考count()函數相應介紹

find_end( val = text regex = regex [case = case] [off = off] [len = len] [occ = occ] )

與find相似，只不過返回的不是regex匹配到串的開頭字符的offset位置，而是regex匹配到串的末尾字符的offset位置

find_any_of( val = text sub = substring [off = off] [len = len] [occ = occ] )

找出text中出現substring中的任何一個字符的位置offset

DATA: text TYPE c LENGTH 120 VALUE `Cathy's cat with the hat sat on Matt's mat.`,
      substring TYPE c LENGTH 120 VALUE `oat`.
DATA: result TYPE i.
result = find_any_of( val   = text sub = substring )."匹配 a 字符
WRITE / result .
result = find_any_of( val   = text sub = substring off = 17 )."匹配 t 字符
WRITE / result .
result = find_any_of( val   = text sub = substring off = 26 )."匹配 o 字符
WRITE / result .

find_any_not_of( val = text sub = substring [off = off] [len = len] [occ = occ] )

找出text中未出現substring中全部字符集的起始位置offset，與find_any_of對應

DATA: text TYPE c LENGTH 120 VALUE `Cathy's cat with the hat sat on Matt's mat.`,
      substring TYPE c LENGTH 120 VALUE `oat`.
DATA: result TYPE i.
result = find_any_not_of( val   = text sub = substring ).
WRITE / result .
result = find_any_not_of( val   = text sub = substring off = 17 ).
WRITE / result .
result = find_any_not_of( val   = text sub = substring off = 26 ).
WRITE / result .

示例請參數match()函數

match()函數regex

match( val = text regex = regex [case = case] [occ = occ] )

返回的爲匹配到的字符串。注：每次只匹配一個。請注意這個函數與matches()函數的區別

case：請參考count()函數相應介紹

occ：請參考find ()函數相應介紹

DATA: text TYPE c LENGTH 120 VALUE `Cathy's cat with the hat sat on Matt's mat.`,
 regx TYPE c LENGTH 120 VALUE `\<.at\>`."\< Start of a word \> End of a word

DATA: result TYPE i,
 substr TYPE string.
WRITE / text.
NEW-LINE.
result = count( val = text regex = regx ).
DO result TIMES.
result = find( val = text regex = regx occ = sy-index ).
substr = match( val = text regex = regx occ = sy-index ).
result = result + 1.
WRITE AT result substr.
ENDDO.

Cathy's cat with the hat sat on Matt's mat.

cat hat sat mat

condense去除多餘空格

CONDENSE<c> [NO-GAPS].

去除字段<c>中的前導空格（注，由於是C類型，而不是String類型，因此當C類型變量末尾有空格時，去不去空格都同樣，假設去掉了還會補上空格，由於C類型變量是固定寬度；但若是這裏是String類型變量，則還會去除尾部空格），字符串中間的多個連續的空格使用一個空格替換。結果是左對齊單詞，每一個單詞只用一個空格隔開。若是指定附加 NO-GAPS，則字符串中間的全部空格都也都會去除。

DATA: string TYPE string VALUE ' one two three four',
len TYPE i.
len = STRLEN( string ).
WRITE: / string, '!'.
WRITE: / 'Length: ', len.
CONDENSE string.
len = STRLEN( string ).
WRITE: / string, '!'.
WRITE: / 'Length: ', len.
CONDENSE string NO-GAPS.
len = STRLEN( string ).
WRITE: / string, '!'.
WRITE: / 'Length: ', len.

one two three four !

Length: 25

one two three four !

Length: 18

onetwothreefour !

Length: 15

String去除尾部空格

"只有使用反引號``才能保留字符串常量尾部空格
DATA: str TYPE string VALUE ` 1 `,
len TYPE i.
len = strlen( str ).
WRITE: len.
"String類型的字符串前導與後綴空格都會去掉
CONDENSE str.
len = strlen( str ).
WRITE: len.

3 1

condense()函數

condense( [val =] text [del = del] [from = from] [to = to] )

該函數不僅是去除頭尾空格，還能夠去除頭尾指定的指定字符，或者替換字符串是中間指定的字符操做

該函數的兩個做用：

l 去除val頭與尾部指定的del字符，若是del爲空字符（0長度串），則不會刪除（注：這裏的del是一個字符集，只要頭尾出如今del之中的某個或所有字符，都會被刪除掉，而不要求頭或尾徹底與del匹配）

l 將from指定的子串替換成to指定的子串，若是from爲空（0長度串），則不會有字符被替換，若是to爲空（0長度串），則會from子字符串將會被刪除（這裏的from與上面的del也是一個字符集的概念，即不是要求val中間出現與from整個串匹配時才發生替換，而是隻要在val中間出現了from字符集中某個字符一次或某個字符連繼屢次，則會將這個字符或這個字符繼續出現的串替換成一個to指定的字符串）

函數返回的值的類型爲 String

del、from、to的默認值爲空格。

若是del、from、to未指定時，val也能夠省略。

若是del, from, to爲固定類型長度的字符串，則尾部空格會被省略掉

若是del、from、to都指定爲空格字符` `，則與不帶NO-GAPS選項的CONDENSE語句做用是同樣的

DATA: result TYPE string.

result = condense(` abc   def ` ).
WRITE:/ result."abc def
result = condense( val = ` abc   def ` from = `` )."form爲空或不指定時不會發生替換操做
WRITE:/ result."abc   def
result = condense( val = `XXabcXXX1XX2XdefXX` del = 'X1' from = 'X' to = 'W' ).
WRITE:/ result."abcW1W2Wdef

result = condense( val = `XXabcXXX1XX2XdefXX` del = 'X' from = 'X' to = '' ).
WRITE:/ result."abc12def
result = condense( val = `XXabcXXX1XX2XdefXX` del = 'X' from = 'X1' to = 'W' ).
WRITE:/ result."abcW2Wdef
result = condense( val = `XXabcXXX1XX2XdefXX` del = 'X' from = 'XX' to = 'W' ).
WRITE:/ result."abcW1W2Wdef
result = condense( val = `XXabcXXX1XX2XdefXX` del = 'X' from = 'X1X' to = 'W' ).
WRITE:/ result."abcW2Wdef
result = condense( val = ` Rock'xxx'Roller` del = `re ` from = `x` to = `n` ).
WRITE:/ result."Rock'n'Roll

insert()函數

insert( val = text sub = substring [off = off] )

將字符串sub插入到text指定的off位置以前。若是sub爲空（0長度串），則返回原樣的 text。返回的類型爲String

DATA result TYPE string VALUE `XXXXX`.
DO strlen( result ) - 1 TIMES.
result = insert( val = result sub = ` ` off = sy-index * 2 - 1 ).
WRITE: / result.
ENDDO.
result = insert( val = result sub = `W`)."若是未指定off，則會在頭插入
WRITE: / result.

X XXXX

X X XXX

X X X XX

X X X X X

WX X X X X

repeat ()函數

repeat( val = text occ = occ )

將text重複occ次後返回，返回類型爲string。若是val爲空（0長度）字符串或者occ爲0，則返回empty string

返回10個空格：result = repeat( val = ` ` occ = 10 ).

reverse()函數

DATA: result TYPE string.
WRITE:/ sy-abcde.
result = reverse( sy-abcde ).
WRITE:/ result.

ABCDEFGHIJKLMNOPQRSTUVWXYZ

ZYXWVUTSRQPONMLKJIHGFEDCBA

concatenate鏈接字符串

CONCATENATE {dobj1 dobj2 ...}|{LINESOF itab}
            INTO result
            [IN {BYTE|CHARACTER} MODE]
            [SEPARATED BY sep]
            [RESPECTING BLANKS].

能夠對內錶行進行拼接

若是結果被result容納，則將 SY-SUBRC 設置爲0。然而，若是結果被截斷（result不能容納整個結果時），則將 SY-SUBRC設置爲4。防止截斷，應該定義成String類型。

字符串尾部空格處理

fixed length (c, d, n, and t or structures regarded as character-type),前導空格會保留，尾部空格都會被去掉，但這個對String類型的字符串是個例外：全部空格都會保留。

CONCATENATE函數對於c, d, n, and t類型的字符串有一個RESPECTING BLANKS選項可以使用，表示尾部空格也會保留（使用``對String類型進行賦值時纔會保留尾部空格，兩個單引號中尾部空格不能成功賦值給String類型變量，由於使用單引號引發來的串尾部的空格的字符賦給一個變長字符串時，是不能賦值過去的，編譯與運動時就會自動去掉）

DATA: c1(10) VALUE 'Sum',
      c2(3)   VALUE 'mer',
      c3(5)   VALUE 'holi ',
      c4(10) VALUE 'day',
      c5(30),
      sep(3) VALUE ' - '.
CONCATENATE c1 c2 c3 c4 INTO c5.
WRITE c5.
CONCATENATE c1 c2 c3 c4 INTO c5 SEPARATED BY sep.
WRITE / c5.

Summerholiday

Sum - mer - holi – day

在鏈接字符串時，若是是固定長度類型的字符串，尾部的空格會被自動的去掉，若是是變長類型的字符串，如尾部有空格時則會保留。

DATA: str1 TYPE string VALUE ` 1 `,str2 TYPE string VALUE ' 2 ', str3 TYPE string VALUE ` 3 `,str4 TYPE string,str5(8).
CONCATENATE str1 str2 str3 INTO str4.
CONCATENATE str1 str2 str3 INTO str5.
WRITE: str4,/ str5.結果是同樣的

1 2 3

concat_lines_of()函數

concat_lines_of( [table =] itab [sep = sep] )

將內表itab的全部行經過sep連接起來，itab須要是索引表，而且行flat結構字符類型（CNDTString）

若是沒有指定sep，則會直接將全部行直接連接起來。若是sep與itab行類型爲固定長字符類型，則尾部空格會被忽略

DATA: BEGIN OF itab OCCURS 0,
a,
b,
END OF itab,
result TYPE string.

APPEND 'ab' to itab.
APPEND 'cd' to itab.
result = concat_lines_of( table = itab[] sep = ` ` ).
WRITE:result.

ab cd

strlen、Xstrlen得到字符串長度

In ABAP, the trailing blanks are taken into account for source fields of type string but not for data objects of type c.

在ABAP中，String類型的尾部空格會計入字符個數中，但C類型的變量尾部空格不會計算入。

strlen：對於固定長度的字符串 C、D、T、N，會忽略尾部空格，但String類型的尾部空格不會忽略。

DATA: int TYPE i,
      word1(20) VALUE '12345',
      word2(20),
      word3(20) VALUE '   4         '.
int = STRLEN( word1 ). WRITE   int.
int = STRLEN( word2 ). WRITE / int.
int = STRLEN( word3 ). WRITE / int.

DATA:
   c_field(5)       TYPE c VALUE '12345',"10個字節
   x_field(5)       TYPE x VALUE '1234567890',"5個字節
   len1             TYPE i,
   len2             TYPE i,
   c_field_off(5)   TYPE c,
   x_field_off(5)   TYPE x.

*Length calculate
len1 = STRLEN( c_field )."以字符爲單位進行計算
len2 = XSTRLEN( x_field )."以字節爲單位進行計算

*Off and leng : 2(2)
c_field_off = c_field+2(2)."取兩個字符（四個字節）
x_field_off = x_field+2(2)."取兩個字節

*output
WRITE:/ 'value', 30 'length'.
ULINE.
WRITE:/ c_field, 30 len1.
WRITE:/ x_field, 30 len2.
SKIP 1.
ULINE.
WRITE:/ 'old value', 30 'field+2(2)'.
ULINE.
WRITE:/ c_field, 30 c_field_off.
WRITE:/ x_field, 30 x_field_off.

value length

12345 5

1234567890 5

old value field+2(2)

12345 34

1234567890 5678000000

substring()函數regex

substring( val = text [off = off] [len = len] )

offset off（從零開始）與len至少輸入一個

substring_from( val = text {sub = substring}|{regex = regex} [case = case] [occ = occ] [len = len] )

截取從找到的substring或者regex子串的offset位置到offset+len位置的子串（因此最後的結果是包括了substring或者regex子串），若是substring沒有找到，則會返回empty String

case：是否大小寫敏感。省略時默認是大小寫敏感的。'X'表示區別大小寫，' '表示不區別大小寫

len:表示要截取的substring個數。若是len沒有指定，則會截取到text的末尾

occ：表示找第幾回與substring或者regex匹配的位置。若是爲正，則從頭日後開始計算，若是爲負，則從尾部向前計算，好比爲1、2時，分別表示只找從左往右數第1次或第2次找到的位置，若是爲-1、-2時，則分別表示只找從右往左數第1次或第2次找到的位置。省略時默認只取最左邊第一個找到的位置。

substring_after( val = text {sub = substring}|{regex = regex} [case = case] [occ = occ] [len = len] )

與substring_from同樣，只不過是從找到的substring或regex串的後面位置開始（最後的結果不包括substring或者regex子串），向後取len個字符的子串

substring_before( val = text {sub = substring}|{regex = regex} [case = case] [occ = occ] [len = len] )

與substring_from同樣，只不過是從找到的substring或regex串的最前面位置開始（最後的結果不包括substring或者regex子串），向前取len個字符的子串。若是沒有指定len，則取到text開頭爲止

substring_to( val = text {sub = substring}|{regex = regex} [case = case] [occ = occ] [len = len] )

與substring_from相同，只不過是取substring或者regex子串的前面len個，並包括substring或者regex子串

DATA result TYPE string.

result = substring( val = 'ABCDEFGH' off = 0 len = 2 ).
WRITE:/ result.
result = substring_from( val = 'ABCDEFGH' sub = 'CD' ).
WRITE:/ result.
result = substring_after( val = 'ABCDEFGH' sub = 'CD' ).
WRITE:/ result.
result = substring_before( val = 'ABCDEFGH' sub = 'CD' ).
WRITE:/ result.
result = substring_to( val = 'ABCDEFGH' sub = 'CD' ).
WRITE:/ result.
result = substring_from( val = 'ABCDEFCDGH' sub = 'CD' occ = 2 ).
WRITE:/ result.

CDEFGH

EFGH

ABCD

CDGH

cmax()、cmin()函數

cmax|cmin( val1 = text1 val2 = text2 [val3 = text3] ... [val9 = text9] )

取val1……val9之間最大或最小的子符串。val1、val2 必需有。最多支持9個

DATA: txt TYPE string,
           max TYPE string,
           min TYPE string,
           msg TYPE string.
txt = `one two three four five six seven eight nine ten`.
max = | |.
min = |§|.
DO.
TRY.
      max = cmax( val1 = max"找最大的
                  val2 = segment( val   = txt
                                  index = sy-index sep = ` ` ) ).
      min = cmin( val1 = min"找最小的
                  val2 = segment( val   = txt
                                  index = sy-index sep = ` ` ) ).
    CATCH cx_sy_strg_par_val.
      EXIT.
ENDTRY.
ENDDO.
msg = |Maximum is { max } and minimum is { min }|.
WRITE:/ msg.

Maximum is two and minimum is eight

translate轉換大/小寫、單個字符替換

TRANSLATE <c> TO UPPER CASE.

TRANSLATE <c> TO LOWER CASE.

TRANSLATE <c> USING <r>.該語句根據字段<r>中存儲的替換規則替換字段<c>的全部字符。<r>包含成對字母，其中每對的第一個字母用第二個字母替換。

DATA: t(11) VALUE 'AbCdEfGhIjA',
string LIKE t,
rule(20) VALUE 'AxbXCydYEzfZ'.
string = t.
WRITE string.
TRANSLATE string TO UPPER CASE.
WRITE / string.
string = t.
TRANSLATE string TO LOWER CASE.
WRITE / string.
string = t.
TRANSLATE string USING rule.
WRITE / string.

AbCdEfGhIjA

ABCDEFGHIJA

abcdefghija

xXyYzZGhIjx

to_upper,to_lower()函數

to_upper( [val =] text )

將全部字母變大寫

to_lower( [val =] text )

將全部字母變小寫

overlay覆蓋對應位置上的字符

OVERLAY <c1> WITH <c2> [ONLY <str>].

該語句用<c2>中的字母覆蓋<c1>中相應位置上的字母，若是指定了<str>，則只覆蓋在<str>中出現過的字母，若是省略 ONLY <str>，則<c1>中全部空格字符將被<c2>中對應位置上的字母所替換。

只要有一個字母被覆蓋，SY-SUBRC 爲 0。對於全部其它狀況，將SY-SUBRC 設置爲 4。若是<c1>比<c2>長，則只覆蓋<c2>中的長度。

注：這不是替換字符串，它是將<c2>與<c1>對應位置（<c2>中的第1個字符被<c1>中的第1字符所覆蓋）上的字符進行一個個覆蓋。

DATA: t(10) VALUE 'a c e g i ',
      string LIKE t,
      over(10) VALUE 'ABCDEFGHIJ',
      str(2) VALUE 'ai'.
string = t.
WRITE string.
WRITE / over.
OVERLAY string WITH over.
WRITE / string.
string = t.
OVERLAY string WITH over ONLY str.
WRITE / string.