ABAP 关键字：CORESPONDING

BASE, CORRESPONDING 和 MOVE-CORRESPONDING的比较：
BASE操作符用作ABAP操作的基线（BASELINE），有多种用途。例如，它可以用于数据插入和比较数据时的基线（BASELINE）。在相应和移动对应操作符的帮助下，数据移动和复制现在变得更容易。

一、Base的基本使用

案例：数据追加演示

TYPES ty_days TYPE TABLE OF string WITH EMPTY KEY.
* 初始化内表
DATA(lt_days) = VALUE ty_days( ( `星期一` )
                  ( `星期二` )
                  ( `星期三` ) ).
* 追加行
lt_days = VALUE #( BASE lt_days ( `星期四` )
                   ( `星期五` )
                   ( `星期六` )
                   ( `星期天` ) )

二、CORRESPONDING与MOVE-CORRESPONDING的区别 – 结构体

在结构体的赋值中，MOVE-CORRESPONDING只针对匹配字段进行赋值，CORRESPONDING操作符会直接进行覆盖。使用Base操作符的复制行功能，可实现与MOVE-CORRESPONDING相同的功能。

2.1、结构类型定义：下面的案例都是基于该结构类型创建。

TYPES:
  BEGIN OF lty_type1,
    field1 TYPE i,
  END OF lty_type1,
  ltty_type1 TYPE TABLE OF lty_type1 WITH EMPTY KEY,
  BEGIN OF lty_type2,
    field1 TYPE i,
    field2 TYPE i,
  END OF lty_type2,
  ltty_type2 TYPE TABLE OF lty_type2 WITH EMPTY KEY,
  BEGIN OF lty_type3,
    field1 TYPE i,
    field3 TYPE i,
  END OF lty_type3,
  ltty_type3 TYPE TABLE OF lty_type3 WITH EMPTY KEY.

案例一：MOVE-CORRESPONDING 与 CORRESPONDING的比较（实现相同的功能：针对匹配字段进行赋值）

DATA(lwa_type1) = VALUE lty_type1( field1 = 1 ).
DATA(lwa_type2) = VALUE lty_type2( field1 = 2 field2 = 3 ).
" lwa_type2-field1 会被替换为 1
" MOVE-CORRESPONDING lwa_type1 TO lwa_type2. 与下面的语句等价
lwa_type2 = CORRESPONDING #( BASE ( lwa_type2 ) lwa_type1 ). 

案例二：MOVE-CORRESPONDING 与 CORRESPONDING的区别（使用操作符赋值时，没有匹配的字段直接初始化，例如Field2会直接被初始化为0）

DATA(lwa_type1) = VALUE lty_type1( field1 = 1 ).
DATA(lwa_type2) = VALUE lty_type2( field1 = 2 field2 = 3 ).

* field2 被初始化
lwa_type2 = CORRESPONDING #( lwa_type1 ).

三、CORRESPONDING与MOVE-CORRESPONDING的区别 – 内表

案例一： 使用MOVE-CORRESPONDING给内表进行赋值、会刷新内表，再进行赋值。

DATA(lt_type1) = VALUE ltty_type1( ( field1 = 1 )
                    ( field1 = 2 ) ).
DATA(lt_type2) = VALUE ltty_type2( ( field1 = 3 field2 = 4 )
                    ( field1 = 5 field2 = 6 )
                    ( field1 = 7 field2 = 8 ) ).
" 步骤：清空内表 lt_type2，再将 lt_type1 赋值给 lt_type2
MOVE-CORRESPONDING lt_type1 TO lt_type2.  " 等价于 lt_type2 = CORRESPONDING #( lt_type1 ).

案例二：实现内表的行追加，等价于KEEPING TARGET LINES 语法。

DATA(lt_type1) = VALUE ltty_type1( ( field1 = 1 )
                    ( field1 = 2 ) ).

DATA(lt_type2) = VALUE ltty_type2( ( field1 = 3 field2 = 4 )
                    ( field1 = 5 field2 = 6 )
                    ( field1 = 7 field2 = 8 ) ).
" 追加两行到内表 lt_type2
MOVE-CORRESPONDING lt_type1 TO lt_type2 KEEPING TARGET LINES.
" 追加两行到内表 lt_type2 与上面的写法是等价的
lt_type2 = CORRESPONDING #( BASE ( lt_type2 ) lt_type1 ).

四、Mapping的使用

案例一：内表赋值时字段名匹配不上，导致某列的值被设置为初始化。

DATA(lt_type2) = VALUE ltty_type2( ( field1 = 23 field2 = 24 )
                    ( field1 = 25 field2 = 26 )
                    ( field1 = 27 field2 = 28 ) ).

DATA(lt_type3) = VALUE ltty_type3( ( field1 = 33 field3 = 30 )
                    ( field1 = 35 field3 = 30 )
                    ( field1 = 37 field3 = 30 ) ).

" 赋值之后 内表 ltty_type3 的field3字段为空
lt_type3 = CORRESPONDING #( BASE ( lt_type3 ) lt_type2 ).

案例二：两个内表的字段名不一致时，可以使用MAPPING关键字实现不同字段名的映射。

DATA(lt_type2) = VALUE ltty_type2( ( field1 = 23 field2 = 24 )
                    ( field1 = 25 field2 = 26 )
                    ( field1 = 27 field2 = 28 ) ).

DATA(lt_type3) = VALUE ltty_type3( ( field1 = 33 field3 = 30 )
                    ( field1 = 35 field3 = 30 )
                    ( field1 = 37 field3 = 30 ) ).
