Mark的技术博客

SAP顾问 | 咨询专家 | IT与AI技术探索者

吴让宇(Mark)

吴让宇(Mark)

SAP顾问 | 咨询专家 | IT与AI技术探索者

吴让宇(Mark)的个人技术博客,专注于SAP系统实施、行业方案咨询、IT技术与AI技术的研究与分享。

SAP Fiori ABAP CDS OData Dify Docker AI LLM

最新文章

程序调用与内存练习 (10题)

#practice #memory-mgmt #program-structure #shared-objects

相关概念

📌核心模式(点击查看)
关键词 答案
插入 vs 新启动 AND RETURN = 插入;不带 AND RETURN = 替换
LEAVE TO TRANSACTION 销毁整个栈 + ABAP 内存
ABAP 内存范围 每个外部会话,内部会话共享
SAP 内存范围 每个用户会话,所有外部会话
封装组件 PXA 中的初始值共享,节省内存

第1题 - SUBMIT 变体 [记忆]

SUBMIT prog AND RETURN 和 SUBMIT prog(不带 AND RETURN)有什么区别?

📌点击查看答案
  • SUBMIT prog AND RETURN:插入被调用程序。新的内部会话压入栈。被调用程序结束后,在调用程序中 SUBMIT 语句之后继续执行。
  • SUBMIT prog(不带 AND RETURN):替换顶层内部会话。调用程序的会话被销毁。被调用程序的新会话替换它。

第2题 - CALL TRANSACTION 模式 [记忆]

CALL TRANSACTION 的 MODE 附加项可以取哪些值?各表示什么?

📌点击查看答案
值 行为
A 显示所有屏幕(默认)
E 仅在出错时显示
N 不显示屏幕(后台模式)

第3题 - BDCDATA 结构 [记忆]

在为 CALL TRANSACTION ... USING 填充 BDCDATA 内表时,哪些字段标识屏幕,哪些字段填充输入值?

📌点击查看答案
屏幕标识:PROGRAM、DYNPRO、DYNBEGIN = 'X'
字段填充:FNAM(字段名或 BDC_OKCODE/BDC_CURSOR)、FVAL(字段值)

第4题 - LEAVE TO TRANSACTION 内存效果 [应用]

一个程序使用 LEAVE TO TRANSACTION 调用另一个程序。调用前使用 EXPORT TO MEMORY ID 'MY_DATA' 存储了数据。被调用程序能读取这些数据吗?为什么?

📌点击查看答案
不能。 LEAVE TO TRANSACTION 销毁整个内部会话栈,同时清除了 ABAP 内存。ABAP 内存与外部会话的内部会话关联,当它们全部被销毁时,内存被释放。只有 CALL TRANSACTION(插入模式)保留 ABAP 内存。

第5题 - 程序组 [记忆]

两个不同的内部会话调用同一函数组的函数模块时会发生什么?

📌点击查看答案
函数组分别加载到每个内部会话中。每个会话获得函数组全局数据的独立副本。会话之间没有意外数据共享的风险,但也不能通过函数组共享数据。

第6题 - ABAP 内存操作 [记忆]

说出操作 ABAP 内存的三条 ABAP 语句及其用途。

📌点击查看答案
  1. EXPORT ... TO MEMORY ID 'cluster_id' – 将数据簇写入 ABAP 内存
  2. IMPORT ... FROM MEMORY ID 'cluster_id' – 从 ABAP 内存读取数据簇
  3. FREE MEMORY ID 'cluster_id' – 显式释放 ABAP 内存中的数据簇

第7题 - SAP 内存 [应用]

需要在事务首屏的输入字段中预填值。该字段关联参数 ID ‘CAR’,且已启用”Set Parameter”。写出设置值的语句。

📌点击查看答案
1
2
SET PARAMETER ID 'CAR' FIELD lv_carrid.
CALL TRANSACTION 'BC402MCAR' AND SKIP FIRST SCREEN.

SET PARAMETER 填充 SAP 内存,事务在屏幕初始化时如果字段的”Get Parameter”已激活,就会读取该值。


第8题 - 封装组件 [应用]

何时应使用封装组件?至少说出两个必须满足的条件。

📌点击查看答案
封装组件在以下所有条件都满足时有益:
  1. 子结构/属性通常保持初始状态(优势 = 初始值共享)
  2. 子结构不太小(节省必须超过 8 字节引用开销)
  3. 结构使用频繁(实例多或程序执行频繁 – 节省与使用量成正比)

封装组件增加 8 字节的内部引用。如果子结构总是有数据或非常小,开销会超过收益。


第9题 - 共享对象架构 [分析]

比较共享对象方法与 ABAP 内存用于跨程序数据交换。各在什么时候适用?

📌点击查看答案
方面 ABAP 内存 共享对象
范围 一个外部会话 同一应用服务器上所有用户
生命周期 直到会话关闭 直到显式删除或服务器重启
数据类型 任意 ABAP 数据对象 类的实例(数据作为属性)
性能 快(同一进程) 非常快(共享内存,无数据库)
使用场景 被调用程序间的数据传递 目录、共享缓存、购物车

在单个用户的程序调用链内交换数据时使用 ABAP 内存。在多个用户需要并发访问而不读数据库时使用共享对象。


第10题 - 写入时复制 [分析]

解释内表的写入时复制语义。将一个内表赋值给另一个时会发生什么?

📌点击查看答案
当执行 itab2 = itab1 时,实际数据不会被复制。两个表共享同一个表体 – 仅表头/管理信息被复制。这节省了内存和运行时间。

实际复制仅在其中一个表被修改(写访问)时发生。此时共享体被复制,修改的表指向自己的副本。

例外:具有嵌套表行类型的表从不共享。

这也适用于过程传参 – 按值传递在形式参数被修改之前不会产生复制开销。


📌模式总结(点击查看)
关键词 答案
SUBMIT AND RETURN 插入程序,保留调用者
LEAVE TO TRANSACTION 销毁栈,清除 ABAP 内存
BDCDATA 字段 PROGRAM+DYNPRO+DYNBEGIN 标识屏幕;FNAM+FVAL 填数据
ABAP 内存 EXPORT/IMPORT/FREE,每个外部会话
SAP 内存 SET/GET PARAMETER,每个用户会话
封装组件 适用条件:通常为初始、不太小、使用频繁
写入时复制 共享直到首次修改

内部数据处理练习 (12题)

#practice #arithmetic #string-processing #internal-tables #data-reference

相关概念

📌核心模式(点击查看)
关键词 答案
算术优先级 decfloat > 二进制浮点 > 压缩数 > 整数
** 运算符 即使全是 i 也强制浮点算术
正则 * vs + * = 0 或多次;+ = 1 或多次
标准表键访问 O(n) 线性
排序表键访问 O(log n) 二分
哈希表键访问 O(1) 常数
LOOP 中 ASSIGNING 无数据复制,直接修改

第1题 - 整数除法 [记忆]

DATA int TYPE i. int = 5 / 2. 的结果是什么?

📌点击查看答案
2。整数算术使用商业舍入。精确结果(2.5)舍入到最接近的偶数(对于半值),或根据操作简单截断。在 ABAP 整数算术中,5 / 2 = 2(向下舍入到整数)。

第2题 - 混合算术优先级 [记忆]

一个表达式包含类型 i、f 和 p 的变量。结果字段为 i 类型。使用哪种算术?

📌点击查看答案
二进制浮点算术。 优先级规则是:decfloat > 二进制浮点 > 压缩数 > 整数。因为有 f 类型操作数(且没有 decfloat),所以使用二进制浮点算术进行计算。结果然后转换为 i 类型。

第3题 - 大字面量类型 [应用]

DATA int TYPE i. int = 10000000000 / 3000000000 * 3. 结果是什么?为什么?

📌点击查看答案
10。 字面量 10000000000 超出了 i 类型的值范围,因此被视为 p 类型。这使得整个表达式使用压缩算术而非整数算术。使用压缩算术:10000000000 / 3000000000 = 3.333...,舍入为 3,然后 3 * 3 = 9.999...,转换为 i 时舍入为 10。

第4题 - 字符串函数 [记忆]

说出字符串函数的三个类别,每类给出一个示例。

📌点击查看答案
类别 用途 示例
描述性 返回数值结果 strlen()、count()、find()
处理性 返回字符串 substring()、to_upper()、reverse()
谓词性 返回真假值 contains()、matches()

第5题 - 正则表达式 [应用]

编写一个正则表达式,匹配以 “ABAP” 开头后跟恰好 3 个数字的字符串。

📌点击查看答案
ABAP\d{3} 或 ABAP[0-9]{3}
  • ABAP 匹配字面文本
  • \d 或 [0-9] 匹配单个数字
  • {3} 表示恰好 3 次

匹配示例:”ABAP123”、”ABAP456”


第6题 - 字符串模板 [记忆]

字符串模板的语法是什么?如何嵌入表达式?

📌点击查看答案
字符串模板使用 |...| 定界符。表达式用花括号嵌入:{expression}。

示例:|Hello {lv_name}, the value is {lv_amount decimals = 2}|

格式化选项跟随在 {} 中的表达式后面,例如 {lv_date date = user}、{lv_num width = 10 align = right}。


