Так сказать еще немного оптимизации в тему, а именно чуток заметок по работе со строками в новых версиях системы от 7.40 и старше.
В самом начале существования языка ABAP, в системе был доступен единственный способ соединения строк, это оператор CONCATENATE. Простой процесс формирования строки в цикле, предполагал выделение достаточного места для строки приемника, и далее уже выполнялось формирование результата.
ВремВып: 810 микросек
6.5.1) Базовая операция соединения строк
DATA: l_long_char(10000) TYPE c,
l_sy_index(10) TYPE c.
l_long_char = `Create long char, line = START`.
DO 100 TIMES.
l_sy_index = sy-index.
CONCATENATE l_long_char 'Create long char, line =' l_sy_index '.' INTO l_long_char.
ENDDO.
CONCATENATE l_long_char `Create long char, line = FINISH` INTO l_long_char.
Возможной оптимизацией в данном случае являлся только вариант прямой записи цепочки знаков в определенное место строки, без вызова операции соединения строк.
ВремВып: 605 микросек
6.5.2) Прямая запись цепочки знаков в позицию строки
DATA: l_long_char(10000) TYPE c,
l_sy_index(10) TYPE c,
l_add_char(100) TYPE c.
l_long_char = `Create long char, line = START`.
DO 100 TIMES.
l_sy_index = sy-index.
CONCATENATE 'Create long char, line =' l_sy_index '.' INTO l_add_char.
DATA(l_len) = strlen( l_long_char ).
l_long_char+l_len = l_add_char.
ENDDO.
CONCATENATE l_long_char `Create long char, line = FINISH` INTO l_long_char.
Как видим прирост производительности для варианта 6.5.2 составляет 25%. Что в принципе неплохо, особенно если у вас в программе выполняется постоянная работа со строками. Кстати, на производительность в данном случае влияет размер строк с которыми выполняются операции.
В данный момент, в системе существуют новые операции сложения строк, которые являются с одной стороны, более быстрыми, а с другой более гибкими. Это операция соединения строк использующая операнд && и операция обработки шаблонов строк | |. Если сформировать аналогичный пример обработки строк, используя примеры переменных из задач 6.5.1 и 6.5.2, то производительность получится, где-то посредине, между операцией CONCATENATE и прямой записью строки в заданную позицию. В среднем пример 6.5.3 давал результат от 660 до 690 микросек. При этом обработки шаблонов всегда была чуть медленнее, чем операция соединения &&.
ВремВып: 685 микросек
6.5.3) Обработка шаблонов строк
DATA: l_long_char(10000) TYPE c,
l_long_char = `Create long char, line = START`.
DO 100 TIMES.
l_long_char = |{ l_long_char }Create long char, line ={ sy-index }.|.
ENDDO.
l_long_char = l_long_char && 'Create long char, line = FINISH'.
ВремВып: 678 микросек
6.5.4) Соединение строк операцией &&
DATA: l_long_char(10000) TYPE c,
l_long_char = `Create long char, line = START`.
DO 100 TIMES.
l_long_char = l_long_char && 'Create long char, line =' && sy-index && '.'.
ENDDO.
l_long_char = l_long_char && 'Create long char, line = FINISH'.
Из приятного, код примеров 6.5.3 и 6.5.4, выглядит менее перегруженным, а так же отсутствуют лишние переменные, так как нет ограничений на использование только определенных типов, как для оператора CONCATENATE. Но самое приятное это появление типа STRING, с которым оператор CONCATENATE работает, по моему мнению, очень плохо, а вот новые операторы работы со строками работают просто великолепно и быстро. Для примера перепишем пример 6.5.3 и 6.5.4 используя тип STRING.
ВремВып: 57 микросек
6.5.5) Обработка шаблонов строк для типа STRING
DATA: l_long_string TYPE string.
l_long_string = `Create long string, line = START`.
DO 100 TIMES.
l_long_string = |{ l_long_string }Create long char, line ={ sy-index }.|.
ENDDO.
l_long_string = l_long_string && 'Create long char, line = FINISH'.
ВремВып: 50 микросек
6.5.6) Соединение строк операцией && для типа STRING
DATA: l_long_string TYPE string.
l_long_string = `Create long string, line = START`.
DO 100 TIMES.
l_long_string = l_long_string && 'Create long char, line =' && sy-index && '.'.
ENDDO.
l_long_string = l_long_string && 'Create long char, line = FINISH'.
Как видим, скорость обработки, отличается практически на порядок, т.е. более чем в 10 раз. Так же большим плюсом использования новых операторов является возможность, как указания различных типов переменных, так и вызова методов классов или выполнения каких-либо вычислений в процессе выполнения соединения данных. Например, выполнение вычисления значения переменной используя внутренние функции системы. В примере 6.5.7, используется возведение числа в степень.
ВремВып: 300 микросек
6.5.7) Соединение строк операцией && с динамическим вычислением значений
DATA: l_long_string TYPE string.
l_long_string = `Create long string, line = START`.
DO 100 TIMES.
l_long_string = l_long_string && 'Create long char, line =' &&
CONV string( ipow( base = sy-index exp = 2 ) ) &&
'.'.
ENDDO.
l_long_string = l_long_string && 'Create long char, line = FINISH'.
Однако, стоит вынести вычисления из операции соединения строк, как скорость выполения резко возрастает, что видно на примере 6.5.8. При этом аналогичное правило так же работает и в случае обработки соединения строк используя шаблоны, т.е. время обработки для примера 6.5.8 меньше времени выполнения для примера 6.5.7, в пять раз.
ВремВып: 57 микросек
6.5.
Соединение строк операцией && с вынесеним операций.
DATA: l_ipow type i,
l_long_string TYPE string.
l_long_string = `Create long string, line = START`.
DO 100 TIMES.
l_ipow = ipow( base = sy-index exp = 2 ).
l_long_string = l_long_string && 'Create long char, line =' && l_ipow && '.'.
ENDDO.
l_long_string = l_long_string && 'Create long char, line = FINISH'.
Выводы (скорость): Где это возможно, лучше использовать тип переменной строка (STRING). Скорость обработки операции со строками, в системе, выше, чем с скорость обработки цепочек символов. Далее, не смотря на то, что новые операции соединения строк позволяют использовать динамическое вычисление значений в ходе вызова соединения строки, использовать данную возможность следует осторожно, так как оптимизации вызова таких вычислений не спросиходит и это существенно сказывается на скорости выполнения кода, что хорошо видно в примерах 6.5.7 и 6.5.8.