Many of the resources we have on ABAP might be old, but they still frequently show up on top positions of search results. I encourage you to correct incorrect information you stumble upon, even many years later.

Here is my attempt to thoroughly solve a trivial problem I needed reminding about this week – retrieving the last character of a string.

My analysis will be presented in the form of a contest between the respondents to the same question asked on SAP Q&A in 2007, with some measurements at the end. Let’s see how the answers fare in 2020. There were seven proposed solutions, but first…

the results. Because the rest is mostly rambling. If you’re interested in that, feel free to read the whole thing. But if you just want code and numbers, this is just a two-minute read:

I made some measurements of the correct approaches from the answers:

• offset/length
• substring
• rotate using SHIFT, return first character

The run times were be measured on a short string (guid) and a long string (5000 concatenated guids)

report zlastchar.


class lcl_string_util definition create private.

  public section.

    " feel free to substitute your favorite single character abstraction
    types: t_last_character type c length 1.

    class-methods:
      get_using_substring
        importing str           type string
        returning value(result) type t_last_character.

    class-methods:
      get_using_off_len
        importing str           type string
        returning value(result) type t_last_character.

    class-methods get_using_shift
      importing value(str)    type string
      returning value(result) type t_last_character.

endclass.

class lcl_profiler definition create private.
  public section.

    class-data: guid type string.
    class-data: n type i.

    class-methods: 
      off_len,
      substring,
      shift.

endclass.

""""""""""""""""""""""""""""""""""""
" we will measure a random short string as well as a much longer string

lcl_profiler=>n = 10000.

lcl_profiler=>guid = cl_system_uuid=>create_uuid_c36_static( ).

data(really_long_string) = ``.
do 5000 times.
  really_long_string = really_long_string && cl_system_uuid=>create_uuid_c36_static( ).
enddo.


lcl_profiler=>off_len( ).
lcl_profiler=>substring( ).
lcl_profiler=>shift( ).

""""""""""""""""""""""""""""""""""""

class lcl_string_util implementation.

  method get_using_substring.
    result = substring( off = strlen( str ) - 1 len = 1 val = str ).
  endmethod.

  method get_using_off_len.
    data(index_before_last) = strlen( str ) - 1.
    result = str+index_before_last(1).
  endmethod.

  method get_using_shift.
    shift str right by 1 places circular.
    result = str(1).
  endmethod.

endclass.


class lcl_profiler implementation.

  method off_len.
    do n times.
      lcl_string_util=>get_using_off_len( guid ).
      lcl_string_util=>get_using_off_len( really_long_string ).
    enddo.
  endmethod.

  method substring.
    do n times.
      lcl_string_util=>get_using_substring( guid ).
      lcl_string_util=>get_using_substring( really_long_string ).
    enddo.
  endmethod.

  method shift.
    do n times.
      lcl_string_util=>get_using_shift( guid ).
      lcl_string_util=>get_using_shift( really_long_string ).
    enddo.
  endmethod.

endclass.

And the measurements (in microseconds):

Using offset/length or the substring function seems to be largely equivalent, very slightly favoring offset/length. Which makes it the winner!

But the shift approach really is taking over 30x as long. Still, you might say it doesn’t amount to much… it’s a few miliseconds for 10 000 iterations. Who cares?

Let’s try an even longer string by concatenating 50 000 guids. Now the shift method takes 10 seconds, while the first two approaches still only take about 11 miliseconds.

Perhaps if your application crumbles when faced with large volumes of data, you don’t have to do anything crazy to fix it. Maybe you’re just doing a basic thing incorrectly too many times.

Edit: if you’re a new abaper, make sure not to take the suggestions from the comments section too seriously.

• It’s true that the database can do a lot of heavy lifting for you, but code pushdown is not to be used for trivial things.
• Even though you can use sql directly in abap, make sure to encapsulate database access or your code will be difficult to test.
• This comment contains some more measurements of the regex-based solutions. I suggest you stick to the two fast ones above.

And now for the contest part

The problem specification

I need to get the last character of the string, like this…

‘AAAAAAAA BBBB 1 QQQQQQQQ 2’.

i need to take the last letter (2) to do more things b4.

I’m thinking to rotate the string and take the first letter, but i think will exist a FM that do my requirement.

The contenders

Amole

Hi,

Verdict