第7题 - 表类型选择 [应用]

需要一个内表,满足:(a) 始终通过唯一键访问,(b) 永远不使用索引访问,(c) 单条记录查找需要最高性能。应选择哪种表类型?

📌点击查看答案
哈希表,使用 UNIQUE 键。
1
DATA: itab TYPE HASHED TABLE OF ty_line WITH UNIQUE KEY key_field.

哈希表提供 O(1) 常数时间键访问,要求唯一键,不支持索引访问 – 满足全部三个要求。


第8题 - 二分搜索 [应用]

使用 READ TABLE lt_standard WITH KEY field = 'X' BINARY SEARCH 时,搜索要正确工作必须满足什么条件?

📌点击查看答案
表必须在读取前按搜索字段升序排序(本例中的 field)。BINARY SEARCH 执行假设数据已排序的二分搜索算法。如果表未按该字段排序,结果不可预测 – 不报错但可能找到错误的行或找不到行。

第9题 - COLLECT 行为 [记忆]

COLLECT 语句如何与内表配合工作?

📌点击查看答案
COLLECT wa INTO itab 比较工作区的字符型字段来查找匹配行。如果找到匹配行,数值字段被累加。如果没有匹配,插入新行。

要求:行类型必须是平坦的(不含深层组件)。COLLECT 在使用与非数值字段匹配的排序或哈希键的表上效果最佳。


第10题 - 次键 [应用]

有一个排序表,主键为 carrid, connid。经常需要单独按 cityfrom 访问。如何优化?

📌点击查看答案
定义一个次键:
1
2
3
DATA: itab TYPE SORTED TABLE OF ty_line
WITH NON-UNIQUE KEY carrid connid
WITH NON-UNIQUE SORTED KEY city_key COMPONENTS cityfrom.

然后使用:READ TABLE itab USING KEY city_key WITH KEY cityfrom = 'NYC'.

次键提供优化访问路径而不改变主键。USING KEY 附加项告诉系统使用次索引。


第11题 - 字段符号 vs 数据引用 [分析]

比较在循环中使用字段符号(<fs>)和数据引用(dref)访问内表行。各在什么时候更适合?

📌点击查看答案
方面 ASSIGNING <fs> REFERENCE INTO dref
访问 直接,像别名 间接通过 ->* 或 dref->field
生命周期 仅在当前作用域有效 可以存储供后续使用
修改 直接修改 通过 ->* 或另一个 ASSIGN 访问
传递 不能传递字段符号本身 可以将引用传递给其他方法
空状态 IS ASSIGNED 检查 IS BOUND / IS INITIAL 检查

简单循环内修改时优先使用字段符号(更易读,开销更小)。需要存储行引用供后续使用或传递给其他方法时优先使用数据引用。


第12题 - DELETE ADJACENT DUPLICATES [应用]

有一个按 carrid 排序的航班预订内表。运行 DELETE ADJACENT DUPLICATES FROM itab COMPARING carrid 后,所有重复的航空公司都会被删除吗?如果表未排序呢?

📌点击查看答案
如果按 carrid 排序:是的,所有重复项都被删除,因为相同的值是相邻的。

如果未排序:不会,仅删除恰好在相邻位置的重复项。不相邻的重复项会保留。DELETE ADJACENT DUPLICATES 仅检查连续的行 – 它不执行全局重复检查。

最佳实践:始终先排序,或使用 COMPARING ALL FIELDS / 指定字段列表。


📌模式总结(点击查看)
关键词 答案
整数除法 商业舍入,截断为整数
混合优先级 decfloat > f > p > i
** 运算符 强制浮点算术
正则 {n,m} n 到 m 次重复
哈希表 O(1) 键访问,无索引,仅唯一键
BINARY SEARCH 需要先按搜索键排序
COLLECT 累加数值,按非数值匹配
次键 WITH ... KEY name COMPONENTS ...
字段符号 vs 引用 FS:直接/作用域局部;Ref:可存储/可传递

内表类型 (★★★)

#internal-tables

三种表类型比较

属性 标准表(STANDARD) 排序表(SORTED) 哈希表(HASHED)
键访问 线性搜索 O(n) 二分搜索 O(log n) 哈希搜索 O(1)
索引访问 是 是 否
排序顺序 未排序(按需排序) 始终按键排序 不适用(无顺序)
键唯一性 非唯一 唯一或非唯一 仅唯一
填充策略 APPEND(末尾追加快) INSERT(维护排序) INSERT(哈希桶)
最佳用途 顺序处理、排序、临时存储 部分顺序读取、有序访问 按键的单条记录查找
📌哈希表不支持索引访问。不能在哈希表上使用 READ TABLE ... INDEX、LOOP AT ... FROM/TO、INSERT ... INDEX 或 DELETE ... INDEX。

表键类别

标准键

1
DATA: lt_itab TYPE STANDARD TABLE OF struc WITH DEFAULT KEY.
  • 组件:行类型中所有平坦的非数值字段
  • 如果行类型没有合适字段:整行为键
  • 空标准键:没有任何键字段

主键

键类型 适用范围 语法
唯一 排序表、哈希表 WITH UNIQUE KEY comp1 comp2
非唯一 标准表、排序表 WITH NON-UNIQUE KEY comp1 comp2
1
2
3
4
5
6
7
" 带唯一主键的排序表
DATA: lt_sorted TYPE SORTED TABLE OF struc
WITH UNIQUE KEY id.

" 带非唯一键的标准表
DATA: lt_std TYPE STANDARD TABLE OF struc
WITH NON-UNIQUE KEY name.

次键(详见 特殊表技术)

  • NW 7.0 EhP2 起可用
  • 独立于主键定义
  • 可以是 SORTED(唯一/非唯一)或 HASHED(唯一)

键访问方法

READ TABLE WITH TABLE KEY

1
2
3
4
5
6
7
8
" 标准表:线性搜索(大表较慢)
READ TABLE lt_standard INTO ls_wa WITH TABLE KEY id = '123'.

" 排序表:二分搜索(快)
READ TABLE lt_sorted INTO ls_wa WITH TABLE KEY id = '123'.

" 哈希表:哈希搜索(最快)
READ TABLE lt_hashed INTO ls_wa WITH TABLE KEY id = '123'.
  • WITH TABLE KEY:使用表的主键(或次键)
  • 根据表类型自动优化

READ TABLE WITH KEY

1
2
" 通用键搜索 - 始终线性搜索,即使在排序/哈希表上!
READ TABLE lt_sorted INTO ls_wa WITH KEY name = 'Smith'.
⚠️WITH KEY(不带 TABLE)始终执行线性搜索,即使在排序或哈希表上也是如此。只有 WITH TABLE KEY 使用优化的访问方法。

索引访问方法

1
2
3
4
5
6
7
8
9
10
+-------------------+-----------------------------+-------------------+
| 操作 | 语句 | 表类型 |
+-------------------+-----------------------------+-------------------+
| 按索引读取 | READ TABLE ... INDEX n | 标准、排序 |
| 范围循环 | LOOP AT ... FROM n TO m | 标准、排序 |
| 按索引修改 | MODIFY ... INDEX n | 标准、排序 |
| 按索引删除 | DELETE ... INDEX n | 标准、排序 |
| 按索引插入 | INSERT ... INDEX n | 仅标准表 |
| 末尾追加 | APPEND ... | 仅标准表 |
+-------------------+-----------------------------+-------------------+
1
2
3
4
5
6
7
8
9
10
11
12
13
" 索引读取
READ TABLE lt_sorted INTO ls_wa INDEX 5.

" 范围循环
LOOP AT lt_sorted INTO ls_wa FROM 10 TO 20.
" 处理第 10 到 20 行
ENDLOOP.

" 按索引修改
MODIFY lt_standard FROM ls_wa INDEX 3.

" 按索引删除
DELETE lt_standard INDEX 7.

选择正确的表类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
                  主要访问模式是什么?
|
+---------------+---------------+
| |
按键访问 索引/顺序访问
| |
+------+------+ +--------+--------+
| | | |
大部分是 需要排序 顺序处理 填充后需要
单条查找 顺序用于 (用 APPEND 排序吗?
范围读取 填充)
| | | +----+----+
HASHED SORTED STANDARD 是:STANDARD
(唯一键) (唯一或 (用 APPEND + SORT
非唯一) 填充) 排序
否:SORTED(自动
维护顺序)
场景 推荐类型 原因
按键查找单条记录 哈希表 O(1) 访问
按键顺序处理记录 排序表 始终排序,二分搜索
收集后排序 标准表 APPEND 快,按需 SORT
部分范围读取(键边界) 排序表 二分搜索 + 顺序
临时无序存储 标准表 最简单,最灵活
按键计数/聚合 哈希表 + COLLECT 唯一键确保正确聚合

表类型声明示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
" 标准表
TYPES: ty_standard TYPE STANDARD TABLE OF struc
WITH NON-UNIQUE KEY id.

" 排序表
TYPES: ty_sorted TYPE SORTED TABLE OF struc
WITH UNIQUE KEY id.

