SAPhtml

——ABAP/4 技术总结 V3.0java

2014-10-14node

--江正军git

1.   基础

1.1.  基本数据类型

C、N、D、T、I、F、P、X、string、Xstring

P：默认为8字节，最大容许16字节。最大整数位：16*2 = 32 - 1 = 31 -14(容许最大小数位数) = 17位整数位

1.1.1.P类型(压缩型)数据

是一种压缩的定点数，其数据对象占据内存字节数和数值范围取定义时指定的整个数据大小和小数点后位数，若是不指定小数位，则将视为I类型。其有效数字位大小能够是从1~31位数字（小数点与正负号占用一个位置，半个字节），小数点后最多容许14个数字。

P类型的数据，可用于精确运算（这里的精确指的是存储中所存储的数据与定义时字面上所看到的大小相同，而不存在精度丢失问题——看到的就是内存中实实在在的大小）。在使用P类型时，要先选择程序属性中的选项 Fixed point arithmetic（即定点算法，通常默认选中），不然系统将P类型看用整型。其效率低于I或F类型。

"16 * 2 = 32表示了整个字面意义上容许的最大字面个数，而14表示的是字面上小数点后面容许的最大小数位，而不是指14个字节，只有这里定义时的16才表示16个字节

DATA: p(16) TYPE p DECIMALS 14 VALUE '12345678901234567.89012345678901'.

"正负符号与小数点固定要占用半个字节，一个字面上位置，并包括在这16个字节里面。
"16 * 2 = 32位包括了小数点与在正负号在内
"在定义时字面上容许最长能够达到32位，除去小数点与符号需占半个字节之后
"有效数字位可容许31位，这31位中包括了整数位与小数位，再除去定义时小
"数位为14位外，整数位最多还可达到17位，因此下面最多只能是17个9
DATA: p1(16) TYPE p DECIMALS 14 VALUE '-99999999999999999'.

"P类型是以字符串来表示一个数的，与字符串不同的是，P类型中的每一个数字位只会占用4Bit位，因此两个数字位才会占用一个字节。另外，若是定义时没有指定小数位，表示是整型，但小数点固定要占用半个字节，因此不带小数位与符号的最大与最小整数以下（最多容许31个9，而不是32个）
DATA: p1(16) TYPE p  VALUE '+9999999999999999999999999999999'.
DATA: p2(16) TYPE p  VALUE '-9999999999999999999999999999999'.

其实P类型是以字符串形式来表示一个小数，这样才能够做到精确，就像Java中要表示一个精确的小数要使用BigDecimal同样，不然会丢失精度。

DATA: p(9) TYPE p DECIMALS 2 VALUE '-123456789012345.12'.
WRITE: / p."123456789012345.12-

DATA: f1 TYPE f VALUE '2.0',
      f2 TYPE f VALUE '1.1',
      f3 TYPE f.
f3  =  f1 - f2."不能精确计算
"2.0000000000000000E+00 1.1000000000000001E+00 8.9999999999999991E-01
WRITE: / f1   , f2 , f3.

DATA: p1 TYPE p DECIMALS 1 VALUE '2.0',
      p2 TYPE p DECIMALS 1 VALUE '1.1',
      p3 TYPE p DECIMALS 1.
p3  =  p1 - p2."能精确计算
WRITE: / p1   , p2 , p3. "2.0               1.1               0.9

Java中精确计算：

    publicstaticvoid main(String[] args) {

        System.out.println(2.0 - 1.1);// 0.8999999999999999

        System.out.println(sub(2.0, 0.1));// 1.9

    }

    publicstaticdouble sub(double v1, double v2) {

        BigDecimal b1 = new BigDecimal(Double.toString(v1));

        BigDecimal b2 = new BigDecimal(Double.toString(v2));

        return b1.subtract(b2).doubleValue();

    }

1.2.TYPE、LIKE

透明表（还有其它数据词典中的类型，如结构）便可看做是一种类型，也可看做是对象，因此便可使用TYPE，也能够使用LIKE：

TYPES type6 TYPE mara-matnr.
TYPES type7 LIKE mara-matnr.
DATA obj6 TYPE mara-matnr.
DATA obj7 LIKE mara-matnr.

"SFLIGHT为表类型
DATA plane LIKE sflight-planetype.
DATA plane2 TYPE sflight-planetype.
DATA plane3 LIKE sflight.
DATA plane4 TYPE sflight.
"syst为结构类型
DATA sy1 TYPE syst.
DATA sy2 LIKE syst.
DATA sy3 TYPE syst-index.
DATA sy4 LIKE syst-index.

