Sommaire

Architecture de base d’un programme ABAP
#

Squelette d’un programme ABAP
#

Objectifs
#

Comprendre la structure de base d’un PROGRAMME ABAP
Identifier les blocs d’événements standards (INITIALIZATION, START-OF-SELECTION, PERFORM, END-OF-SELECTION)
Savoir à quel moment chaque section du programme est exécutée
Etre capable d’écrire un squelette complet de PROGRAMME ABAP

Pré-requis
#

Créer un nouveau programme ZAELION_TRI_UNIT02_01 à stocker dans ton PACKAGE et OT
Créer les 3 INCLUDES (TOP > SCR > F01)
Sauvegarger, Activer les objets et basculer en Modification.

Définition
#

Un PROGRAMME ABAP est composé de BLOCS D'EVENEMENTS déterminant l’ordre et le contexte d’exécution du code.
Ces blocs structurent le flux d’exécution et rendent le code prédictable et maintainable.

Le programme est une piece de theatre REPORT = titre

chaque bloc (INITIALIZATION, START-OF-SELECTION, …) = acte

chaque PERFORM = séquence

les instructions des PERFORM = repliques.

Construction du squelette
#

Bloc de programme : REPORT
#

Dans le REPORT, ajouter l’instruction suivante entre l’instruction REPORT et les INCLUDES

        WRITE:/ '01 - REPORT...',
              / '     WARNING: Ne jamais implémenter de code ici !',
              / '-------------------------------------------------'.

Sauvegarder, Activer et Excécuter

        *&---------------------------------------------------------------------*
        *& Report ZAELION_FGI_UNIT02_01
        *&---------------------------------------------------------------------*
        *&
        *&---------------------------------------------------------------------*
        REPORT zaelion_fgi_unit02_01.

        WRITE:/ '01 - REPORT...',
              / '     WARNING: Ne jamais implémenter de code ici !',
              / '-------------------------------------------------'.

        INCLUDE zaelion_fgi_unit02_01_top.
        INCLUDE zaelion_fgi_unit02_01_scr.
        INCLUDE zaelion_fgi_unit02_01_f01.

INCLUDES
#

Dans chaque INCLUDE, ajouter respectivement les instructions suivantes

INCLUDE _TOP

      WRITE:/ '02 - INCLUDE _TOP...',
            / '     INFO: Spécifique aux déclarations globales',
            / '-------------------------------------------------'.

INCLUDE _SCR

      WRITE:/ '03 - INCLUDE _SCR...',
            / '     INFO: Spécifique aux écrans de sélections',
            / '-------------------------------------------------'.

INCLUDE _F01

      WRITE:/ '04 - INCLUDE _F01...',
            / '     INFO: Spécifique aux traitements du REPORT',
            / '-------------------------------------------------'.

Sauvegarder, Activer les objets et Exécuter

Bloc d’événement : INITIALIZATION
#

Le bloc INITIALIZATION en ABAP est une section du REPORT exécutée avant l’affichage du premier écran de sélection (c’est-à-dire avant que l’utilisateur voie les paramètres et sélections du programme).

Il sert à pré-remplir des valeurs par défaut dans les champs du selection screen ou à initialiser des variables globales nécessaires avant toute interaction utilisateur. Ce bloc s’exécute une seule fois, automatiquement, sans appel explicite du programmeur.

Imagine que tu ouvres un formulaire papier déjà partiellement rempli avec ton nom et la date. Tu n’as encore rien fait, mais quelqu’un a préparé le document pour toi. Le bloc INITIALIZATION joue ce rôle de “préparateur” dans un programme ABAP : il met en place les valeurs de départ avant que l’utilisateur voie le formulaire (l’écran de sélection).

Dans le REPORT, ajouter l’instruction suivante entre l’instruction en dessous du dernier INCLUDE

        INITIALIZATION.
          WRITE:/ '00 - INITIALIZATION du programme...',
                / '     TYPE: Bloc d''événement',
                / '     WARNING: Activation unique au lancement',
                / '-------------------------------------------------'.