" 哈希表
TYPES: ty_hashed TYPE HASHED TABLE OF struc
WITH UNIQUE KEY id.

" 内联声明(默认标准表)
DATA(lt_inline) = VALUE ty_standard( ).

键访问性能汇总

1
2
3
4
5
表类型           WITH TABLE KEY    WITH KEY     INDEX
----------- -------------- --------- -----
STANDARD O(n) 线性 O(n) 线性 O(1)
SORTED O(log n) 二分 O(n) 线性 O(1)
HASHED O(1) 哈希 O(n) 线性 不适用
💡按主键搜索时始终使用 WITH TABLE KEY 以获得该表类型的最佳性能。

考试/测试模式

关键词/模式 答案
“哈希表无索引” 不能在哈希表上使用 INDEX、FROM/TO 或位置访问
“WITH TABLE KEY vs WITH KEY” TABLE KEY 使用优化访问;WITH KEY 始终线性
“排序表始终有序” 记录自动按键顺序维护
“哈希表唯一键” 哈希表要求唯一键;重复会导致 CX_SY_ITAB_DUPLICATE_KEY
“标准表线性搜索” 键访问 O(n);排序后可使用 BINARY SEARCH
“单条记录查找最佳” 哈希表 (O(1))
“范围读取最佳” 排序表(二分 + 顺序)
“APPEND vs INSERT” APPEND 在末尾添加(标准表);INSERT 维护排序(排序/哈希)
“标准键组件” 行类型中所有平坦的非数值字段

相关笔记

数据引用与字段符号 (★★★)

#data-reference #internal-tables

概述

特性 数据引用 字段符号
声明 TYPE REF TO DATA FIELD-SYMBOLS <fs> TYPE ...
赋值 GET REFERENCE OF ... INTO dref ASSIGN ... TO <fs>
访问 dref->*(解引用) <fs>(直接使用)
检查有效性 IS BOUND IS ASSIGNED
取消 CLEAR dref UNASSIGN <fs>
内存模型 指向数据对象的指针 数据对象的别名
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
数据引用 vs 字段符号:
+-------------------------------------------------+
| |
| 数据对象 dref (TYPE REF TO DATA) |
| +-----------+ +-----------+ |
| | 值:42 | <----| 地址 | |
| +-----------+ +-----------+ |
| ^ | |
| | | dref->* |
| +-------------------+ (解引用) |
| |
| 数据对象 <fs> (FIELD-SYMBOL) |
| +-----------+ +-----------+ |
| | 值:42 | <----| 别名 | |
| +-----------+ +-----------+ |
| ^ | |
| | | <fs> |
| +-------------------+ (直接访问) |
| |
+-------------------------------------------------+

数据引用

声明和创建

1
2
3
4
5
6
7
8
9
10
" 声明
DATA: lr_data TYPE REF TO DATA.

" 获取已有数据对象的引用
DATA: lv_value TYPE i VALUE 42.
GET REFERENCE OF lv_value INTO lr_data.

" 在运行时创建匿名数据对象
CREATE DATA lr_data TYPE i.
CREATE DATA lr_data TYPE (lv_type_name). " 动态类型

解引用

1
2
3
" 通过解引用访问值
lr_data->* = 100.
WRITE: / lr_data->*.
⚠️解引用未绑定的引用(IS NOT BOUND)会导致运行时错误(CX_SY_REF_IS_INITIAL)。解引用前始终检查 IS BOUND。

IS BOUND vs IS INITIAL

检查 含义
lr_data IS BOUND 引用指向一个数据对象
lr_data IS INITIAL 引用是初始的(空指针)
lr_data IS NOT BOUND 引用不指向任何对象
1
2
3
4
5
IF lr_data IS BOUND.
WRITE: / lr_data->*.
ELSE.
WRITE: / '引用未绑定'.
ENDIF.
📌IS BOUND 和 IS INITIAL 对于引用变量是对立的。检查有效性时使用 IS BOUND 更清晰。

字段符号

声明和赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
" 声明
FIELD-SYMBOLS: <fs> TYPE i,
<fs_any> TYPE any, " 泛型
<fs_struc> TYPE struc. " 结构化

" 赋值数据对象
ASSIGN lv_value TO <fs>.

" 带类型转换的赋值
ASSIGN lv_hex TO <fs> TYPE c. " 将字节解释为字符

" 取消赋值
UNASSIGN <fs>.

" 检查赋值
IF <fs> IS ASSIGNED.
WRITE: / <fs>.
ENDIF.
检查 含义
<fs> IS ASSIGNED 字段符号指向一个数据对象
<fs> IS NOT ASSIGNED 字段符号未赋值
💡UNASSIGN <fs> 后,字段符号不再赋值。访问未赋值的字段符号会导致运行时错误。

与内表配合使用

访问方法概述

语句 使用字段符号 使用数据引用
LOOP AT ASSIGNING <fs> REFERENCE INTO dref
READ TABLE ASSIGNING <fs> REFERENCE INTO dref
INSERT ASSIGNING <fs> REFERENCE INTO dref
MODIFY 隐式(无额外语法) 不适用

LOOP AT … ASSIGNING

1
2
3
4
" 通过字段符号直接修改 - 无数据复制
LOOP AT lt_itab ASSIGNING FIELD-SYMBOL(<fs_row>).
<fs_row>-amount = <fs_row>-amount * 2. " 直接修改表
ENDLOOP.

LOOP AT … REFERENCE INTO

1
2
3
4
" 每行的引用
LOOP AT lt_itab REFERENCE INTO DATA(lr_row).
lr_row->*-amount = lr_row->*-amount * 2. " 通过解引用修改表
ENDLOOP.

READ TABLE … ASSIGNING

1
2
3
4
5
6
7
" 读取到字段符号
READ TABLE lt_itab ASSIGNING FIELD-SYMBOL(<fs_row>)
WITH TABLE KEY id = '123'.

IF sy-subrc = 0.
<fs_row>-status = 'X'. " 直接修改
ENDIF.

READ TABLE … REFERENCE INTO

1
2
3
4
5
6
7
" 读取到引用
READ TABLE lt_itab REFERENCE INTO DATA(lr_row)
WITH TABLE KEY id = '123'.

IF sy-subrc = 0.
lr_row->*-status = 'X'. " 通过解引用修改
ENDIF.

INSERT … ASSIGNING / REFERENCE INTO

1
2
3
4
5
6
" 插入并获取新行的引用/字段符号
INSERT ls_wa INTO TABLE lt_itab ASSIGNING FIELD-SYMBOL(<fs_new>).
INSERT ls_wa INTO TABLE lt_itab REFERENCE INTO DATA(lr_new).

" 继续操作新行
<fs_new>-created_at = sy-uzeit.

使用字段符号的 MODIFY

1
2
3
4
5
" 字段符号直接修改表行 - 不需要 MODIFY 语句!
LOOP AT lt_itab ASSIGNING FIELD-SYMBOL(<fs_row>).
<fs_row>-processed = abap_true.
" 不需要 MODIFY;<fs_row> 已经指向表行
ENDLOOP.

性能优势

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
+----------------------------------------------------------+
| 数据复制比较 |
+----------------------------------------------------------+
| |
| INTO wa: 将行数据复制到工作区 |
| +---------+ +---------+ 必须使用 MODIFY |
| | 表 | --> | WA 副本 | 写回到表 |
| +---------+ +---------+ (双重复制) |
| |
| ASSIGNING <fs>:无复制 - 直接指针 |
| +---------+ +---------+ 通过 <fs> 的更改 |
| | 表 | <-- | <fs> | 直接写入表 |
| +---------+ +---------+ (零复制) |
| |
| REFERENCE INTO:无复制 - 引用指针 |
| +---------+ +---------+ 通过 dref->* 的更改 |
| | 表 | <-- | dref | 直接写入表 |
| +---------+ +---------+ (零复制) |
| |
+----------------------------------------------------------+
方法 数据复制 修改方式 性能
INTO wa 是(复制进 + 复制回) 需要 MODIFY 最慢
ASSIGNING <fs> 无复制 通过 <fs> 直接 最快
REFERENCE INTO dref 无复制 通过 dref->* 快
💡循环内表时始终使用 ASSIGNING <fs> 或 REFERENCE INTO dref,特别是大表。修改行时避免使用 INTO wa。

完整方法比较

1
2
3
4
5
6
7
8
9
操作              INTO wa        ASSIGNING <fs>    REFERENCE INTO dref
---------------- ----------- -------------- -------------------
LOOP AT itab 复制行 无复制 无复制
READ TABLE 复制行 无复制 无复制
INSERT 不适用 获取新行 <fs> 获取新行 dref
MODIFY 需要 不需要 不适用

数据访问 wa-field <fs>-field dref->*-field
检查有效性 sy-subrc IS ASSIGNED IS BOUND

考试/测试模式