注：定义的变量名千万别与词典中的类型相同，不然表面上便可使用TYPE也可以使用LIKE，就会出现这两个关键字（Type、Like）均可用的奇怪现像，下面是定义一个变量时与词典中的结构同名的后果（致使）

DATA : BEGIN OF address2,
  street(20) TYPE c,
  city(20) TYPE c,
END OF address2.
DATA obj4 TYPE STANDARD TABLE OF address2."这里使用的实质上是词典中的类型address2
DATA obj5 LIKE STANDARD TABLE OF address2."这里使用是的上面定义的变量address2

上面程序编译经过，按理obj4定义是经过不过的（只能使用LIKE来引用另外一定义变量的类型，TYPE是不能够的），但因为address2是数字词典中定义的结构类型，因此obj4使用的是数字词典中的结构类型，而obj5使用的是LIKE，因此使用的是address2变量的类型

1.3.  DESCRIBE

DESCRIBE FIELD dobj 
  [TYPE typ [COMPONENTS com]] 
  [LENGTH ilen IN {BYTE|CHARACTER} MODE] 
  [DECIMALS dec] 
  [OUTPUT-LENGTH olen] 
  [HELP-ID hlp] 
  [EDIT MASK mask].

DESCRIBE TABLE itab [KIND knd] [LINES lin] [OCCURS n].

1.4.字符串表达式

能够使用&或&&将多个字符模板串连接起来，能够突破255个字符的限制，下面两个是等效的：

|...| &  |...|

|...| && |...|

若是内容只有字面常量文本（没有变量表达式或控制字符\r \n \t），则不须要使用字符模板，可这样（若是包含了这些控制字符时，会原样输出，因此有这些控制字符时，请使用 |...|将字符包起来）：

`...` && `...`

可是上面3个与下面3个是不同的：

`...` &  `...`

'...' &  '...'

'...' && '...'

上面前两个仍是会受255个字符长度限制，最后一个虽然不受255限制，但尾部空格会被忽略

字面常量文本（literal text）部分，使用 ||括起来，不能含有控制字符（如 \r \n \t这些控制字符），特殊字符 |{ } \须要使用 \进行转义：

txt = |Characters \|, \{, and \} have to be escaped by \\ in literal text.|.

字符串表达式：

str = |{ ( 1 + 1 ) * 2 }|."算术计算表达式
str = |{ |aa| && 'bb' }|."字符串表达式

str = |{ str }|."变量名

str = |{ strlen( str ) }|."内置函数

1.5.  Data element、Domain

数据元素是构成结构、表的基本组件，域又定义了数据元素的技术属性。Data element主要附带Search Help、Parameter ID、以及标签描述，而类型是由Domain域来决定的。Domain主要从技术方面描述了Data element，如Data Type数据类型、Output Length输出长度、Convers. Routine转换规则、以及Value Range取值范围

将技术信息从Data element提取出来为Domain域的好处：技术信息造成的Domain能够共用，而每一个表字段的业务含意不同，会致使其描述标签、搜索帮助不同，因此牵涉到业务部分的信息直接Data element中进行描述，而与业务无关的技术信息部分则分离出来造成Domain

1.6.  词典预约义类型与ABAP类型映射

当你在ABAP程序中引用了ABAPDictionary，则预置Dictionary类型则会转换为相应的ABAP类型，预置的Dictionary类型转换规则表以下：

这里的“容许最大长度m”表示的是字面上容许的字符位数，而不是指底层所占内存字节数，如

int1的取值为0~255，因此是3位（不包括符号位）

int2的取值为-32768~32767，因此是5位

lLCHR and LRAW类型容许的最大值为INT2 最大值

lRAWSTRING and STRING 具备可变长度，最大值能够指定，但没有上限

lSSTRING 长度是可变的，其最大值必须指定且上限为255。与CHAR类型相比其优点是它与ABAP type string进行映射。

这些预置的Dictionary类型在建立Data element、Domain时能够引用

在Unicode系统中，一个字符占两个字节

1.7.字符串处理

SPLIT dobj AT sep INTO { {result1 result2 ...} | {TABLE result_tab} }必须指定足够目标字段。不然，用字段dobj的剩余部分填充最后目标字段并包含分界符；或者使用内表动态接收

SHIFT dobj {[{BY num PLACES}|{UP TO sub_string}][[LEFT|RIGHT][CIRCULAR]]}
           | { {LEFT DELETING LEADING}|{RIGHT DELETING TRAILING} } pattern

