代码拉取完成，页面将自动刷新
Regarding "dynamic" in contrast to "static" aspects, ABAP programs can include both dynamic and static parts.
Consider a data object in your program:
It can be declared as a static data object, i. e. you provide all attributes by specifying the data type and more statically in the code.
"Internal table declaration
DATA itab TYPE TABLE OF zdemo_abap_carr WITH EMPTY KEY.
The name itab of the data object is determined at compile time and remains stable throughout the execution of the program.
However, there can also be use cases where the attributes of such a data object are not statically determined. This is where dynamic aspects enter the picture: Attributes, names, types etc. are not determined at compile time but rather at runtime.
There are ABAP statements that include these dynamic aspects in the syntax. Assume you have simple program and a UI that includes an input field storing the input in a data object named dbtab. As input, you expect the name of a database table to be provided. In the end, you want to retrieve all entries of the database table and store them in an internal table. This table should be displayed. So, there is random input at runtime and your program must be able to deal with it.
See the following SELECT statement. As also shown further down, the FROM clause does not include a statically defined table to be selected from. Instead, there is a pair of parentheses including a data object. Assume the data object holds the name of the database table. At runtime, the data retrieval happens from the database table that was inserted in the input field.
SELECT *
FROM (dbtab)
INTO TABLE @DATA(some_itab).
Further aspects for dynamic programming in ABAP enter the picture if you want to determine information about data types and data objects at runtime (RTTI) or even create them (RTTC).
In general, dynamic programming also comes with some downsides. For example, the ABAP compiler cannot check the dynamic programming feature like the SELECT statement mentioned above. There is no syntax warning or suchlike. The checks are performed at runtime only which has an impact on the performance. Plus, the testing of procedures
that include dynamic programming features is difficult.
Field symbols and data references are dealt with here since they are supporting elements for dynamic programming.
Field symbols ...
ASSIGN). Note that you can only work with the field symbols if indeed they have been assigned before.FIELD-SYMBOLS or the declaration operator FIELD-SYMBOL. Their names must be included between angle brackets.Declaring field symbols
Syntax:
"Declaring field symbols using the FIELD-SYMBOLS statement
"and providing a complete/generic type
"Examples for complete types
FIELD-SYMBOLS: <fs_i> TYPE i,
<fs_fli> TYPE zdemo_abap_fli,
<fs_tab_type> TYPE LINE OF some_table_type,
<fs_like> LIKE some_data_object.
"Examples for generic types
FIELD-SYMBOLS <fs_data> TYPE data.
FIELD-SYMBOLS <fs_any_table> TYPE any table.
"Declaring field symbols inline
"The typing of the field symbol is determined using the statically
"known type of the assigned memory area.
"Prominent use case: Inline declaration of a field symbol for an internal table.
LOOP AT itab ASSIGNING FIELD-SYMBOL(<line>).
...
ENDLOOP.
💡 Note
- After its declaration, a field symbol is initial, i. e. a memory area is not (yet) assigned to it (apart from the inline declaration). If you use an unassigned field symbol, an exception is raised.
- There are plenty of options for generic ABAP types. A prominent one is
datathat stands for any data type (the older generic typeanyhas the same effect). See more information in the topic Generic ABAP Types.- Field symbols cannot be declared in the declaration part of classes and interfaces.
Assigning data objects
ASSIGN
statements assign the memory area of a data object to a field symbol.
Once the memory area is assigned, you can work with the content.
"Some data object declarations to be used
DATA: number TYPE i,
struc TYPE sflight,
tab TYPE string_table.
"Declaring field symbols with complete types
FIELD-SYMBOLS: <fs_i> TYPE i,
<fs_struc> TYPE sflight,
<fs_tab> TYPE string_table.
"Declaring field symbols with generic type
FIELD-SYMBOLS <fs_gen> TYPE data.
"Assigning data objects to field symbols
"Note: In this case, the field symbols have an appropriate type.
ASSIGN number TO <fs_i>.
ASSIGN struc TO <fs_struc>.
ASSIGN tab TO <fs_tab>.
ASSIGN number TO <fs_gen>. "Could be any of the data objects
"Inline declaration is possible, too. The type
"is automatically derived.
ASSIGN number TO FIELD-SYMBOL(<fs_inl>).
"You can also assign a particular component of a structure.
"Second component of the structure
ASSIGN COMPONENT 2 OF STRUCTURE struc TO <fs_gen>.
ASSIGN COMPONENT 'CARRID' OF STRUCTURE struc TO <fs_gen>.
"CASTING addition for matching types of data object and field symbol
"when assigning memory areas
TYPES c_len_3 TYPE c LENGTH 3.
DATA(chars) = 'abcdefg'.
FIELD-SYMBOLS <fs1> TYPE c_len_3.
"Implicit casting
ASSIGN chars TO <fs1> CASTING.
FIELD-SYMBOLS <fs2> TYPE data.
"Explicit casting
ASSIGN chars TO <fs2> CASTING TYPE c_len_3.
💡 Note
- If you use an unassigned field symbol, an exception is raised. Before using it, you can check the assignment with the following logical expression. The statement is true if the field symbol is assigned.
IF <fs> IS ASSIGNED. ... ENDIF.- Using the statement
UNASSIGN, you can explicitly remove the assignment of the field symbol. ACLEARstatement only initializes the value.UNASSIGN <fs>.- See more information on the addition
CASTINGhere.
Field symbols in use
"For example, in assignments
DATA: number TYPE i VALUE 1.
FIELD-SYMBOLS <fs_i> TYPE i.
ASSIGN number TO <fs_i>.
<fs_i> = 2.
"The data object 'number' has now the value 2.
"Loops
"Here, field symbols are handy since you can avoid an
"actual copying of the table line to boost performance.
SELECT * FROM zdemo_abap_fli
INTO TABLE @DATA(itab).
FIELD-SYMBOLS <fs1> LIKE LINE OF itab.
LOOP AT itab ASSIGNING <fs1>.
<fs1>-carrid = ... "The field symbol represents a line of the table.
<fs1>-connid = ... "Components are accessed with the component selector.
"Here, a new value is assigned.
...
ENDLOOP.
"Inline declaration of field symbol
LOOP AT itab ASSIGNING FIELD-SYMBOL(<fs2>).
<fs2>-carrid = ...
<fs2>-connid = ...
...
ENDLOOP.
Data references ...
REF TO followed by a static type. Note the dynamic type in this context: The dynamic type of such a variable is the data type to which it actually points. This concept is particularly relevant in the context of assignments (see the assignment rules here).data can be used as generic type.💡 Note
Object references and object reference variables are not part of this cheat sheet. To get more details, refer to the ABAP Keyword Documentation or the cheat sheet ABAP Object Orientation.
Declaring data reference variables
"Example declarations of data reference variables
"Note that they do not yet point to a data object.
DATA: ref1 TYPE REF TO i, "Complete data type
ref2 TYPE REF TO some_dbtab, "Complete data type
ref3 LIKE REF TO some_data_object,
ref4 TYPE REF TO data. "Generic data type
Creating data references to existing data objects using the
reference operator
REF.
"Declaring a data object
DATA num TYPE i VALUE 5.
"Declaring data reference variables
DATA ref1 TYPE REF TO i.
DATA ref_gen TYPE REF TO data.
"Creating data references to data objects.
"The # sign means that the type is derived from the context.
ref1 = REF #( num ).
ref_gen = REF #( num ).
"You can also use inline declarations to omit the explicit declaration.
DATA(ref2) = REF #( num ).
"You can explicitly specify the data type after REF.
DATA(ref3) = REF string( `hallo` ).
"The older syntax GET REFERENCE having the same effect
"should not be used anymore.
"GET REFERENCE OF num INTO ref1.
"GET REFERENCE OF num INTO DATA(ref4).
Creating new data objects at runtime: You create an anonymous
data object
at runtime by assigning the reference to the data object of a data reference variable. You can use the instance
operator
NEW.
The older syntax CREATE DATA
has the same effect as using the newer instance operator.
"Declaring data reference variables
DATA ref1 TYPE REF TO i. "Complete type
DATA ref_gen TYPE REF TO data. "Generic type
"Creating anonymous data objects
"Using the # sign and the explicit type: see REF #( ) above.
ref1 = NEW #( ).
ref_gen = NEW string( ).
"For directly assigning values, insert the values within the parentheses.
ref1 = NEW #( 123 ).
"Using inline declarations to omit a prior declaration of a variable.
DATA(ref2) = NEW i( 456 ).
TYPES i_table TYPE STANDARD TABLE OF i WITH EMPTY KEY.
DATA(ref3) = NEW i_table( ( 1 ) ( 2 ) ( 3 ) ( 4 ) ( 5 ) ).
"CREATE DATA statements (older syntax)
DATA ref4 TYPE REF TO string.
DATA ref5 TYPE REF TO data.
CREATE DATA ref4.
"Note: TYPE ... needed because of generic type data
CREATE DATA ref5 TYPE p LENGTH 6 DECIMALS 2.
CREATE DATA ref5 LIKE ref4.
Assigning existing data references to other data references. As mentioned above regarding the assignment, note that static types of both data reference variables must be compatible. As a result of an assignment, both the target reference variable and the source reference variable point to the same data object.
Excursion: Static vs. dynamic type, upcasts and downcasts
Data reference variables have ...
i is the static type in this example: DATA ref TYPE REF TO i.. The static type can also be a generic data type: DATA ref TYPE REF TO data..For an assignment to work, the differentiation is particularly relevant since the following basic rule applies: The static type of the target reference variable must be more general than or the same as the dynamic type of the source reference variable.
This is where the concepts of upcast and downcast enter the picture.
=.CAST. In older code, you might see
the operator ?=)."Examples demonstrating up- and downcasts
"Declaring data reference variables
DATA ref1 TYPE REF TO i.
DATA ref2 TYPE REF TO i.
ref1 = NEW #( 789 ).
"Assignments
ref2 = ref1.
"Casting
"Complete type
DATA(ref3) = NEW i( 321 ).
"Generic type
DATA ref4 TYPE REF TO data.
"Upcast
ref4 = ref3.
"Downcasts
DATA ref5 TYPE REF TO i.
"Generic type
DATA ref6 TYPE REF TO data.
ref6 = NEW i( 654 ).
ref5 = CAST #( ref6 ).
"Old casting operator
ref5 ?= ref6.
Addressing data references
Before addressing the content of data objects a data reference points to, you must dereference data reference variables. Use the
dereferencing operator
->*. To check if dereferncing works, you can use a logical expression with IS BOUND.
"Creating data reference variables and assign values
DATA(ref_i) = NEW i( 1 ).
DATA(ref_carr) = NEW zdemo_abap_carr( carrid = 'LH' carrname = 'Lufthansa' ).
"Generic type
DATA ref_gen TYPE REF TO data.
ref_gen = ref_i. "Copying reference
"Accessing
"Variable number receives the content.
DATA(number) = ref_i->*.
"Content of referenced data object is changed.
ref_i->* = 10.
"Data reference used in a logical expression.
IF ref_i->* > 5.
...
ENDIF.
"Dereferenced generic type
DATA(calc) = 1 + ref_gen->*.
"Structure
"Complete structure
DATA(struc) = ref_carr->*.
"When dereferencing a data reference variable that has a structured
"data type, you can use the component selector -> to address individual components
DATA(carrid) = ref_carr->carrid.
ref_carr->carrid = 'UA'.
"This syntax also works but it is less "comfortable".
ref_carr->*-carrname = 'United Airlines'.
"Checking if a data reference variable can be dereferenced.
IF ref_carr IS BOUND.
...
ENDIF.
"Explicitly removing a reference
"However, the garbage collector takes care of removing the references
"automatically once the data is not used any more by a reference.
CLEAR ref_carr.
Data references in use
Some example contexts of using data references are as follows:
Overwriting data reference variables:
ref = NEW i( 1 ).
"ref is overwritten here because a new object is created
"with a data reference variable already pointing to a data object
ref = NEW i( 2 ).
Retaining data references:
"This snippet shows that three data references are created
"with the same reference variable. Storing them in an internal table
"using the TYPE TABLE OF REF TO prevents the overwriting.
DATA: ref TYPE REF TO data,
itab TYPE TABLE OF REF TO data,
number TYPE i VALUE 0.
DO 3 TIMES.
"Adding up 1 to demonstrate a changed data object.
number += 1.
"Creating data reference and assigning value.
"In the course of the loop, the variable gets overwritten.
ref = NEW i( number ).
"Adding the reference to itab
itab = VALUE #( BASE itab ( ref ) ).
ENDDO.
Processing internal tables:
"Similar use case to using field symbols: In a loop across an internal table,
"you can store the content of the line in a data reference variable
"instead of actually copying the content to boost performance.
"Filling an internal table.
SELECT * FROM zdemo_abap_fli
INTO TABLE @DATA(fli_tab).
LOOP AT fli_tab REFERENCE INTO DATA(ref).
"A component of the table line might be addressed.
ref->carrid = ...
...
ENDLOOP.
Data reference variables as part of structures and internal tables:
"In contrast to field symbols, data reference variables can be used as
"components of structures or columns in internal tables.
"Structure
DATA: BEGIN OF struc,
num TYPE i,
ref TYPE REF TO i,
END OF struc.
"Some value assignment
struc2 = VALUE #( num = 1 ref = NEW #( 2 ) ).
"Internal table
DATA itab LIKE TABLE OF struc WITH EMPTY KEY.
"Some value assignment in the first table line
"assuming the table is filled and a line is available.
itab[ 1 ]-ref->* = 123.
✔️ Hint
The question might now arise when to actually use either a field symbol or a data reference variable. It depends on your use case. However, data reference variables are more powerful as far as their usage options are concerned, and they better fit into the modern (object-oriented) ABAP world. Recommended read: Accessing Data Objects Dynamically (F1 docu for standard ABAP).
As already touched on above, there are ABAP statements that support the dynamic specification of syntax elements.
In this context, you can use character-like data objects (or, for example, in the SELECT list, a standard table with a character-like row type) - the content is usually provided in capital letters - specified within a pair of parentheses. They can be included as operands in many ABAP statements
(e. g. SORT table BY (field_name).).
Note that this has downsides, too. Consider some erroneous character-like content of such data objects. There is no syntax warning. At runtime, it can lead to runtime errors. For the rich variety of options (where dynamic specification is possible for ABAP statements), check the ABAP Keyword Documentation. The following snippets are meant to give you an idea and overview.
Dynamically specifying data objects
"Here, the names of fields are stored in a character-like data object
"The sorting is done by a field that is determined at runtime.
DATA(field_name) = 'SOME_FIELD'. "maybe the data object/field name is changed at runtime
...
SORT itab BY (field_name).
"A field symbol is assigned a data object; here, an attribute of a class
ASSIGN class=>(attribute_name) TO FIELD-SYMBOL(<fs>).
"In newer ABAP releases, you can dynamically specify structure components using this syntax
ASSIGN struc-(comp1) TO <fs>.
"Accessing components of structures that are referenced by a data reference variable
ASSIGN dref->(comp1) TO <fs>.
Dynamically specifying data types
"Anonymous data objects are created using a type determined at runtime.
"Note that the NEW operator cannot be used here.
CREATE DATA ref TYPE (some_type).
CREATE DATA ref TYPE TABLE OF (some_type).
"Assigning a data object to a field symbol casting a type
ASSIGN dobj TO <fs> CASTING TYPE (some_type).
"Assigning a structure component dynamically to a field symbol that is declared inline
DATA struct TYPE zdemo_abap_flsch.
ASSIGN struct-('CARRID') TO FIELD-SYMBOL(<fs>).
Dynamic specification of clauses in ABAP SQL statements
"Dynamic SELECT list
DATA(select_list) = `CARRID, CONNID, COUNTRYFR, COUNTRYTO`.
SELECT (select_list)
FROM zdemo_abap_fli
INTO TABLE @itab.
"Dynamic FROM clause
DATA(table) = `ZDEMO_ABAP_FLI`.
SELECT *
FROM (table)
INTO TABLE @itab.
"Dynamic WHERE clause
"This is an example for using an internal table with a character-like row type
DATA(where_clause) = VALUE string_table( ( `CARRID = 'LH'` )
( `OR CARRID = 'AA'` ) ).
SELECT *
FROM zdemo_abap_fli
WHERE (where_clause)
INTO TABLE @itab.
Dynamic invoke: Dynamically specifying procedure calls
"Note that dynamic method calls require a CALL METHOD statement.
"Note: The following 3 examples assume that there are no
"mandatory parameters defined for the method.
"Method dynamically specified
CALL METHOD class=>(meth).
"Class dynamically specified
CALL METHOD (class)=>meth.
"Class and method dynamically specified
CALL METHOD (class)=>(meth).
"Assigning actual parameters to the formal parameters statically
CALL METHOD class=>(meth) EXPORTING p1 = a1 p2 = a2 ...
IMPORTING p1 = a1 p2 = a2 ...
"Assigning actual parameters to the formal parameters dynamically
DATA ptab TYPE abap_parmbind_tab.
ptab = ...
CALL METHOD class=>(meth) PARAMETER-TABLE ptab.
"Notes on PARAMETER-TABLE ptab
"- The table (of type abap_parmbind_tab; line type is abap_parmbind) must
" be filled and have a line for all non-optional parameters.
"- Components: name -> formal parameter name
" kind -> kind of parameter, e. g. importing
" value -> pointer to appropriate actual parameter,
" is of type REF TO data
"The addition EXCEPTION-TABLE for exceptions is not dealt with here.
RTTS represent a hierarchy of type description classes containing methods for Runtime Type Creation (RTTC) and Runtime Type Identification (RTTI). Using these classes, you can ...
The hierarchy of type description classes is as follows.
CL_ABAP_TYPEDESCR
|
|--CL_ABAP_DATADESCR
| |
| |--CL_ABAP_ELEMDESCR
| | |
| | |--CL_ABAP_ENUMDESCR
| |
| |--CL_ABAP_REFDESCR
| |--CL_ABAP_COMPLEXDESCR
| |
| |--CL_ABAP_STRUCTDESCR
| |--CL_ABAP_TABLEDESCR
|
|--CL_ABAP_OBJECTDESCR
|
|--CL_ABAP_CLASSDESCR
|--CL_ABAP_INTFDESCR
So, the
superclass
CL_ABAP_TYPEDESCR has multiple
subclasses,
for example, to deal with each kind of type.
Working with this inheritance tree means making use of
casts,
especially
downcasts when retrieving information at runtime.
Detailing out all the possibilities for the information retrieval and
type creation is beyond scope. Check the information, options and
various methods that can be used in the class documentation, e. g. using
F2 help information in
ADT,
for more details.
The following examples show the retrieval of information. Instead of the cumbersome extra declaration of data reference variables, you can use inline declarations. Method chaining comes in handy, too.
"The properties of a type are retrieved using RTTI
DATA(some_type) = cl_abap_typedescr=>describe_by_data( var ).
"The components of a structure are retrieved.
"Like above, the describe_by_data method is used together with a variable.
DATA(components) = CAST cl_abap_structdescr(
cl_abap_typedescr=>describe_by_data( some_struc )
)->components.
"The attributes of a global class are retrieved. In contrast to the
"example above the describe_by_name method is used together with the actual name.
DATA(attributes) = CAST cl_abap_classdescr(
cl_abap_classdescr=>describe_by_name( 'CL_SOME_CLASS' )
)->attributes.
The following example demonstrates the dynamic creation of data objects.
Note the TYPE HANDLE
addition as part of the CREATE DATA statement that is used when referring to dynamically created data types.
"RTTC examples
"Creation of an anonymous data object using a type description object for a
"dictionary structure that is obtained using RTTI
"Declaring a data reference variable with a generic type
DATA dref TYPE REF TO data.
"Getting type description using RTTI
DATA(type) = CAST cl_abap_datadescr(
cl_abap_typedescr=>describe_by_name( 'ZDEMO_ABAP_CARR' ) ).
"Creating an anonymous data object using the retrieved type description
CREATE DATA dref TYPE HANDLE type.
"Creating an internal table dynamically
"Getting type description using RTTI
DATA(line_type) = CAST cl_abap_structdescr(
cl_abap_tabledescr=>describe_by_name( `ZDEMO_ABAP_CARR` ) ).
"Defining primary table keys of internal table type to be created
DATA(itab_keys) = VALUE abap_keydescr_tab( ( name = 'CARRID' )
( name = 'CARRNAME' ) ).
"Creating internal table type using the create method of cl_abap_tabledescr
DATA(table_type) = cl_abap_tabledescr=>create(
p_line_type = line_type
p_table_kind = cl_abap_tabledescr=>tablekind_sorted
p_unique = cl_abap_typedescr=>true
p_key = itab_keys ).
"Creating internal table based on the created table type
DATA ref_tab TYPE REF TO data.
CREATE DATA ref_tab TYPE HANDLE table_type.
GENERATE SUBROUTINE POOL, READ REPORT and INSERT REPORT in the ABAP Keyword Documentation for Standard ABAP: Dynamic Program Development (F1 docu for standard ABAP)Note the steps outlined here about how to import and run the code.
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
马建仓 AI 助手