Sauvegarder, Activer et Excécuter

        *&---------------------------------------------------------------------*
        *& Report ZAELION_FGI_UNIT02_01
        *&---------------------------------------------------------------------*
        *&
        *&---------------------------------------------------------------------*
        REPORT zaelion_fgi_unit02_01.

        WRITE:/ '01 - REPORT...',
              / '     WARNING: Ne jamais implémenter de code ici !',
              / '-------------------------------------------------'.

        INCLUDE zaelion_fgi_unit02_01_top.
        INCLUDE zaelion_fgi_unit02_01_scr.
        INCLUDE zaelion_fgi_unit02_01_f01.

        INITIALIZATION.
          WRITE:/ '00 - INITIALIZATION du programme...',
                / '     TYPE: Bloc d''événement',
                / '     WARNING: Activation unique au lancement',
                / '-------------------------------------------------'.

Blocs d’événement : START-OF-SELECTION END-OF-SELECTION
#

Le bloc START-OF-SELECTION est le point d’entrée principal du traitement logique d’un programme ABAP de type rapport.

C’est à ce moment que le code principal s’exécute, après la validation de l’écran de sélection (quand l’utilisateur a saisi ses valeurs et lancé le programme). Tout le calcul, la lecture de données, et la logique métier se placent généralement ici.

Le bloc END-OF-SELECTION s’exécute après la fin du traitement du bloc START-OF-SELECTION. Il est souvent utilisé pour le traitement final, comme l’affichage des résultats (WRITE, ALV, etc.), ou des actions nécessitant que toutes les données soient déjà prêtes.

Dans le REPORT, ajouter l’instruction suivante entre l’instruction en dessous du bloc d’événement INITIALIZATION

        START-OF-SELECTION.
          WRITE:/ '05 - START-OF-SELECTION du programme...',
                / '     TYPE: Bloc d''événement',
                / '     INFO: Traitement principal du REPORT',
                / '-------------------------------------------------'.

        END-OF-SELECTION.
          WRITE:/ '99 - END-OF-SELECTION du programme...',
                / '     TYPE: Bloc d''événement',
                / '     INFO: Traitement de fin du REPORT',
                / '-------------------------------------------------'.

Sauvegarder, Activer et Excécuter

        *&---------------------------------------------------------------------*
        *& Report ZAELION_FGI_UNIT02_01
        *&---------------------------------------------------------------------*
        *&
        *&---------------------------------------------------------------------*
        REPORT zaelion_fgi_unit02_01.

        WRITE:/ '01 - REPORT...',
              / '     WARNING: Ne jamais implémenter de code ici !',
              / '-------------------------------------------------'.

        INCLUDE zaelion_fgi_unit02_01_top.
        INCLUDE zaelion_fgi_unit02_01_scr.
        INCLUDE zaelion_fgi_unit02_01_f01.

        INITIALIZATION.
          WRITE:/ '00 - INITIALIZATION du programme...',
                / '     TYPE: Bloc d''événement',
                / '     WARNING: Activation unique au lancement',
                / '-------------------------------------------------'.

        START-OF-SELECTION.
          WRITE:/ '05 - START-OF-SELECTION du programme...',
                / '     TYPE: Bloc d''événement',
                / '     INFO: Traitement principal du REPORT',
                / '-------------------------------------------------'.

        END-OF-SELECTION.
          WRITE:/ '99 - END-OF-SELECTION du programme...',
                / '     TYPE: Bloc d''événement',
                / '     INFO: Traitement de fin du REPORT',
                / '-------------------------------------------------'.

Bloc de sous-traitement : PERFORM
#

L’instruction PERFORM en ABAP sert à appeler une “sous-routine” (un bloc de code séparé) définie avec FORM … ENDFORM.

Elle permet de structurer le programme en plusieurs parties logiques, chacune remplissant une tâche précise.

L’intérêt : stocker une logique précise de l’ensemble du programme.

Dans une recette, le PERFORM équivaudrait à une étape simple de l’ensemble telle que “Laver les légumes”. Bien que l’étape soit “simple”, elle nécessite une suite logique d’étape prévue qu’à cet effet.

Une sous-routine ne s’exécute que lorsqu’elle est appelée par un PERFORM (d’où le fait de l’implémenter au bon endroit dans le REPORT).

Les données peuvent être passées entre le programme principal REPORT et la sous-routine PERFORM par des variables globales ou par des paramètres (USING, CHANGING) mais tu verras cela dans le cadre de leur module spécifique.