对于固定长度字符串类型，shift产生的空位会使用空格或十六进制的0（若是为X类型串时）来填充

向右移动时前面会补空格，固定长度类型字符串与String结果是不同：String类型右移后不会被截断，只是字串前面补相应数量的空格，但若是是C类型时，则会截断；左移后后面是否被空格要看是不是固定长度类型的字符串仍是变长的String类型串，左移后C类型会补空格，String类型串不会（会缩短）

CIRCULAR：将移出的字符串放在左边或者左边

pattern：只要前导或尾部字符在指定的pattern字符集里就会被去掉，直到第一个不在模式pattern的字符止

CONDENSE <c> [NO-GAPS].若是是C类型只去掉前面的空格（由于是定长，即便后面空格去掉了，左对齐时后面会补上空格），若是是String类型，则后面空格也会被去掉；字符串中间的多个连续的空格使用一个空格替换(String类型也是这样)；NO-GAPS：字符串中间的全部空格都也都会去除(String类型也是这样)；空格去掉后会左对齐[kənˈdens] 

CONCATENATE {dobj1 dobj2 ...}|{LINES OF itab}[kənˈkatɪneɪt]
            INTO result
            [SEPARATED BY sep]
            [RESPECTING BLANKS].

CDNT类型的前导空格会保留，尾部空格都会被去掉，但对String类型全部空格都会保留；对于c, d, n, t类型的字符串有一个RESPECTING BLANKS选项可以使用，表示尾部空格也会保留。注：使用 `` 对String类型进行赋值时才会保留尾部空格  字符串链接能够使用 && 来操做，具体请参考这里

strlen(arg)、Xstrlen(arg)String类型的尾部空格会计入字符个数中，但C类型的变量尾部空格不会计算入

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

count( val = TEXT {sub = substring}|{regex = regex} )匹配指定字符串substring或正则式regex出现的子串次数，返回的类型为i整型类型

contains( val = TEXT REGEX = REGEX)是否包含。返回布尔值，注：只能用在if、While等条件表达式中

matches( val = TEXT REGEX = REGEX)regex表达式要与text彻底匹配，这与contains是不同的。返回布尔值，也只能用在if、While等条件表达式中

match( val = TEXT REGEX = REGEX occ = occ)返回的为匹配到的字符串。注：每次只匹配一个。occ：表示需匹配到第几回出现的子串。若是为正，则从头日后开始计算，若是为负，则从尾部向前计算

find( val = TEXT {sub = substring}|{regex = regex}[occ = occ] )查找substring或者匹配regex的子串的位置。若是未找到，则返回 -1，返回的为offset，因此从0开始

FIND ALL OCCURRENCES OF REGEX regex IN  dobj
  [MATCH COUNT  mcnt]   成功匹配的次数
  { {[MATCH OFFSET moff][MATCH LENGTH mlen]}最后一次总体匹配到的串（总体串，最外层分组，而不是指正则式最内最后一个分组）起始位置与长度
  | [RESULTS result_tab|result_wa] } result_tab接收全部匹配结果，result_wa只能接收最后一次匹配结果
  [SUBMATCHES s1 s2 ...].一般与前面的MATCH OFFSET/ LENGTH一块儿使用。只会接收使用括号进行分组的子组。若是变量s1 s2 ...比分组的数量多，则多余的变量被initial；若是变量s1 s2 ...比分组的数量少，则多余的分组将被忽略；且只存储第一次或最后一次匹配到的结果

replace( val = TEXT  REGEX = REGEX  WITH = NEW)使用new替换指定的子符串，返回String类型

REPLACE ALL OCCURRENCES OF REGEX regex IN  dobj WITH new

1.7.1.   count、match结合

DATA: text TYPE string VALUE `Cathy's cat with the hat sat on Matt's mat.`,
      regx TYPE string VALUE `\<.at\>`."\< 单词开头，\> 单词结尾
DATA: counts TYPE i,
index TYPE i,
      substr TYPE string.
WRITE / text.
NEW-LINE.
counts = count( val = text regex = regx )."返回匹配次数
DO counts TIMES.
index = find( val   = text regex = regx occ = sy-index )."返回匹配到的的起始位置索引
  substr = match( val  = text regex = regx occ = sy-index )."返回匹配到的串
index = index + 1.
WRITE AT index substr.
ENDDO.

1.7.2.FIND …SUBMATCHES 