关键词/模式 答案
“ASSIGNING vs INTO” ASSIGNING = 无复制,直接修改;INTO = 数据复制
“REFERENCE INTO” 到行的数据引用;通过 dref->* 访问
“IS BOUND” 引用变量指向一个数据对象
“IS ASSIGNED” 字段符号指向一个数据对象
“用 ->* 解引用” dref->* 访问被引用的数据对象
“泛型引用解引用” TYPE REF TO DATA 必须使用 ASSIGN dref->* TO <fs> 处理泛型
“使用字段符号的 MODIFY” 不需要;对 <fs> 的更改直接修改表
“性能” ASSIGNING 和 REFERENCE INTO 避免数据复制
“GET REFERENCE OF” 获取已有数据对象的引用指针
“CREATE DATA” 在运行时创建匿名数据对象
“UNASSIGN” 移除字段符号的赋值
“insert + assigning” INSERT ... INTO TABLE ... ASSIGNING <fs> 获取新行的访问

相关笔记

动态编程技术 (★★)

#dynamic-prog

概述

动态编程是指在运行时而非设计时指定类型、长度、偏移量或名称。这使得程序能灵活、通用地适应不同的数据结构和用户输入。

技术一览

技术 机制 典型用途
动态语言元素 运行时替换令牌 通用工具
字段符号 动态数据访问 处理未知结构
RTTI / RTTC 类型检查和创建 框架、工具
程序生成 运行时创建并执行代码 动态报表

令牌替换

有两种方式使语句动态化:

令牌类型 语法 示例 关键规则
替换字面量 数据对象直接在语句中 WRITE: / var. 值替换字面量
替换标识符 数据对象放在括号中 WRITE: / (lv_field). 值替换名称;括号内不能有空格
⚠️动态标识符括号内不能有空格
CALL FUNCTION (lv_name) 是正确的。
CALL FUNCTION ( lv_name ) 是错误的,会导致语法错误或意外行为。

动态 Open SQL

1
2
3
4
5
6
7
8
9
10
" 动态表名
SELECT * FROM (lv_tabname) INTO TABLE @lt_data.

" 动态 WHERE 条件
SELECT * FROM spfli INTO TABLE @lt_flights
WHERE (lv_where_clause).

" 两者都动态
SELECT * FROM (lv_tab) INTO TABLE @lt_result
WHERE (lv_cond).
SQL 子句 动态语法 说明
FROM (lv_tabname) 表名在变量中
WHERE (lv_condition) 整个条件作为字符串
字段列表 不能完全动态 使用 * 或静态指定列

动态函数模块调用

1
2
3
4
5
6
7
8
9
DATA: lv_fm_name TYPE funcname VALUE 'Z_MY_FUNCTION'.

CALL FUNCTION (lv_fm_name)
EXPORTING
iv_param = lv_value
IMPORTING
ev_result = lv_result
EXCEPTIONS
others = 1.
💡何时使用
当函数模块名称在运行时确定时(例如从定制表或用户选择中获取),使用动态 FM 调用。

动态方法调用

1
2
3
4
5
6
DATA: pt TYPE abap_parmbind_tab,
et TYPE abap_excpbind_tab.

CALL METHOD (lv_method_name)
PARAMETER-TABLE pt
EXCEPTION-TABLE et.
附加项 用途
PARAMETER-TABLE 通过内表动态传递参数
EXCEPTION-TABLE 通过内表动态处理异常

参数表行包含 name(参数名)和 value(实际参数的引用)。异常表行包含 name(异常名)和 value(要分配的 sy-subrc 值)。

使用动态数据的 CALL TRANSACTION

1
2
3
4
5
6
7
DATA: lt_bdcdata TYPE TABLE OF bdcdata.

" 动态填充 BDC 表...
CALL TRANSACTION 'MM01' USING lt_bdcdata
MODE 'N'
UPDATE 'S'
MESSAGES INTO lt_messages.

程序生成

INSERT REPORT

1
2
" 从源代码内表生成程序
INSERT REPORT lv_prog_name FROM lt_source_code.
方面 详情
来源 string 或类似类型的内表
结果 程序被添加到仓库(临时或可传输)
使用场景 动态报表生成

GENERATE SUBROUTINE POOL

1
2
3
4
5
6
7
8
9
10
DATA: lv_prog TYPE string.

GENERATE SUBROUTINE POOL lt_source
NAME lv_prog
MESSAGE lv_msg
LINE lv_line
WORD lv_word.

" 调用生成的子程序
PERFORM (lv_form_name) IN PROGRAM (lv_prog).
方面 详情
用途 生成并执行临时子程序池
生命周期 仅在内部会话期间存在
错误处理 MESSAGE、LINE、WORD 附加项捕获语法错误
📌程序生成 vs 动态调用
程序生成在运行时创建新的可执行代码。动态调用(FM、方法)调用的是名称在运行时解析的已有代码。生成代价更高,应谨慎使用。

比较:静态 vs 动态

方面 静态 动态
语法检查 完整的编译时检查 仅在运行时发现错误
性能 最优 名称解析有轻微开销
灵活性 固定 适应运行时条件
安全性 高(编译器捕获) 较低(可能出现运行时错误)
调试 直接 更难追踪
⚠️运行时错误风险
动态规格绕过语法检查。拼写错误的名称、错误的类型或缺失的对象会导致运行时错误(短转储),编译器无法捕获。使用前始终验证动态输入。

考试/测试模式

关键词 / 短语 答案
“动态标识符语法” 数据对象在括号中,不能有空格:(lv_name)
“动态令牌替换字面量” 数据对象直接用在语句位置
“SELECT 中动态 WHERE” WHERE (lv_condition),条件为字符串变量
“CALL FUNCTION 动态” CALL FUNCTION (lv_fm_name)
“动态方法参数传递” PARAMETER-TABLE pt,使用 abap_parmbind_tab
“INSERT REPORT 用途” 从源代码表在仓库中创建程序
“GENERATE SUBROUTINE POOL” 从源代码创建临时可执行子程序池
“动态编程的主要风险” 语法检查无法检测的运行时错误

相关笔记

程序调用 (★★★)

#program-structure #memory-mgmt

同步程序调用:概述

同步程序调用在返回控制权之前执行被调用程序。有两种模式:

模式 类比 对调用者的影响
插入(AND RETURN) 压入栈 调用者暂停,被调用程序结束后恢复
新启动(无 AND RETURN) 替换当前 调用者终止,被调用程序替换它

SUBMIT 语句

SUBMIT 变体比较

变体 行为 会话效果
SUBMIT prog AND RETURN 插入:被调用程序结束后调用者恢复 新的内部会话压入栈顶
SUBMIT prog 替换:调用者被终止 顶层内部会话被替换
SUBMIT ... VIA SELECTION-SCREEN 显示被调用程序的选择屏幕 与基本变体相同
1
2
3
4
5
" 插入 — 报表结束后调用者恢复
SUBMIT zreport AND RETURN.

" 替换 — 调用者终止,zreport 替换它
SUBMIT zreport.

使用 SUBMIT 传递数据

方法 语法 说明
单值 WITH p_param VALUE 传递值给参数
选择选项单值 WITH s_selopt EQ value 添加单条条件
选择选项范围 WITH s_selopt IN range_tab range_tab 必须为 TYPE RANGE
变式 USING VARIANT var_name 使用已保存的变式
💡选择选项的 RANGE 类型
要传递选择选项,声明一个范围表:
1
2
3
DATA: r_bukrs TYPE RANGE OF bkpf-bukrs.
r_bukrs = VALUE #( ( sign = 'I' option = 'EQ' low = '1000' ) ).
SUBMIT zreport WITH s_bukrs IN r_bukrs AND RETURN.

范围表必须包含字段:SIGN、OPTION、LOW、HIGH。

CALL TRANSACTION

语法和附加项

附加项 用途
AND SKIP FIRST SCREEN 如果必填字段已预填,则跳过初始屏幕
MODE mode 控制屏幕显示:A(全部)、E(仅错误)、N(不显示)
UPDATE upd 更新模式:A(异步)、S(同步)、L(本地更新)
USING bdc_tab 使用批输入表驱动事务
MESSAGES INTO itab 将所有消息收集到内表中
1
2
3
4
5
CALL TRANSACTION 'MM01'
USING lt_bdcdata
MODE 'N'
UPDATE 'S'
MESSAGES INTO lt_messages.

显示模式

模式 代码 描述
显示所有屏幕 A 每个屏幕都显示(默认)
仅显示错误 E 仅在出错时显示屏幕
不显示 N 后台处理,不显示任何屏幕

更新模式

模式 代码 行为
异步 A 不等待更新完成(默认)
同步 S 等待更新完成;可通过 sy-subrc 检查成功
本地 L 在当前 LUW 中更新(调试有用)
📌同步更新最安全
当需要确认事务成功时,始终使用 UPDATE 'S'。使用 UPDATE 'A' 时,sy-subrc 仅反映事务调用结果,而非数据库更新结果。

LEAVE TO TRANSACTION

1
LEAVE TO TRANSACTION 'MM01'.
方面 行为
会话效果 销毁整个内部会话栈
ABAP 内存 被清除 – 所有 EXPORT TO MEMORY 数据丢失
比较 与 CALL TRANSACTION(插入)不同,这是新启动
⚠️LEAVE TO TRANSACTION 清除 ABAP 内存
因为整个栈被销毁,ABAP 内存中所有数据(EXPORT/IMPORT)都会丢失。这是常见的考试陷阱。参见 [[_posts/SAP_MM/SCM500_采购流程/00-仪表盘/考试陷阱]]。