Dans le REPORT, ajouter l’instruction suivante dans le bloc INITIALIZATION

        PERFORM report_initialization.

Double-cliquer sur le nom du PERFORM → popup de création → valider → sauvegarder si demander → sélectionner l’INCLUDE F01 précédemment créé → valider
Implémenter le WRITE suivant dans le FORM nouvellement créé

        WRITE:/ '     A - PERFORM report_initialization...',
              / '         INFO: Sous-process de l''initialisation',
              / '-------------------------------------------------'.

Sauvegarder, Activer les objets et Excécuter

        *&---------------------------------------------------------------------*
        *& Form report_initialization
        *&---------------------------------------------------------------------*
        *& text
        *&---------------------------------------------------------------------*
        *& -->  p1        text
        *& <--  p2        text
        *&---------------------------------------------------------------------*
        FORM report_initialization .

          WRITE:/ '     A - PERFORM report_initialization...',
                / '         INFO: Sous-process de l''initialisation',
                / '-------------------------------------------------'.

        ENDFORM.

Même chose pour le bloc d’événement START-OF-SELECTION avec les PERFORM report_subprocess_01. et PERFORM report_subprocess_02.

a. PERFORM report_subprocess_01.

        *&---------------------------------------------------------------------*
        *& Report ZAELION_FGI_UNIT02_01
        *&---------------------------------------------------------------------*
        *&
        *&---------------------------------------------------------------------*
        REPORT zaelion_fgi_unit02_01.

        WRITE:/ '01 - REPORT...',
              / '     WARNING: Ne jamais implémenter de code ici !',
              / '-------------------------------------------------'.

        INCLUDE zaelion_fgi_unit02_01_top.
        INCLUDE zaelion_fgi_unit02_01_scr.
        INCLUDE zaelion_fgi_unit02_01_f01.

        INITIALIZATION.
          WRITE:/ '00 - INITIALIZATION du programme...',
                / '     TYPE: Bloc d''événement',
                / '     WARNING: Activation unique au lancement',
                / '-------------------------------------------------'.

          PERFORM report_initialization.

        START-OF-SELECTION.
          WRITE:/ '05 - START-OF-SELECTION du programme...',
                / '     TYPE: Bloc d''événement',
                / '     INFO: Traitement principal du REPORT',
                / '-------------------------------------------------'.

          PERFORM report_subprocess_01.

Ajouter ceci dans le PERFORM nouvellement créé

        WRITE:/ '     A - PERFORM report_subprocess_01...',
              / '         INFO: Sous-process 01 du REPORT',
              / '-------------------------------------------------'.

Sauvegarder, Activer les objets et Exécuter.

b. PERFORM report_subprocess_02.

        *&---------------------------------------------------------------------*
        *& Report ZAELION_FGI_UNIT02_01
        *&---------------------------------------------------------------------*
        *&
        *&---------------------------------------------------------------------*
        REPORT zaelion_fgi_unit02_01.

        WRITE:/ '01 - REPORT...',
              / '     WARNING: Ne jamais implémenter de code ici !',
              / '-------------------------------------------------'.

        INCLUDE zaelion_fgi_unit02_01_top.
        INCLUDE zaelion_fgi_unit02_01_scr.
        INCLUDE zaelion_fgi_unit02_01_f01.

        INITIALIZATION.
          WRITE:/ '00 - INITIALIZATION du programme...',
                / '     TYPE: Bloc d''événement',
                / '     WARNING: Activation unique au lancement',
                / '-------------------------------------------------'.

          PERFORM report_initialization.

        START-OF-SELECTION.
          WRITE:/ '05 - START-OF-SELECTION du programme...',
                / '     TYPE: Bloc d''événement',
                / '     INFO: Traitement principal du REPORT',
                / '-------------------------------------------------'.

          PERFORM report_subprocess_01.
          PERFORM report_subprocess_02.

    Ajouter ceci dans le `PERFORM` nouvellement créé

        WRITE:/ '     B - PERFORM report_subprocess_02...',
              / '         INFO: Sous-process 02 du REPORT',
              / '-------------------------------------------------'.

Sauvegarder, activer les objets et exécuter.