DATA: moff TYPE i,
       mlen TYPE i,
       s1   TYPE string,
       s2   TYPE string,
       s3   TYPE string,
       s4   TYPE string.
FIND ALL OCCURRENCES OF REGEX `((\w+)\W+\2\W+(\w+)\W+\3)`"\2 \3 表示反向引用前面匹配到的第二与第三个子串
IN `Hey hey, my my, Rock and roll can never die Hey hey, my my`"会匹配二次，但只会返回第二次匹配到的结果，第一次匹配到的子串不会存储到s1、s2、s3中去
IGNORING CASE
MATCH OFFSET moff
 MATCH LENGTH mlen
SUBMATCHES s1 s2 s3 s4."根据从外到内，从左到右的括号顺序依次存储到s1 s2…中，注：只取出使用括号括起来的子串，如想取总体子串则也要括起来，这与Java不一样
WRITE: /  s1, / s2,/ s3 ,/ s4,/ moff ,/ mlen."s4会被忽略

1.7.3.   FIND …RESULTS  itab

DATA: result TYPE STANDARD TABLE OF string WITH HEADER LINE .
"与Java不一样，只要是括号括起来的都称为子匹配（即便用总体也用括号括起来了），
"无论括号嵌套多少层，统称为子匹配，且匹配到的全部子串都会存储到，
"MATCH_RESULT-SUBMATCHES中，即便最外层的括号匹配到的子串也会存储到SUBMATCHES
"内表中。括号解析的顺序为：从外到内，从左到右的优先级顺序来解析匹配结构。
"Java中的group(0)存储的是总体匹配串，即便总体未（或使用）使用括号括起来
PERFORM get_match TABLES result
USING '2011092131221032' '(((\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[].
"result_tab中存储了匹配到的子串自己（与Regex总体匹配的串，存储在
"result_tab-offset、result_tab-length中）以及所子分组（括号部分，存储在
"result_tab-submatches中）
LOOP AT result_tab .
"如需取总体匹配到的子串（与Regex总体匹配的串），则使用括号将总体Regex括起来
"来便可，括起来后也会自动存储到result_tab-submatches，而不须要在这里像这样读取
*    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.

1.7.4.正则式类

regex = Regular expression   [ˈreɡjulə]

cl_abap_regex：与Java中的 java.util.regex.Pattern的类对应

cl_abap_matcher：与Java中的 java.util.regex.Matcher的类对应

1.7.4.1.matches、match

是否彻底匹配（正则式中没必要使用 ^ 与 $）；matches为静态方法，而match为实例方法，做用都是同样

DATA: matcher TYPE REF TO cl_abap_matcher,
      match TYPE match_result,
      match_line TYPE submatch_result.
"^$能够省略，由于matches方法自己就是彻底匹配整个Regex
IF cl_abap_matcher=>matches( pattern = '^(db(ai).*)$' text = 'dbaiabd' ) = 'X'.
  matcher = cl_abap_matcher=>get_object( )."获取最后一次匹配到的 Matcher 实例
  match = matcher->get_match( ). "获取最近一次匹配的结果(注：是总体匹配的结果)
WRITE / matcher->text+match-offset(match-length).
LOOP AT  match-submatches INTO match_line. "提取子分组（括号括起来的部分）
WRITE: /20 match_line-offset, match_line-length,matcher->text+match_line-offset(match_line-length).
ENDLOOP.
ENDIF.

DATA: matcher TYPE REF TO cl_abap_matcher,
      match TYPE match_result,
      match_line TYPE submatch_result.
"^$能够省略，由于matche方法自己就是彻底匹配整个Regex
matcher = cl_abap_matcher=>create( pattern = '^(db(ai).*)$' text = 'dbaiabd' ).
IF matcher->match(  ) = 'X'.
  match = matcher->get_match( ). "获取最近一次匹配的结果
WRITE / matcher->text+match-offset(match-length).
LOOP AT  match-submatches INTO match_line. "提取子分组（括号括起来的部分）
WRITE: /20 match_line-offset, match_line-length,matcher->text+match_line-offset(match_line-length).
ENDLOOP.
ENDIF.

1.7.4.2.contains

是否包含（也可在正则式中使用 ^ 与 $ 用于彻底匹配检查，或者使用 ^ 检查是否匹配开头，或者使用 $ 匹配结尾）

DATA: matcher TYPE REF TO cl_abap_matcher,
      match TYPE match_result,