BDCDATA 结构

使用 CALL TRANSACTION ... USING bdc_tab 时,BDCDATA 表驱动屏幕字段:

字段 类型 描述
PROGRAM CHAR 40 ABAP 程序名
DYNPRO CHAR 4 屏幕编号
DYNBEGIN CHAR 1 X = 屏幕头行, = 字段行
FNAM CHAR 132 字段名(或 BDC_OKCODE 表示功能码)
FVAL CHAR 132 字段值

BDCDATA 表布局

1
2
3
4
5
6
7
8
+-------------------+--------+----------+------------------+------------------+
| PROGRAM | DYNPRO | DYNBEGIN | FNAM | FVAL |
+-------------------+--------+----------+------------------+------------------+
| SAPLMGMM | 0060 | X | | |
| | | | RMMG1-MATNR | MAT01 |
| | | | RMMG1-MBRSH | M |
| | | | BDC_OKCODE | =ENTR |
+-------------------+--------+----------+------------------+------------------+
💡BDCDATA 模式
每个屏幕以头行(DYNBEGIN = 'X')开始,包含 PROGRAM 和 DYNPRO。后续所有 DYNBEGIN = ' ' 的行设置字段值。使用 FNAM 中的 BDC_OKCODE 触发操作。

收集消息

1
2
3
4
5
6
7
8
9
10
DATA: lt_messages TYPE TABLE OF bdcmsgcoll.

CALL TRANSACTION 'MM01'
USING lt_bdcdata
MODE 'N'
MESSAGES INTO lt_messages.

LOOP AT lt_messages INTO DATA(ls_msg).
" ls_msg-MSGTYP, ls_msg-MSGID, ls_msg-MSGNR, ls_msg-MSGV1...
ENDLOOP.

会话栈图示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
CALL TRANSACTION / SUBMIT AND RETURN(插入):
==============================================

外部会话
┌──────────────────────────────────┐
│ 内部会话栈 │
│ ┌────────────────────────────┐ │
│ │ 被调用程序(新栈顶) │ │
│ ├────────────────────────────┤ │
│ │ 调用者(已暂停) │ │
│ ├────────────────────────────┤ │
│ │ ... 更早的会话 ... │ │
│ └────────────────────────────┘ │
└──────────────────────────────────┘


LEAVE TO TRANSACTION(新启动):
=================================

外部会话
┌──────────────────────────────────┐
│ 内部会话栈 │
│ ┌────────────────────────────┐ │
│ │ 目标事务(唯一) │ │ ← 所有先前的会话被销毁
│ └────────────────────────────┘ │
└──────────────────────────────────┘


SUBMIT 不带 AND RETURN(替换):
=====================================

外部会话
┌──────────────────────────────────┐
│ 内部会话栈 │
│ ┌────────────────────────────┐ │
│ │ 被提交程序(栈顶) │ │ ← 替换了旧的栈顶会话
│ ├────────────────────────────┤ │
│ │ ... 更早的会话 ... │ │
│ └────────────────────────────┘ │
└──────────────────────────────────┘

考试/测试模式

关键词 / 模式 正确答案
SUBMIT … AND RETURN 插入 – 调用者恢复;新的内部会话压入栈
SUBMIT 不带 AND RETURN 替换 – 调用者终止;栈顶会话被替换
LEAVE TO TRANSACTION 销毁整个栈并清除 ABAP 内存
CALL TRANSACTION … MODE ‘N’ 不显示屏幕(后台)
CALL TRANSACTION … UPDATE ‘S’ 同步更新 – 等待数据库提交
BDCDATA DYNBEGIN = ‘X’ 标记屏幕头行(PROGRAM + DYNPRO)
WITH select-option IN range 范围表必须为 TYPE RANGE,包含 SIGN/OPTION/LOW/HIGH
MESSAGES INTO itab 将事务消息收集到 BDCMSGCOLL 表中
AND SKIP FIRST SCREEN 仅在必填字段已预填时跳过初始屏幕
区别:CALL TRANSACTION vs LEAVE TO TRANSACTION CALL 插入(栈增长),LEAVE 销毁(栈重置)

相关笔记

  • 运行时与内存管理 – 内部/外部会话、程序组、ABAP/SAP 内存
  • 共享对象 – 跨会话数据共享的替代方案
  • [[_posts/SAP_MM/SCM500_采购流程/00-仪表盘/考试陷阱]] – LEAVE TO TRANSACTION 清除 ABAP 内存
  • [[_posts/SAP_MM/SCM500_采购流程/00-仪表盘/快速参考]] – 程序调用汇总表

泛型与动态访问 (★★)

#dynamic-prog #data-types #data-reference

概述

泛型数据类型不能直接用于声明数据对象。它们用作形式参数类型和字段符号类型,实际类型在运行时从赋值的数据对象中解析。这是编写灵活、可复用 ABAP 代码的基础。

ABAP 泛型数据类型

泛型 覆盖的完整类型 说明
any 所有数据类型 最泛型;不保证任何操作
any table 所有表类型 泛型内表
c c, d, n, t, string 类字符型
clike c, d, n, t, string 类字符型,可用于字符串函数
csequence c, string 字符序列(用于字符串函数)
data 所有数据类型 与 any 相同
decfloat decfloat16, decfloat34 十进制浮点
index table 标准、排序表 支持索引访问的表
n n 数字文本
numeric i, f, p, decfloat16, decfloat34 可进行数值计算
object 所有对象引用 泛型对象引用
simple 基本类型 + 结构(平坦) 可比较和排序
sorted table 仅排序表 特定表类别
standard table 仅标准表 特定表类别
table 所有表类型 与 any table 相同
x x, xstring 类字节型
xsequence x, xstring 字节序列
📌不能用泛型声明数据对象
DATA: lv_var TYPE any. – 不允许。泛型仅对以下有效:
  • 过程的形式参数(子程序、FM、方法)
  • 字段符号
  • 类型引用(TYPE REF TO data)

泛型类型参数

当形式参数具有泛型类型时,具体类型在运行时从传入的实际参数确定:

1
2
3
4
5
6
FORM process USING p_data TYPE any.
" p_data 继承实际参数的类型
ENDFORM.

PERFORM process USING lv_string. " p_data 表现为 STRING
PERFORM process USING lv_int. " p_data 表现为 I
上下文 类型解析
FORM ... USING p TYPE any 调用时从实际参数
方法参数 TYPE any 调用时从实际参数
FM 参数 TYPE any 调用时从实际参数

泛型类型字段符号

字段符号从赋值的数据对象继承其类型:

1
2
3
4
FIELD-SYMBOLS: <fs> TYPE any.

ASSIGN lv_string TO <fs>. " <fs> 现在表现为 STRING
ASSIGN lv_int TO <fs>. " <fs> 现在表现为 I
💡字段符号与泛型
泛型类型的字段符号是一个”占位符”,采用所赋值对象的类型和值。这是泛型数据访问的主要机制。

泛型数据引用

1
DATA: dref TYPE REF TO data.
属性 行为
声明 TYPE REF TO data 创建泛型数据引用
赋值 可通过 GET REFERENCE OF ... INTO dref 指向任何数据对象
解引用 不能直接使用 dref->*;必须使用 ASSIGN
⚠️泛型数据引用解引用
TYPE REF TO data 变量不能直接用 ->* 解引用。必须使用 ASSIGN dref->* TO <fs> 来访问被引用的数据。
1
2
3
4
5
6
DATA: dref TYPE REF TO data.
FIELD-SYMBOLS: <fs> TYPE any.

CREATE DATA dref TYPE string.
ASSIGN dref->* TO <fs>. " 正确:使用 ASSIGN
<fs> = 'Hello'. " 通过字段符号访问

使用字段符号的类型转换

ASSIGN … CASTING

将赋值数据对象的内存区域视为具有不同类型:

1
2
3
FIELD-SYMBOLS: <hex> TYPE x.

ASSIGN lv_string TO <hex> CASTING. " 将字符串内存解释为原始字节
CASTING 变体 语法 效果
隐式类型 ASSIGN dobj TO <fs> CASTING 使用字段符号的声明类型
显式类型 ASSIGN dobj TO <fs> CASTING TYPE typ 使用指定类型
显式小数 ASSIGN dobj TO <fs> CASTING TYPE p DECIMALS 2 带小数的压缩数
💡CASTING 不转换数据
CASTING 以不同类型重新解释相同的内存内容。它不转换数据。实际类型转换请使用转换函数。

ASSIGN … CASTING TYPE(动态)

1
ASSIGN lv_data TO <fs> CASTING TYPE (lv_type_name).

类型名称在运行时动态解析。

动态 ASSIGN

结构中的动态组件访问

1
2
3
4
5
6
7
8
9
10
FIELD-SYMBOLS: <comp> TYPE any.

" 按组件索引
ASSIGN COMPONENT 3 OF STRUCTURE ls_struct TO <comp>.

" 按组件名(动态)
ASSIGN COMPONENT 'FIELD_NAME' OF STRUCTURE ls_struct TO <comp>.