* 将 field2 赋值给 field3 完成映射赋值
lt_type3 = CORRESPONDING #( BASE ( lt_type3 ) lt_type2
                MAPPING field3 = field2 ).

五、Except的使用

案例一：内表赋值时，使某个字段不参与映射。

TYPES : BEGIN OF lty_type4,
          field1 TYPE i,
          field2 TYPE i,
          field3 TYPE i,
        END OF lty_type4,
        ltty_type4 TYPE TABLE OF lty_type4 WITH EMPTY KEY.
DATA(lt_type2) = VALUE ltty_type2( ( field1 = 23 field2 = 24 )
                    ( field1 = 25 field2 = 26 ) ).

DATA(lt_type4) = VALUE ltty_type4( ( field1 = 43 field2 = 41 field3 = 40 )
                    ( field1 = 45 field2 = 42 field3 = 40 ) ).
" 将 field2 排除，不参与映射
lt_type4 = CORRESPONDING #( lt_type2 EXCEPT field2 ).

案例二：指定映射的字段、使其它的字段都不参与映射。

DATA(lt_type2) = VALUE ltty_type2( ( field1 = 23 field2 = 24 )
                    ( field1 = 25 field2 = 26 ) ).
DATA(lt_type4) = VALUE ltty_type4( ( field1 = 43 field2 = 41 field3 = 40 )
                    ( field1 = 45 field2 = 42 field3 = 40 ) ).
" 指定映射字段，其它的全部排除
lt_type4 = CORRESPONDING #( lt_type2 MAPPING field2 = field2 EXCEPT * ).

六、类的简单使用

类CL_ABAP_CORRESPONDING 它允许通过动态映射的方式在结构和内表之间进行相互赋值。主要包含两个主要的方法：CREATE( )和EXECUTE( )。
1、CREATE( )：主要用于创建映射对象，包含结构和内表之间的转换规则。
2、EXECUTE( )：基于CREATE( )之间创建的映射对象实现数据转换。该方法是在ABAP内核执行的，因此比Loop循环效率更高。像MOVE-CORRESPONDING,CORRESPONDING只能实现确定列名的静态映射。该方法能实现动态映射。
参数详解：
Level：结构或内部表中组件的等级。该参数的可能值从0到n，其中0是顶级的。当您希望在嵌套结构/内部表之间移动数据时，此参数用于定义组件的级别。
KIND：选项值
1、CL_ABAP_CORRESPONDING=>MAPPING_COMPONENT 或者 1：指定的字段名srcname和dstname相互映射。
2、CL_ABAP_CORRESPONDING=>MAPPING_EXCEPT_COMPONENT 或者2：在映射时可将字段排除，不参与映射。
3、CL_ABAP_CORRESPONDING=>MAPPING_EXCEPT_ALL 或者 3：排除其它所有的映射字段。
SRCNAME：源结构/内表中的字段名
DSTNAME：目标结构/内表中的字段名
案例一：

TYPES:
  BEGIN OF src,
    sign   TYPE char1,
    option TYPE char2,
    value  TYPE string,
  END OF src,

  BEGIN OF dest,
    sign   TYPE char1,
    option TYPE char2,
    low    TYPE string,
    high   TYPE string,
  END OF dest.

DATA lt_src TYPE TABLE OF src.   " 源表
DATA lt_dest TYPE TABLE OF dest. " 目标表

lt_src = VALUE #( ( sign = 'I' option = 'EQ' value = '10008' )
                  ( sign = 'I' option = 'EQ' value = '10008' )
                  ( sign = 'I' option = 'EQ' value = '10008' ) ).

* 创建映射对象/规则
* KIND = 2 = CL_ABAP_CORRESPONDING=>MAPPING_EXCEPT_COMPONENT
DATA(lo_mapping_object) =
         cl_abap_corresponding=>create(
           source    = lt_src
           destination = lt_dest
           mapping   = VALUE cl_abap_corresponding=>mapping_table(
             ( level = 0 kind = 1 srcname = 'SIGN' dstname = 'SIGN' )
             ( level = 0 kind = 1 srcname = 'OPTION' dstname = 'OPTION' )
             ( level = 0 kind = 1 srcname = 'VALUE' dstname = 'LOW' )
             ( level = 0 kind = 2 dstname = 'HIGH')
           ) ).

* 执行映射
lo_mapping_object->execute( EXPORTING source    = lt_src
               CHANGING  destination = lt_dest ).

案例二、结构之间的简单赋值

TYPES:
  BEGIN OF struct1,
    a1 TYPE string,
    a2 TYPE string,
    a3 TYPE string,
  END OF struct1,

  BEGIN OF struct2,
    b1 TYPE string,
    b2 TYPE string,
    b3 TYPE string,
  END OF struct2.

DATA dest_struct TYPE struct2.

DATA(src_struct) = VALUE struct1( a1 = 'Jon Snow'
                   a2 = 'Arya Stark'
                   a3 = 'Daenerys').
* 创建映射对象
DATA(lo_mapping_object) =
         cl_abap_corresponding=>create(
           source      = src_struct    " 源结构
           destination = dest_struct   " 目标结构
           mapping     = VALUE cl_abap_corresponding=>mapping_table(
             ( level = 0 kind = 1 srcname = 'A1' dstname = 'B1' )
             ( level = 0 kind = 1 srcname = 'A2' dstname = 'B2' )
             ( level = 0 kind = 1 srcname = 'A3' dstname = 'B3' )
           ) ).

* 将 src_struct 转换为 dest_struct.
lo_mapping_object->execute( EXPORTING source     = src_struct
               CHANGING  destination = dest_struct ).