match_line TYPE submatch_result.
IF cl_abap_matcher=>contains( pattern = '(db(ai).{2}b)' text = 'dbaiabddbaiabb' ) = 'X'.
  matcher = cl_abap_matcher=>get_object( ). "获取最后一次匹配到的 Matcher 实例
  match = matcher->get_match( ). "获取最近一次匹配的结果
WRITE / matcher->text+match-offset(match-length).
  LOOP AT  match-submatches INTO match_line. "提取子分组（括号括起来的部分）
WRITE: /20 match_line-offset, match_line-length,matcher->text+match_line-offset(match_line-length).
ENDLOOP.
ENDIF.

1.7.4.3.find_all

一次性找出全部匹配的子串，包括子分组（括号括起的部分）

DATA: matcher TYPE REF TO cl_abap_matcher,
       match_line TYPE submatch_result,
      itab TYPE match_result_tab WITH HEADER LINE.
matcher = cl_abap_matcher=>create( pattern = '<[^<>]*(ml)>' text = '<html>hello</html>' )."建立 matcher 实例
"注：子分组存储在itab-submatches字段里
itab[] = matcher->find_all( ).
LOOP AT itab .
WRITE: / matcher->text, itab-offset, itab-length,matcher->text+itab-offset(itab-length).
  LOOP AT  itab-submatches INTO match_line. "提取子分组（括号括起来的部分）
WRITE: /20 match_line-offset, match_line-length,matcher->text+match_line-offset(match_line-length).
ENDLOOP.
ENDLOOP.

1.7.4.4.find_next

逐个找出匹配的子串，包括子分组（括号括起的部分）

DATA: matcher TYPE REF TO cl_abap_matcher,
      match TYPE match_result, match_line TYPE submatch_result,
      itab TYPE match_result_tab WITH HEADER LINE.
matcher = cl_abap_matcher=>create( pattern = '<[^<>]*(ml)>' text = '<html>hello</html>' ).
WHILE matcher->find_next( ) = 'X'.
  match = matcher->get_match( )."获取最近一次匹配的结果
WRITE: / matcher->text, match-offset, match-length,matcher->text+match-offset(match-length).  
  LOOP AT  match-submatches INTO match_line. "提取子分组（括号括起来的部分）
 WRITE: /20 match_line-offset, match_line-length,matcher->text+match_line-offset(match_line-length).
  ENDLOOP.
ENDWHILE.

1.7.4.5.get_length、get_offset、get_submatch

DATA: matcher TYPE REF TO cl_abap_matcher,
      length TYPE i,offset TYPE i,
      submatch TYPE string.
matcher = cl_abap_matcher=>create( pattern = '(<[^<>]*(ml)>)' text = '<html>hello</html>' ).
WHILE matcher->find_next( ) = 'X'. "循环2次
"为0时，表示取整个Regex匹配到的子串，这与Java同样，但若是整个Regex使用括号括起来后，
"则分组索引为1，这又与Java不同（Java无论是否使用括号将整个Regex括起来，分组索引号都为0）
  "上面Regex中共有两个子分组，再加上整个Regex为隐含分组，因此一共为3组
DO 3 TIMES.
"在当前匹配到的串（整个Regex相匹配的串）中返回指定子分组的匹配到的字符串长度
    length = matcher->get_length( sy-index - 1 ).
"在当前匹配到的串（整个Regex相匹配的串）中返回指定子分组的匹配到的字符串起始位置
    offset = matcher->get_offset( sy-index - 1 ).
"在当前匹配到的串（整个Regex相匹配的串）中返回指定子分组的匹配到的字符串
    submatch = matcher->get_submatch( sy-index - 1 ).
WRITE:/ length , offset,matcher->text+offset(length),submatch.
ENDDO.
SKIP.
ENDWHILE.

1.7.4.6.replace_all

DATA: matcher TYPE REF TO cl_abap_matcher,
      count TYPE i,
      repstr TYPE string.
matcher = cl_abap_matcher=>create( pattern = '<[^<>]*>' text = '<html>hello</html>' ).
count = matcher->replace_all( ``)."返回替换的次数
repstr = matcher->text. "获取被替换后的新串
WRITE: / count , repstr.

1.8.CLEAR、REFRESH、FREE

内表：若是使用有表头行的内表，CLEAR 仅清除表格工做区域。要重置整个内表而不清除表格工做区域，使用REFRESH语句或 CLEAR 语句CLEAR <itab>[].；REFRESH加不加中括号都是只清内表，另外REFRESH是专为清内表的，不能清基本类型变量，但CLEAR能够