" 按变量名
ASSIGN COMPONENT lv_comp_name OF STRUCTURE ls_struct TO <comp>.
变体 语法 使用场景
按索引 ASSIGN COMPONENT n OF STRUCTURE 遍历所有组件
按名称(字面量) ASSIGN COMPONENT 'NAME' OF STRUCTURE 已知组件名,静态
按名称(变量) ASSIGN COMPONENT lv_name OF STRUCTURE 组件名在运行时确定

动态属性访问

1
2
3
4
5
6
7
FIELD-SYMBOLS: <attr> TYPE any.

" 动态访问类属性
ASSIGN (lcl_my_class=>lv_attr_name) TO <attr>.

" 通过对象引用访问实例属性
ASSIGN oref->('ATTRIBUTE_NAME') TO <attr>.
📌动态名称的括号语法
括号中的类/属性名遵循与其他动态令牌相同的规则:(name),内部不能有空格。

动态结构组件访问模式

1
2
3
4
5
6
7
8
9
10
11
12
" 泛型:处理任意结构的所有组件
FIELD-SYMBOLS: <comp> TYPE any.
DATA: lo_struct TYPE REF TO cl_abap_structdescr.
DATA: lt_comp TYPE cl_abap_structdescr=>component_table.

lo_struct ?= cl_abap_typedescr=>describe_by_data( ls_any_struct ).
lt_comp = lo_struct->get_components( ).

LOOP AT lt_comp INTO DATA(ls_comp).
ASSIGN COMPONENT ls_comp-name OF STRUCTURE ls_any_struct TO <comp>.
" 泛型处理 <comp> ...
ENDLOOP.

使用数据引用的类型转换

操作 语法 说明
向上转型 oref_super = oref_sub 宽化;始终安全
向下转型 oref_sub ?= oref_super 窄化;可能抛出 CX_SY_MOVE_CAST_ERROR
数据引用向上转型 dref_any = dref_typed 安全:从特定到泛型
数据引用向下转型 dref_typed ?= dref_any 有风险:必须检查兼容性
1
2
3
4
5
6
7
8
9
" 向上转型(安全)
DATA: dref_any TYPE REF TO data.
DATA: dref_str TYPE REF TO string.

CREATE DATA dref_str TYPE string.
dref_any = dref_str. " 向上转型:始终成功