Explication des blocs
#

BLOC	MOMENT D’EXECUTION	USAGE PRINCIPAL
`REPORT`	Début du programme	Définit le nom et le type du programme
`INCLUDES`	Inclut des segments de code	Modularisation : top, écrans, logique
`INITIALIZATION`	Avant tout affichage	Initialisations et valeurs par défaut
`START-OF-SELECTION`	Après validation du selection-screen	Traitement principal
`PERFORM`	Sous-traitement à ranger dans l’INCLUDE F01	Sous-traitement
`END-OF-SELECTION`	A la fin du traitement	Affichages finaux et récap

Si aucun bloc n’est declare, le code est execute implicitement dans START-OF-SELECTION.

Bonnes pratiques
#

Bonne pratique	Explication
Toujours séparer les blocs par des commentaires `*`	Facilite la lecture et la maintenance
Utiliser des INCLUDES pour modulariser	Evite la duplication et clarifie le role du code
Commenter chaque section	Guide la relecture et la formation
Respecter l’ordre d’execution SAP	Evite des comportements inattendus
Ne pas placer de code avant `REPORT`	SAP rejettera ou ignorera du code mal placé

Resume
#

Un PROGRAMME ABAP est organise en blocs d’evenements pour controler l’ordre d’execution.

Inclure des INCLUDES (TOP, SCR, F01) facilite la modularite et la maintenance.

Respecter la structure (REPORT -> INCLUDES -> INITIALIZATION -> START-OF-SELECTION -> PERFORM -> END-OF-SELECTION -> PERFORM) garantit lisibilite et predictibilite.

Commentaires dans le code ABAP
#

Objectifs
#

Comprendre le rôle des COMMENTAIRES dans le code ABAP
Identifier les différents types de COMMENTAIRES
Savoir appliquer les conventions de bonne pratique

Raccourcis clavier
#

[ CTRL ] + [ ? ] commente automatiquement la ligne sélectionnée
[ CTRL ] + [ ; ] décommente automatiquement la ligne sélectionnée

Definition
#

Un COMMENTAIRE en ABAP est une ligne ou un bloc de texte ignoré par le système d’exécution.
Son seul rôle est d’expliquer le code pour les humains.
Un bon COMMENTAIRE [!TIP] à comprendre pourquoi un code existe, pas seulement ce qu’il fait.

Un COMMENTAIRE, c’est une [!NOTE] dans la marge d’un plan d’ingénieur.
Le plan construit la machine (le code), la [!NOTE] explique la raison de chaque pièce.

Explication
#

Les COMMENTAIRES sont essentiels pour :

faciliter la lecture du code par un autre développeur,
[!TIP]r à la maintenance dans le temps,
documenter les choix techniques,
rendre visible la structure logique d’un programme.

En entreprise, le code ABAP est rarement lu par son auteur après quelques semaines.
Les ``COMMENTAIRES` garantissent la continuité de compréhension collective.

Types de commentaires
#

Commentaire sur ligne unique
#

Utiliser le symbole * en première colonne (en début de ligne).
Tout ce qui suit sur la ligne est ignoré par le système.

    * Déclaration d’une variable
    DATA: lv_age TYPE i.

Le * doit être placé dans la première colonne (en début de ligne), sinon SAP peut interpréter la ligne comme du code.

Commentaire de fin de ligne
#

Utiliser le symbole " (guillemet double) pour commenter après une instruction.

    DATA: lv_variable TYPE string.          "Variable pour stocker le prénom
    CONSTANTS: lc_age TYPE i VALUE 30.      "Âge fixe pour test

Les COMMENTAIRES de fin de ligne expliquent le rôle exact d’une variable ou d’une instruction sans casser la lecture du code.

Commentaire multiligne structuré
#

Utiliser *& pour construire des blocs visuels de COMMENTAIRE.
Cette méthode est utilisée pour les cartouches, les sections ou les explications longues.

    *&---------------------------------------------------------------------*
    *& Déclaration des constantes globales
    *&---------------------------------------------------------------------*

    CONSTANTS: lc_limit TYPE i VALUE 100.

Penser à une pancarte sur un chantier : le bloc *&---* signale une zone importante du code.

Longueur maximale
#

SAP limite techniquement la lecture à 72–76 caractères par ligne.
Les COMMENTAIRES trop longs peuvent être tronqués.

Un texte coupé peut rendre le COMMENTAIRE incohérent.
Mieux vaut plusieurs lignes brèves et alignées qu’une phrase trop longue.

Bonnes pratiques
#

Bonne pratique	Explication
Commencer les `COMMENTAIRES` par une majuscule	Améliore la lisibilité
Limiter à une seule idée par ligne	Évite les surcharges visuelles
Mettre à jour les `COMMENTAIRES` après toute modification	Empêche les incohérences code/documentation
Aligner les `COMMENTAIRES` dans les blocs	Améliore la structure visuelle du code
Ne pas sur-commenter le code évident	Favorise la clarté : commenter l’intention, pas la syntaxe

Trop de COMMENTAIRES “inutiles” peuvent polluer la lecture du code.
Un bon COMMENTAIRE répond à la question : Pourquoi ce code existe-t-il ?

Exemple
#

```abap
* Déclaration d'une variable pour stocker le prénom
DATA: lv_firstname TYPE string VALUE 'Alice'.     "Variable prénom

