从最嵌套的循环继续最外层循环

Question

有没有办法从ABAP中最嵌套的循环中继续最外层循环？

Java中的示例.这种语言中有一个使用标签的构造(大多数人还不知道它),它允许我从嵌套的循环中继续最外层的循环.

public class NestedLoopContinue {
    public static void main(String[] args) {    
        label1: for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 2; j++) {
                if (i == 3) {
                    continue label1;
                }
            }
            System.out.println(i + 1);
        }
    }
}

这输出

1
2
3
5

现在,我怎么能以聪明的方式在ABAP中做到这一点？一种解决方案是使用TRY. ENDTRY.块,但它更像是一个黑客攻击.还有其他想法吗？

DATA: l_outer_counter TYPE i.
DO 5 TIMES.
  l_outer_counter = sy-index.
  TRY.
    DO 2 TIMES.
      IF l_outer_counter = 4.
        RAISE EXCEPTION TYPE cx_abap_random.
      ENDIF.
    ENDDO.
    WRITE / l_outer_counter.
    CATCH cx_abap_random.
      CONTINUE.
  ENDTRY.
ENDDO.

或者也许有一种方法来判断是否DO. ENDO.以EXIT语句结束(当然没有引入自己的变量,如SYST全局变量)？

DATA: l_outer_counter TYPE i.
DO 5 TIMES.
  l_outer_counter = sy-index.
  DO 2 TIMES.
    IF l_outer_counter = 4.
      EXIT.
    ENDIF.
  ENDDO.
  IF sy-last_loop_ended_with_exit = abap_true. "???
    CONTINUE.
  ENDIF.
  WRITE / l_outer_counter.
ENDDO.

Answer 1

我不知道特定于ABAP的解决方案,但我之前使用过通用编程解决方案来解决这个问题.只需使用布尔值并检查内循环的末尾是否继续.

在Java中:

public class NestedLoopContinue
{
    public static void main(String[] args)
    {
        for (int i = 0; i < 5; i++)
        {
            boolean earlyBreak = false;
            for (int j = 0; j < 2; j++)
            {
                if (i == 3)
                {
                    earlyBreak = true;
                    break;
                }
            }
            if (earlyBreak)
            {
               continue;
            }
            System.out.println(i + 1);
        }
    }
}

在ABAP:

DATA: l_outer_counter type i,
      early_break type FLAG.

DO 5 TIMES.
  l_outer_counter = sy-index.

  DO 2 TIMES.
      IF l_outer_counter = 4.
       early_break = ABAP_TRUE.
       EXIT.
      ENDIF.
  ENDDO.

  IF early_break = ABAP_TRUE.
      CLEAR early_break.
      CONTINUE.
  ENDIF.

  WRITE / l_outer_counter.

ENDDO.

我已经读过,首先在Java中存在基于标签的中断的原因是因为GOTO语句明确没有,并且基于标签的中断所涵盖的案例GOTO是团队想要维护的少数"好"用途之一.

但总的来说,这是一个非常尴尬的结构.有没有可能的方法来重构你的代码(可能交换循环的内部),以便首先消除对此的需求？