以上都不会释放掉内表所占用的空间，若是想初始化内表的同时还要释放所占用的空间，请使用：FREE <itab>.

1.9.ABAP程序中的局部与全局变量

报表程序中选择屏幕事件块（AT SELECTION-SCREEN）与逻辑数据库事件块、以及methods（类中的方法）、subroutines（FORM子过程）、function modules（Function函数）中声明的变量为局部的，即在这些块里声明的变量不能在其余块里使用，但这些局部变量能够覆盖同名的全局变量；除这些处理块外，其余块里声明的变量都属于全局的（如报表事件块、列表事件块、对话Module），效果与在程序最开头定义的变量效果是同样的，因此能够在其余处理块直接使用（但要注意的是，需遵照先定义后使用的原则，这种前后关系是从语句书写顺序来讲的，与事件块的自己运行顺序没有关系）；另外，局部变量声明时，无论在处理块的任何地方，其效果都是至关于处理块里的全局变量，而不像其余语言如Java那样：局部变量的做用域能够存在于任何花括号{}之间（这就意味着局部变量在处理过程范围内是全局的），以下面的i，在ABAP语言中仍是会累加输出，而不会永远是1（在Java语言中会是1）：

FORM aa.
DO 10 TIMES.
DATA: i TYPE i VALUE 0.
i = i + 1.
WRITE: / i.
ENDDO.
ENDFORM.

1.10.Form、Function

Form、Function中的TABLES参数，TYPE与LIKE后面只能接标准内表类型或标准内表对象，若是要使用排序内表或者哈希内表，则只能使用USING（Form）与CHANGING方式来代替。当把一个带表头的实参经过TABLES参数传递时，表头也会传递过去，若是实参不带表头或者只传递了表体（使用了[]时），系统会自动为内表参数变量建立一个局部空的表头

无论是以TABLES仍是以USING（Form）非值、CHANGE非值方式传递时，都是以引用方式（即别名，不是指地址，注意与Java中的传引用区别：Java实为传值，但传递的值为地址的值，而ABAP中传递的是否为地址，则要看实参是不是经过Type ref to定义的）传递；但若是USING值传递，则对形参数的修改不会改变实参，由于此时不是引用传递；但若是CHANGE值传递，对形参数的修改仍是会改变实参，只是修改的时机在Form执行或Function执行完后，才去修改

Form中经过引用传递时，USING与CHANGING彻底同样；但CHANGING为值传递方式时，须要在Form执行完后，才去真正修改实参变量的内容，因此CHANGING传值与传引用其结果都是同样：结果都修改了实参内容，只是修改的时机不太同样而已

1.10.1.FORM

FORM subr [TABLES t1 [{TYPE itab_type}|{LIKE itab}|{STRUCTURE struc}] 
t2 […]] 

[USING { VALUE(p1)|p1 } [ { TYPE generic_type } 

| { LIKE <generic_fs>|generic_para }
| { TYPE {[LINE OF] complete_type}|{REF TO type} } 
| { LIKE {[LINE OF] dobj} | {REF TO dobj} }
| STRUCTURE struc] 

{ VALUE(p2)|p2 } […]] 

[CHANGING{ VALUE(p1)|p1 } [ { TYPE generic_type } 

| { LIKE <generic_fs>|generic_para }  

| { TYPE {[LINE OF] complete_type} | {REF TO type} } 
| { LIKE {[LINE OF] dobj} | {REF TO dobj} } 
| STRUCTURE struc] 

{ VALUE(p2)|p2 } […]] 

[RAISING {exc1|RESUMABLE(exc1)} {exc2|RESUMABLE(exc2)} ...].

generic_type：为通用类型

complete_type：为彻底限制类型

<generic_fs>：为字段符号变量类型，以下面的 fs 形式参数

generic_para：为另外一个形式参数类型，以下面的 b 形式参数

DATA: d(10) VALUE'11'.
FIELD-SYMBOLS: <fs> LIKE d.
ASSIGN d TO <fs>.
PERFORM aa USING <fs> d d.
FORM aa USING fs like <fs>  a like d  b like a.
WRITE:fs,/ a , / b.
ENDFORM.

若是没有给形式参数指定类，则为ANY类型

若是TABLES与USING、CHANGING一块儿使用时，则必定要按照TABLES、USING、CHANGING顺序声明

值传递中的VALUE关键字只是在FORM定义时出现，在调用时PERFORM语句中无需出现，也就是说，调用时值传递和引用传递不存在语法格式差异