* Afficher le message à l’écran
WRITE: / 'Bonjour', lv_firstname, '!'.            "Affiche Bonjour Alice
```

Resume
#

Les COMMENTAIRES documentent le code sans être exécutés.

Utiliser * pour une ligne entière, " pour la fin de ligne, *& pour un bloc.

Respecter la limite de longueur et mettre à jour les COMMENTAIRES lors de chaque évolution.

La cartouche standard doit être présente dans tout programme.

Le bon COMMENTAIRE explique l’intention, pas la syntaxe.

Cartouche (entete de programme ABAP)
#

Objectifs
#

Comprendre le rôle de la CARTOUCHE dans un programme ABAP
Identifier les informations essentielles qu’elle contient
Savoir structurer et rédiger une CARTOUCHE correctement

Definition
#

Une CARTOUCHE est un bloc de texte placé au tout début d’un REPORT ABAP, d’une METHOD de CLASS, d’un MODULE FUNCTION etc.
Elle décrit le contexte : son nom, son auteur, sa fonction, et son historique.

La CARTOUCHE, c’est la carte d’identité du programme.
Elle indique qui l’a créé, quand, pour quoi faire, et où en est la version.

Elle [!TIP] les développeurs, les administrateurs et les équipes de maintenance à comprendre rapidement l’origine et le but du programme.

Pourquoi utiliser une cartouche ?
#

Sans CARTOUCHE, il devient difficile de savoir à quoi sert un programme ou qui l’a développé.
Dans un environnement où plusieurs personnes travaillent sur le même système, la CARTOUCHE est un repère indispensable.

Elle permet de :

Identifier le propriétaire du code.
Comprendre le rôle du programme sans lire tout le code.
Suivre les modifications au fil du temps (historique).
Garantir une traçabilité entre le besoin, le ticket et le développement.

Une CARTOUCHE bien remplie évite de perdre du temps en analyse technique inutile.

Structure standard d’une cartouche
#

Élément	Description
Nom du programme	Identifiant technique du programme ABAP (ex : `ZFGI_HELLO_WORLD`)
Type de programme	Catégorie : `REPORT`, `INCLUDE`, `FUNCTION MODULE`, etc.
Auteur	Nom ou trigramme du développeur
Date de création/modification	Historique des changements
Description	Résumé du rôle du programme
Version / Ticket	Lien avec le suivi du projet ou du correctif
Organisation / Département	Service responsable du développement

SAP GUI ne valide pas automatiquement le contenu de la CARTOUCHE.
C’est à toi (ou à ton équipe) de respecter la convention commune.

Exemple type de cartouche standard
#

    *&---------------------------------------------------------------------*
    *& NOM DU PROGRAMME                                                    *
    *& ------------------------------------------------------------------- *
    *& Objet  : Nom de l'objet                                             *
    *& Ticket : Numéro du ticket                                           *
    *& Titre  : Intitulé du ticket                                         *
    *& ------------------------------------------------------------------- *
    *& Commentaire :                                                       *
    *& Description courte du programme                                     *
    *& ------------------------------------------------------------------- *
    *& Historique des modifications                                        *
    *& Date      | Nom (Trigramme)   | Ticket - Objet                      *
    *& 00.00.2025| P.NOM (PNO)       | Création du programme               *
    *&---------------------------------------------------------------------*

Imagine une fiche projet collée sur ton code : chaque développeur peut voir d’un coup d’œil ce qu’il fait, pourquoi, et par qui.

Exemple complet dans un programme
#

    *&---------------------------------------------------------------------*
    *& Report  ZAELION_FGI_UNIT02_01
    *&---------------------------------------------------------------------*
    *&
    *&---------------------------------------------------------------------*

    *&---------------------------------------------------------------------*
    *& ZAELION_FGI_UNIT02_01                                               *
    *& ------------------------------------------------------------------- *
    *& Objet  : Démonstration - Structure programme                        *
    *& Ticket : DEV-0001                                                   *
    *& Titre  : Premier programme ABAP                                     *
    *& ------------------------------------------------------------------- *
    *& Commentaire : Programme d'exemple pour introduction ABAP            *
    *& ------------------------------------------------------------------- *
    *& Historique des modifications                                        *
    *& Date      | Nom (Trigramme)   | Ticket - Objet                      *
    *& 01.01.2025| F.GIUSTINI (FGI)  | Création du programme               *
    *&---------------------------------------------------------------------*

    REPORT zaelion_fgi_unit02_01.

    WRITE:/ '01 - REPORT...',
        / '     WARNING: Ne jamais implémenter de code ici !',
        / '-------------------------------------------------'.

    INCLUDE zaelion_fgi_unit02_01_top.
    INCLUDE zaelion_fgi_unit02_01_scr.
    INCLUDE zaelion_fgi_unit02_01_f01.

    INITIALIZATION.
    WRITE:/ '00 - INITIALIZATION du programme...',
            / '     TYPE: Bloc d''événement',
            / '     WARNING: Activation unique au lancement',
            / '-------------------------------------------------'.

    PERFORM report_initialization.

    START-OF-SELECTION.
    WRITE:/ '05 - START-OF-SELECTION du programme...',
            / '     TYPE: Bloc d''événement',
            / '     INFO: Traitement principal du REPORT',
            / '-------------------------------------------------'.

    PERFORM report_subprocess_01.
    PERFORM report_subprocess_02.

    END-OF-SELECTION.
    WRITE:/ '99 - END-OF-SELECTION du programme...',
            / '     TYPE: Bloc d''événement',
            / '     INFO: Traitement de fin du REPORT',
            / '-------------------------------------------------'.

Le bloc supérieur (CARTOUCHE) présente le programme.

Les blocs suivants (SELECTION-SCREEN, START-OF-SELECTION, etc.) structurent le code.

Chaque section est visuellement délimitée pour une lecture fluide et rapide.

Bonnes pratiques
#

Bonne pratique	Explication
Renseigner chaque champ de la `CARTOUCHE`	Garantit clarté et traçabilité
Utiliser les séparateurs `*&`	Uniformise la présentation dans toute l’équipe
Mettre à jour l’historique à chaque changement	Suivi fiable de l’évolution du code
Ajouter date et trigramme du développeur	Identification claire des contributeurs
Adopter une structure commune	Facilite la relecture et les audits techniques
Garder un ton clair et concis	Lecture rapide, sans surcharge d’information

Un champ vide dans une cartouche peut compliquer la recherche d’un incident ou la gestion d’un correctif.

[!TIP] Mémoire visuel
#

Une cartouche, c’est :

En haut du programme
Délimitée par *&---*
Toujours à jour
Identifiable par tous
Unique à chaque programme

Lors de la création d’un nouveau programme dans SE38 ou SE80, copie toujours une cartouche type fournie par ton équipe avant de commencer ton code.

Resume
#

La CARTOUCHE est l’en-tête descriptive de chaque programme ABAP.

Elle sert à identifier rapidement le quoi, qui, quand, et pourquoi du code.

Toujours placée au début du programme, elle garantit la traçabilité et la cohérence.

Elle doit être complète, à jour, et homogène dans tout le système SAP.

Un programme sans cartouche est comme un document sans titre : difficile à comprendre et à maintenir.