Amole’s solution was voted best answer and highlighted in green. I reluctantly copy-pasted the code into a report.

The code does not compile. After fixing a couple of syntax errors, I ran the report to see it print out test, which is not the last character of the word test.

When cleaned up, you can easily see that the code always prints out the original string:

report zfh.

data(str) = 'test'.

data(len) = strlen( str ).
write str(len).

" this is equal to
write str+0(len).

" which is equal to
write str.

The author of the question mentions in a comment that they “like a lot the amole solution”. I’m not sure how to feel about that.

Rich Heilman

Lots of ways to do this. another one would be to use the function module REVERSE_STRING, or STRING_REVERSE. It is something like that. Anyway, from the name, you can guess what it does, then all you need to do is look at the first letter of the string using an offset.

Verdict

The algorithm proposed by Rich is correct. As for the function module, it’s the second one:

FUNCTION STRING_REVERSE
  IMPORTING
    VALUE(STRING) TYPE ANY
    VALUE(LANG) TYPE ANY
  EXPORTING
    VALUE(RSTRING) TYPE ANY
  EXCEPTIONS
    TOO_SMALL.

I especially like the lang parameter here, really makes you wonder. So if you are too, this function module will count characters slightly differently in Thai. I choose to forget about this particular fact and hope that strlen does return the universally agreed-upon lengths of characters on unicode systems. I would actually like to know if I’m right about this. Feel free to let me know in the comments.

The solution gets minus points in 2020 where clean code is a thing for relying on untyped parameters and legacy exception handling. Using a static utility method would be a much better choice today.

Also, it doesn’t work if used with the data type string, only on fixed-length character types.

Given the simplicity of the problem we’re trying to solve, this is a gotcha I wouldn’t expect to encounter. The parameter claims it could be anything!

I’m sorry Rich, but I have to disqualify you. But since you still work in SAP 13 years later, it might be fun for you to reminisce on how much changed since then in the comments section.

Prabhu

Verdict

Due to the unfortunate mixing of explanations and code without actually using comments, Prahbu’s solution does not compile and also loses some points for readability. But I can understand what he means and the algorithm is correct.

Verdict

Plus point for correct algorithm. #1’s proposed solution would look something like this:

report zfh.

data: string type string value 'ABCD',
      len    type i,
      result   type string.

call function 'STRING_LENGTH'
  exporting
    string = string
  importing
    length = len.

call function 'STRING_SPLIT_AT_POSITION'
  exporting
    string  = string
    pos     = len - 1
  importing
    string2 = result.

Unfortunately,

these function modules also do not work with strings. I’ve already explained my concerns with this as well as usage of function modules.

Nazeer

‘AAAAAAAA BBBB 1 QQQQQQQQ 2’.

i need to take the last letter (2) to do more things b4.

He misinterprets the 2 given as the output to the author’s example input, and instead gives the solution on how to return the last 2 characters.

This underlines the importance of taking the time to ask good questions.

Nazeer gets plus points for solving his variant of the problem correctly. His code, once cleaned up, makes sense and even compiles! He also provided an alternative solution.

report zfh.

data: lv_string type char4 value 'ABCD',
      lv_new    type i,
      lv_new1   type char2.

*lv_new = strlen( lv_string ).

call function 'STRING_LENGTH'
  exporting
    string = lv_string
  importing
    length = lv_new.

lv_new = lv_new - 2.
lv_new1 = lv_string+lv_new(2).

write lv_new1.

Verdict

Would you mind if I just called you Ram? Ram’s algorithm is correct, but he does not specify exactly how to Find the string lenght-1 posotion of that string, which might be important. The ABAP +off(len) syntax might not be familiar to everyone and there might be different methods as well.

Former member #2

Verdict

#2 surprises us with exactly the same misunderstanding of the question Nazeer had. His code is missing the final line of code, which is instead explained, giving us a nice hybrid solution.

Additional entries

from a similar StackOverflow question from 2018:

Note how the code snippets are actually readable without having to copy-paste it somewhere else first. Both solutions produce correct results. Despite its author’s confidence, the second snippet is worse in performance, but it is downvoted and there is a recent comment from Sandra Rossi explaining why it’s slower. Thank you for doing that. Your efforts are not in vain.

And now that I have this out of my system, I can go back to delivering you the intelligent enterprise. Stay tuned.