Fundament

Operatoren, control flow & moderne syntax

Vergelijkingen en logische expressies, IF/CASE/lussen, en de moderne 7.40+-syntax: inline-declaraties, VALUE, COND, SWITCH, REDUCE, FOR en table expressions.

Op deze pagina

01Operatoren & logische expressies
02Control flow
03Moderne syntax (ABAP 7.40+)

01Operatoren & logische expressies

Vergelijken, rekenen en combineren. ABAP kent zowel symbolen als (oudere) letterschrijfwijzen.

Symbool	Letters (oud)	Betekenis
`=`	`EQ`	gelijk aan
`<>`	`NE`	ongelijk aan
`<` / `>`	`LT` / `GT`	kleiner / groter dan
`<=` / `>=`	`LE` / `GE`	kleiner/groter of gelijk

Speciale predicaten

Expressie	Betekenis
`IS INITIAL` / `IS NOT INITIAL`	Heeft de initiële waarde van het type (0, leeg, 00000000…)
`IS BOUND`	Objectreferentie wijst naar een instance (niet null)
`IS ASSIGNED`	Field-symbol is gekoppeld
`IS SUPPLIED`	Optionele parameter is meegegeven (binnen functiemodule/methode)
`IN s_range`	Waarde valt binnen een range-tabel/select-option
`BETWEEN a AND b`	Waarde tussen a en b (inclusief)
`CO / CN / CA / NA / CS / NS / CP / NP`	Tekstvergelijkingen: contains only / pattern (`CP 'AB*'`) etc. — zie strings

Logisch combineren met AND, OR, NOT en haakjes. Booleaanse hulpfuncties: xsdbool( lv_a > 5 ) levert direct abap_true/false — handig in constructor expressions.

Rekenen

lv_totaal = lv_prijs * lv_aantal.
lv_rest   = lv_a MOD lv_b.          " modulo
lv_macht  = lv_a ** 2.               " machtsverheffen
lv_delta  = abs( lv_x ).            " ingebouwde functies: abs, ceil, floor,
lv_rond   = round( val = lv_bedrag dec = 2 ). " trunc, frac, round, nmin, nmax…
lv_teller = lv_teller + 1.           " er is geen ++; wel: lv_teller += 1. (≥7.54)

Deling — lv_i = 7 / 2. met integer-doel geeft 4 (commercieel afgerond), niet 3. Gebruik DIV voor gehele deling zonder afronding en een p-doelveld voor decimalen.

02Control flow

Vertakkingen en lussen. Elk blok wordt afgesloten met een END-statement.

IF / ELSEIF / ELSE

IF lv_status = 'A' AND lv_bedrag > 0.
  ...
ELSEIF lv_status = 'B'.
  ...
ELSE.
  ...
ENDIF.

CASE

CASE lv_status.
  WHEN 'A' OR 'B'.
    ...
  WHEN OTHERS.
    ...
ENDCASE.

CASE TYPE OF lo_object.          " op object-type, zie OO
  WHEN TYPE zcl_klant INTO DATA(lo_klant). ...
  WHEN OTHERS. ...
ENDCASE.

Lussen

DO 10 TIMES.            " sy-index = 1..10
ENDDO.

DO.                      " oneindig — zelf verlaten met EXIT
  IF lv_klaar = abap_true. EXIT. ENDIF.
ENDDO.

WHILE lv_teller < 100.
ENDWHILE.

Voor het itereren over interne tabellen: LOOP AT. Voor databaserijen: SELECT ... ENDSELECT (vermijden waar mogelijk).

Lus- en blokbesturing

Statement	Effect
`EXIT`	In een lus: verlaat de lus. Búiten een lus: verlaat de hele procedure — een beruchte bron van verwarring.
`CONTINUE`	Spring naar de volgende lus-iteratie.
`CHECK cond.`	Als de conditie ONWAAR is: in een lus → volgende iteratie; buiten een lus → verlaat de procedure. Lees het als "ga alleen door als…".
`RETURN`	Verlaat de huidige methode/procedure — de duidelijkste keuze in moderne code.

03Moderne syntax (ABAP 7.40+)

Sinds 7.40 is ABAP expressie-georiënteerd geworden: veel constructies die vroeger meerdere statements kostten, passen nu in één expressie. Dit domineert alle nieuwe code.

Inline-declaraties

DATA(lv_aantal) = lines( lt_orders ).       " type wordt afgeleid
SELECT * FROM mara INTO TABLE @DATA(lt_mara) UP TO 100 ROWS.
LOOP AT lt_orders ASSIGNING FIELD-SYMBOL(<ls_o>). ENDLOOP.
READ TABLE lt_orders INTO DATA(ls_eerste) INDEX 1.

VALUE — structuren en tabellen bouwen

ls_order = VALUE #( vbeln = '0000012345' erdat = sy-datum ).

lt_orders = VALUE #( ( vbeln = '1' netwr = 100 )
                    ( vbeln = '2' netwr = 250 ) ).

lt_orders = VALUE #( BASE lt_orders ( vbeln = '3' ) ). " toevoegen i.p.v. vervangen

De # betekent "leid het type af uit de context"; je mag er ook expliciet een typenaam neerzetten: VALUE ty_orders( ... ).

COND & SWITCH — voorwaardelijke expressies

lv_kleur = COND #( WHEN lv_netwr > 10000 THEN 'rood'
                   WHEN lv_netwr > 1000  THEN 'oranje'
                   ELSE 'groen' ).

lv_tekst = SWITCH #( lv_status
                     WHEN 'O' THEN 'Open'
                     WHEN 'C' THEN 'Gesloten'
                     ELSE 'Onbekend' ).

FOR & REDUCE — itereren in een expressie

" FOR: tabel afleiden uit een andere tabel (map/filter)
DATA(lt_nummers) = VALUE ty_vbelns(
  FOR ls IN lt_orders WHERE ( netwr > 0 )
  ( ls-vbeln ) ).

" REDUCE: aggregeren tot één waarde
DATA(lv_totaal) = REDUCE netwr_ak(
  INIT som = 0
  FOR ls IN lt_orders
  NEXT som = som + ls-netwr ).

CORRESPONDING, CONV, CAST, NEW, REF

Expressie	Doet
`CORRESPONDING #( ls_bron )`	Kopieert gelijknamige velden; met `MAPPING doel = bron` en `EXCEPT veld` stuur je het bij.
`CONV matnr( lv_string )`	Expliciete typeconversie in een expressie.
`CAST zcl_klant( lo_obj )`	Down-cast van objectreferenties — zie casting.
`NEW zcl_klant( iv_id = '1' )`	Instantie aanmaken (vervangt `CREATE OBJECT`).
`REF #( ls_data )`	Data-referentie naar bestaand object.
`EXACT #( ... )`	Conversie die dumpt bij verlies van informatie (afkapping/afronding).
`FILTER #( lt_tab WHERE ... )`	Filteren van sorted/hashed tabellen op key-velden.

String templates

lv_msg = |Order { ls_order-vbeln } van { ls_order-erdat DATE = USER }: | &&
         |{ ls_order-netwr NUMBER = USER } EUR|.

Alles tussen |...| is een template; { } evalueert een expressie, met formatteringsopties (DATE, NUMBER, ALPHA, WIDTH, PAD…). Meer in strings.

Leesbaarheid boven alles — constructor expressions kun je diep nesten, maar drie niveaus VALUE( FOR ... ( COND ... ) ) leest niemand meer. Clean ABAP adviseert: gebruik expressies waar ze de intentie verhelderen, niet om regels te besparen.