" 向下转型(有风险)
dref_str ?= dref_any. " 向下转型:可能抛出异常
⚠️向下转型需要 ?= 运算符
引用的窄化赋值需要 ?=(或内联的 CAST #(...))。标准 = 仅适用于向上转型。使用 TRY ... CATCH cx_sy_move_cast_error 确保安全。

比较:字段符号 vs 数据引用

方面 字段符号 数据引用
声明 FIELD-SYMBOLS <fs> TYPE any DATA dref TYPE REF TO data
赋值 ASSIGN dobj TO <fs> GET REFERENCE OF dobj INTO dref
访问 直接:<fs> 通过解引用:ASSIGN dref->* TO <fs>
可传递给 FM 否(不是数据对象) 是(是数据对象)
可在内表中 否 是
生命周期 直到取消赋值或超出作用域 直到被垃圾回收
类型转换 ASSIGN ... CASTING 使用 ?= 向上/向下转型

考试/测试模式

关键词 / 短语 答案
“泛型不能声明数据对象” any、data、any table、clike、simple 等
“字段符号类型在运行时确定” 从赋值的数据对象继承类型
“TYPE REF TO DATA 解引用” 必须使用 ASSIGN dref->* TO <fs>;不能直接用 ->*
“ASSIGN COMPONENT 语法” ASSIGN COMPONENT (n|name) OF STRUCTURE struct TO <fs>
“动态属性访问” ASSIGN (class=>attr) TO <fs> 或 ASSIGN oref->('ATTR') TO <fs>
“CASTING 不转换” 以不同类型重新解释相同内存
“引用向下转型运算符” ?=(窄化);可能抛出 CX_SY_MOVE_CAST_ERROR
“泛型引用 vs 类型化引用” TYPE REF TO data 是泛型;TYPE REF TO string 是完整的

相关笔记

字符串处理与正则表达式 (★★★)

#string-processing #data-types

Unicode vs 非 Unicode

方面 Unicode 系统 非 Unicode 系统
字符编码 ISO/IEC 10646 (UTF-16) 依赖代码页
每字符字节数 2(ABAP 中固定) 1(依赖代码页)
字符集 所有 Unicode 字符 限于代码页
现代 SAP 默认 是 仅遗留系统
📌所有现代 SAP 系统都是 Unicode 系统。字符串处理必须考虑每个字符 2 字节。

按类型的数据对象类别

类别 类型 描述
字节型 x, xstring 原始字节;无字符语义
字符型 c, n, d, t, string 字符语义;受代码页影响
数值型 i, f, p, decfloat16, decfloat34 可隐式转换为字符型
💡日期(d)和时间(t)是字符型字段。它们支持特殊算术,但以字符串形式存储和处理。

字符串语句

语句 用途 关键附加项
FIND 搜索子串/正则 REGEX、FIRST OCCURRENCE、ALL OCCURRENCES
REPLACE 替换子串/正则 REGEX、SECTION OFFSET、OF
CONCATENATE 连接字符串 SEPARATED BY、RESPECTING BLANKS
SPLIT 分割字符串到表 AT
TRANSLATE 转换大小写/替换字符 TO UPPER/LOWER、USING
CONDENSE 删除多余空格 NO-GAPS
SHIFT 移动字符串内容 LEFT、RIGHT、CIRCULAR、BY n PLACES
STRLEN 获取长度 返回整数

IN BYTE MODE / IN CHARACTER MODE

  • IN CHARACTER MODE:默认;按字符处理
  • IN BYTE MODE:按字节处理;字节型(x/xstring)操作必需
1
2
FIND lv_byte IN BYTE MODE.
SHIFT lv_string BY 2 PLACES IN CHARACTER MODE.

字符串函数

描述性函数

函数 返回值 说明
strlen( arg ) 字符串长度 字符长度
xstrlen( arg ) xstring 长度 字节长度
numofchar( arg ) 字符数 忽略尾部空格
find( val, sub ) 子串偏移量 未找到返回 -1
find( val, regex ) 正则匹配偏移量 默认区分大小写
count( val, sub ) 计数出现次数 子串或正则
contains( val, sub ) 布尔值 找到子串则为真
matches( val, regex ) 布尔值 正则匹配则为真

处理函数

函数 返回值 说明
substring( val, off, len ) 子串 偏移量和长度
to_upper( val ) 大写
to_lower( val ) 小写
reverse( val ) 反转字符串
repeat( val, n ) 重复字符串
shift_left( val, n ) 左移
shift_right( val, n ) 右移
concat_lines_of( itab, sep ) 连接字符串 从内表

谓词函数

函数 返回值 用法
contains( val, sub ) 布尔值 IF contains( lv_text, abc ).
contains( val, regex ) 布尔值 正则变体
matches( val, regex ) 布尔值 完全匹配检查
💡字符串函数可以链式调用:to_upper( substring( val = lv_text off = 0 len = 5 ) )。

字符串表达式和模板

字符串模板

1
DATA(lv_result) = |Hello { lv_name }, today is { sy-datum DATE = USER }|.

语法:|literal {expression option} literal|

  • 嵌入表达式用 { } 包围
  • { } 外为字面文本
  • 反斜杠 \ 用于转义:\{、\}、\\

字符串连接运算符

1
DATA(lv_full) = lv_first && ` ` && lv_last.
  • && 连接类字符串操作数
  • 两个操作数都转换为 string

嵌入表达式的格式化选项

选项 值 效果
WIDTH = n 整数 最小输出宽度
ALIGN = LEFT、RIGHT、CENTER 宽度内对齐
PAD = 字符 填充字符(默认:空格)
CASE = RAW、UPPER、LOWER 大小写转换
SIGN = LEFT、LEFTPLUS、LEFTSPACE、RIGHT、RIGHTPLUS、RIGHTSPACE 符号显示
DECIMALS = n 整数 小数位数
DATE = RAW、ISO、USER、ENVIRONMENT 日期格式
TIME = RAW、ISO、USER、ENVIRONMENT 时间格式
CURRENCY = 货币代码 依赖货币的格式化
COUNTRY = 国家代码 依赖国家的格式化
ALPHA = IN、OUT 转换出口 ALPHA
NUMBER = RAW、USER、ENVIRONMENT 数字格式
1
2
3
4
5
" 示例
|Value: { lv_num ALIGN = RIGHT WIDTH = 10 PAD = '0' }|
|Date: { sy-datum DATE = ISO }| " 2026-05-10
|Name: { lv_name CASE = UPPER }|
|Amount: { lv_price DECIMALS = 2 CURRENCY = 'EUR' }|

正则表达式

单字符模式

模式 匹配 示例
. 任意单个字符 a.c 匹配 abc、aXc
\d 任意数字(0-9) \d\d 匹配 42
\w 任意单词字符(字母数字 + _) \w+ 匹配 hello_1
\s 任意空白字符
[A-Z] 字符类:A 到 Z
[0-9] 字符类:数字
[abc] 字符类:a、b 或 c
[^abc] 否定类:非 a、b、c

字符串模式(量词和分组)

模式 含义 贪婪?
{n} 恰好 n 次 -
{n,m} n 到 m 次 是(贪婪)
{n,m}? n 到 m 次 否(懒惰)
? 零次或一次 是
* 零次或多次 是
+ 一次或多次 是
` ` 选择(或)
( ) 捕获组
(?: ) 非捕获组
\1, \2 反向引用

最左最长规则

  • 正则引擎在字符串中找到最左的匹配
  • 在同一位置的多个匹配中,选择最长的(贪婪)
  • 懒惰量词(?、*?、+?)优先选择最短匹配
1
2
3
4
" 模式:a.*b  匹配 "aXbYb"
" 贪婪匹配:aXbYb (从最左 'a' 开始的最长匹配)
" 模式:a.*?b 匹配 "aXbYb"
" 懒惰匹配:aXb (从最左 'a' 开始的最短匹配)

在 ABAP 语句中使用正则

1
2
3
4
5
6
7
8
9
10
11
12
13
" FIND 使用正则
FIND REGEX '\d{4}-\d{2}-\d{2}' IN lv_text.
FIND ALL OCCURRENCES OF REGEX '[A-Z]+' IN lv_text RESULTS lt_results.

" REPLACE 使用正则
REPLACE ALL OCCURRENCES OF REGEX '\s+' IN lv_text WITH ` `.

" 字符串函数使用正则
IF matches( val = lv_email regex = '[\w.]+@[\w]+\.[\w]+' ).
" 有效的邮箱模式
ENDIF.

DATA(lv_count) = count( val = lv_text regex = '\d' ).

日期和时间作为字符串

类型 长度 格式 算术
d(日期) 8 字符 YYYYMMDD 支持 + n / - n(天),减法 = 相隔天数
t(时间) 6 字符 HHMMSS 支持 + n / - n(秒)
1
2
3
4
5
DATA: lv_date TYPE d VALUE '20260510',
lv_tomorrow TYPE d.

lv_tomorrow = lv_date + 1. " 20260511
DATA(lv_days) = lv_tomorrow - lv_date. " 1
💡日期和时间字段以字符串形式存储但支持隐式算术。这是 ABAP 的特殊功能,不是通用的字符串算术。

考试/测试模式

关键词/模式 答案
“Unicode 每字符字节数” Unicode 系统中每字符 2 字节
“字节型 vs 字符型” x/xstring = 字节;c/n/d/t/string = 字符
“| \{ \} 模板” 带嵌入表达式的字符串模板
“&& 运算符” 表达式中的字符串连接
“IN BYTE MODE” x/xstring 类型操作必需
“find() vs contains()“ find 返回偏移量;contains 返回布尔值
“matches() 函数” 完全正则匹配;返回布尔值
“最左最长” 正则匹配规则:找最左,然后最长
“(?: ) 非捕获组” 不创建反向引用的分组
“DATE = ISO” 在字符串模板中将日期格式化为 YYYY-MM-DD
“CONDENSE NO-GAPS“ 删除字符串中所有空格
“字符串模板转义” 使用 \{ 和 \} 表示字面大括号
“CURRENCY 格式化” 模板中依赖货币的小数位数

相关笔记

内表特殊技术 (★★★)

#internal-tables

二分搜索(BINARY SEARCH)

  • 要求读取前数据按读取键排序
  • 在标准表上:必须先 SORT,再使用 BINARY SEARCH 读取
  • 在排序表上:自动(WITH TABLE KEY 内置二分搜索)
  • 如果表未按读取键排序,结果不可预测(不报错)
1
2
3
4
5
6
" 标准表:必须先排序
SORT lt_standard BY name.
READ TABLE lt_standard INTO ls_wa WITH KEY name = 'Smith' BINARY SEARCH.

" 排序表:自动
READ TABLE lt_sorted INTO ls_wa WITH TABLE KEY name = 'Smith'.
⚠️在未排序的表上使用 BINARY SEARCH 不会报错。它只会返回不正确或不可预测的结果。务必确保排序顺序与读取键匹配。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
标准表使用 BINARY SEARCH:
+--------------------+
| 1. SORT 按读取键 | <-- 二分搜索前必需
+--------------------+
|
+--------------------+
| 2. READ TABLE ... | <-- BINARY SEARCH 附加项
| WITH KEY ... |
| BINARY SEARCH |
+--------------------+

排序表:
+--------------------+
| READ TABLE ... | <-- 二分搜索自动执行
| WITH TABLE KEY ... | (不需要 BINARY SEARCH)
+--------------------+

DELETE ADJACENT DUPLICATES(删除相邻重复项)

  • 仅删除相邻的重复行
  • 表必须先排序(按比较字段)
  • COMPARING 附加项指定比较哪些字段
1
2
3
4
5
6
7
8
" 先排序!
SORT lt_data BY id.

" 按指定字段比较删除相邻重复项
DELETE ADJACENT DUPLICATES FROM lt_data COMPARING id.

" 比较所有字段删除相邻重复项(默认)
DELETE ADJACENT DUPLICATES FROM lt_data.
附加项 行为
(无 COMPARING) 比较字符型和数值型的所有字段
COMPARING f1 f2 ... 仅比较指定字段
COMPARING ALL FIELDS 显式比较所有字段
📌DELETE ADJACENT DUPLICATES 仅删除相邻的重复项。如果表未先排序,不相邻的重复项会保留。

COLLECT(收集)

  • 将数值字段添加到匹配键的已有行
  • 如果没有匹配行,插入新行
  • 键比较基于所有非数值字段
  • 仅适用于平坦行类型(不含深层结构)
1
2
3
4
5
6
7
8
9
10
11
12
13
DATA: BEGIN OF ls_totals,
category TYPE string,
amount TYPE i,
END OF ls_totals.
DATA: lt_totals LIKE TABLE OF ls_totals.

" 首次出现:插入新行
ls_totals-category = 'A'. ls_totals-amount = 10.
COLLECT ls_totals INTO lt_totals.

" 找到匹配键:累加金额(10 + 20 = 30)
ls_totals-category = 'A'. ls_totals-amount = 20.
COLLECT ls_totals INTO lt_totals.
1
2
3
4
5
6
7
COLLECT 处理过程:
+--------------------------------------------+
| 1. 提取非数值字段作为键 |
| 2. 搜索具有相同键的已有行 |
| +--> 找到:将数值字段加到该行 |
| +--> 未找到:插入新行 |
+--------------------------------------------+
⚠️COLLECT 仅适用于平坦行类型。深层结构(包含内表、字符串、引用)会导致运行时错误。
特性 行为
键字段 所有非数值字段
数值字段 求和(累加)
行类型 仅平坦
表类型 任意(但带唯一键的哈希表最理想)

次键(NW 7.0 EhP2)

用途

  • 在主键之外为表定义额外的键
  • 通过不同字段组合实现优化访问
  • 避免对不同访问模式反复排序标准表

次键类型

类型 语法 唯一性 访问
NON-UNIQUE SORTED WITH NON-UNIQUE SORTED KEY 非唯一 二分搜索 O(log n)
UNIQUE HASHED WITH UNIQUE HASHED KEY 唯一 哈希搜索 O(1)

语法

1
2
3
4
5
6
7
8
9
10
TYPES: BEGIN OF ty_struc,
id TYPE i,
name TYPE string,
dept TYPE string,
END OF ty_struc.

TYPES: ty_employees TYPE STANDARD TABLE OF ty_struc
WITH NON-UNIQUE KEY id
WITH NON-UNIQUE SORTED KEY sec_name COMPONENTS name
WITH UNIQUE HASHED KEY sec_dept COMPONENTS dept.

使用

1
2
3
4
5
6
7
8
9
10
DATA: lt_emp TYPE ty_employees.

" 使用次键读取
READ TABLE lt_emp INTO ls_wa USING KEY sec_name
WITH KEY name = 'Smith'.

" 使用次键循环
LOOP AT lt_emp INTO ls_wa USING KEY sec_name.
" 按 name 顺序处理
ENDLOOP.

何时使用次键

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
+------------------------------------------------------+
| 何时需要次键? |
+------------------------------------------------------+
| |
| 1. 同一表需要通过不同键字段访问 |
| (例如,按 ID 和按 name) |
| |
| 2. 标准表需要按非主键字段排序访问 |
| |
| 3. 避免每次不同读取模式前显式 SORT |
| |
| 不应使用的情况: |
| - 仅有一种访问模式 |
| - 表很小(< 100 行) |
| - 填充比率远高于读取比率 |
+------------------------------------------------------+
💡次键有代价:填充/修改表时,所有次键索引必须更新。仅在读取优化收益超过填充代价时使用。

INSERT INTO TABLE vs APPEND

语句 行为 表类型兼容性
APPEND wa TO itab 在末尾添加行 仅标准表
INSERT wa INTO TABLE itab 根据表类型插入 所有表类型
INSERT wa INTO itab INDEX n 在位置 n 插入 仅标准表
1
2
3
4
5
6
7
" APPEND:总是在末尾(标准表)
APPEND ls_wa TO lt_standard.

" INSERT INTO TABLE:根据类型行为不同
INSERT ls_wa INTO TABLE lt_standard. " 在末尾追加
INSERT ls_wa INTO TABLE lt_sorted. " 插入到正确排序位置
INSERT ls_wa INTO TABLE lt_hashed. " 插入到哈希桶
💡使用 INSERT INTO TABLE 进行泛型编程。它能正确适用于所有表类型。

表表达式(新语法)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
" 使用表表达式读取行
DATA(ls_row) = lt_itab[ id = '123' ].

" 使用次键
DATA(ls_row2) = lt_itab[ USING KEY sec_name name = 'Smith' ].

" 安全访问使用 OPTIONAL(防止 CX_SY_ITAB_LINE_NOT_FOUND)
DATA(ls_safe) = VALUE #( lt_itab[ id = '999' ] OPTIONAL ).

" 检查存在性
IF line_exists( lt_itab[ id = '123' ] ).
" 行存在
ENDIF.

" 获取匹配行的索引
DATA(lv_idx) = line_index( lt_itab[ name = 'Smith' ] ).
表达式/函数 返回值 未找到时异常?
itab[ key = val ] 行(副本) 是:CX_SY_ITAB_LINE_NOT_FOUND
... OPTIONAL 默认值 否(返回初始值)
line_exists( ... ) 布尔值 否
line_index( ... ) 索引或 0 否
⚠️表表达式 itab[ ... ] 在没有行匹配时抛出 CX_SY_ITAB_LINE_NOT_FOUND。使用 OPTIONAL 或 line_exists() 进行安全访问。

考试/测试模式

关键词/模式 答案
“BINARY SEARCH 未排序表” 返回不可预测的结果;不报错
“DELETE ADJACENT DUPLICATES” 仅删除相邻重复项;需先排序
“COMPARING 附加项” 指定重复比较的字段
“COLLECT 仅限平坦类型” 深层结构导致运行时错误
“COLLECT 键字段” 所有非数值字段组成键
“次键类型” NON-UNIQUE SORTED 或 UNIQUE HASHED
“USING KEY” 指定用于访问的次键
“INSERT INTO TABLE” 泛型插入;适用于所有表类型
“APPEND” 仅标准表;在末尾添加
“表表达式异常” 未找到行时抛出 CX_SY_ITAB_LINE_NOT_FOUND
“line_exists()” 返回布尔值;无异常
“何时使用次键” 同一表有多种访问模式

相关笔记

动态编程练习 (10题)

#practice #dynamic-prog #rtti #rttc #data-reference

相关概念

📌核心模式(点击查看)
关键词 答案
动态字面量令牌 数据对象直接在语句中
动态标识符令牌 数据对象在括号中,不能有空格
泛型 REF TO DATA 必须使用 ASSIGN 解引用
RTTI 根类 CL_ABAP_TYPEDESCR
RTTC 限制 不能动态创建类/接口

第1题 - 动态令牌 [记忆]

用动态令牌替换字面量和替换标识符的语法区别是什么?

📌点击查看答案
  • 替换字面量:数据对象直接出现在语句中。示例:WRITE lv_text.,其中 lv_text 包含文本。
  • 替换标识符:数据对象必须在不带空格的括号中。示例:CALL FUNCTION (lv_fm_name).,其中 lv_fm_name 包含函数模块名称。

第2题 - 动态 SQL [应用]

编写一个动态 SELECT 语句,表名和 WHERE 条件都在运行时确定。

📌点击查看答案
1
2
3
4
DATA: lv_table TYPE string VALUE 'SFLIGHT',
lv_where TYPE string VALUE `carrid = 'LH'`.

SELECT * FROM (lv_table) INTO TABLE lt_data WHERE (lv_where).

FROM 子句和 WHERE 子句都使用括号中的动态令牌。


第3题 - 动态方法调用 [记忆]

如何动态地向方法调用传递参数?

📌点击查看答案
使用 PARAMETER-TABLE 和 EXCEPTION-TABLE 附加项:
1
2
3
CALL METHOD (lv_method) OF lo_obj
PARAMETER-TABLE lt_params
EXCEPTION-TABLE lt_exceptions.

lt_params 类型为 ABAP_PARMBIND_TAB,包含名称-值对。lt_exceptions 类型为 ABAP_EXCPBIND_TAB。


第4题 - 泛型数据引用 [应用]

使用 TYPE REF TO DATA 创建数据引用。为什么不能直接用 ->* 访问数据?

📌点击查看答案
因为 TYPE REF TO DATA 是泛型类型 – 编译器在编译时不知道被引用数据对象的结构。必须使用 ASSIGN 解引用:
1
2
3
4
5
DATA: dref TYPE REF TO data.
FIELD-SYMBOLS: <fs> TYPE any.
CREATE DATA dref TYPE i.
ASSIGN dref->* TO <fs>.
<fs> = 42.

第5题 - ASSIGN CASTING [记忆]

ASSIGN ... CASTING 的作用是什么?何时使用?

📌点击查看答案
ASSIGN ... CASTING 让你将数据对象的内存区域视为具有不同类型。字段符号的类型被强加到赋值的数据上而不进行转换。

变体:

  • ASSIGN dref->* TO <fs> CASTING. – 使用字段符号的类型
  • ASSIGN dref->* TO <fs> CASTING TYPE ty_my_type. – 使用显式类型

使用场景:处理需要强加特定结构类型的泛型数据引用时。


第6题 - RTTI 类层次结构 [记忆]

说出用于数据类型描述的主要 RTTI 类及其各自描述的内容。

📌点击查看答案
类 描述
CL_ABAP_TYPEDESCR 根类(所有类的基类)
CL_ABAP_DATADESCR 所有数据类型
CL_ABAP_ELEMDESCR 基本类型(i, f, c, string 等)
CL_ABAP_STRUCTDESCR 结构类型
CL_ABAP_TABLEDESCR 内表类型
CL_ABAP_REFDESCR 引用类型
CL_ABAP_CLASSDESCR 类类型
CL_ABAP_INTFDESCR 接口类型

第7题 - RTTI describe_by 方法 [应用]

编写代码获取名为 ‘SPFLI’ 的结构的类型描述并确定其 KIND。

📌点击查看答案
1
2
3
4
5
6
7
8
9
10
DATA: lo_type TYPE REF TO cl_abap_typedescr.

cl_abap_typedescr=>describe_by_name(
EXPORTING p_name = 'SPFLI'
RECEIVING p_descr_ref = lo_type
EXCEPTIONS type_not_found = 1 ).

IF lo_type->kind = cl_abap_typedescr=>kind_struct.
" 是结构
ENDIF.

KIND 值:kind_elem、kind_struct、kind_table、kind_ref、kind_class、kind_intf。


第8题 - 运行时 CREATE DATA [应用]

编写代码动态创建行类型与数据库表 SPFLI 匹配的内表。

📌点击查看答案
1
2
3
4
5
DATA: gr_data TYPE REF TO data.
FIELD-SYMBOLS: <fs_table> TYPE ANY TABLE.

CREATE DATA gr_data TYPE TABLE OF spfli.
ASSIGN gr_data->* TO <fs_table>.

或完全动态:

1
2
3
DATA: lv_tabname TYPE string VALUE 'SPFLI'.
CREATE DATA gr_data TYPE TABLE OF (lv_tabname).
ASSIGN gr_data->* TO <fs_table>.

第9题 - RTTC 表类型创建 [分析]

解释使用 RTTC 动态创建表类型然后用于创建数据对象的步骤。

📌点击查看答案
步骤:
  1. 获取行类型描述符:lo_line = cl_abap_typedescr=>describe_by_name('SPFLI').
  2. 向下转型为数据描述符:lo_data ?= lo_line.
  3. 创建表类型:lo_table = cl_abap_tabledescr=>create( p_line_type = lo_data ).
  4. 使用动态类型创建数据对象:CREATE DATA dref TYPE HANDLE lo_table.
  5. 解引用:ASSIGN dref->* TO <fs_table>.

create() 的可选参数:p_table_kind(standard/sorted/hashed)、p_unique、p_key、p_key_kind。


第10题 - RTTC 限制 [分析]

RTTC 有哪些限制?至少说出两件不能做的事情。

📌点击查看答案
  1. 不能生成类或接口 – RTTC 仅限于数据类型
  2. 不能创建不作为构建块已存在的类型(例如,组件需要已有的 RTTI 描述符)
  3. 动态创建的类型是匿名的 – 它们在类型系统中没有名称,只能通过 HANDLE 引用
  4. 使用 HANDLE 的 CREATE DATA 创建的是匿名数据对象,没有名称 – 只能通过引用访问

📌模式总结(点击查看)
关键词 答案
字面量令牌 数据对象直接使用
标识符令牌 括号,不能有空格
泛型 REF TO DATA 必须 ASSIGN 解引用
CASTING 强加类型但不转换
RTTI 根类 CL_ABAP_TYPEDESCR
describe_by_name 通过名称字符串获取类型
KIND 值 elem, struct, table, ref, class, intf
RTTC 创建表 describe_by_name → create → CREATE DATA HANDLE
0%