"Définition de type local ABAP : l

Catégorie
ABAP-Statements
Publié
Auteur
Johannes

L’instruction TYPES est utilisée en ABAP pour définir des types de données locaux au sein d’un programme (report, classe, groupe de fonctions, interface, etc.). On peut les considérer comme des modèles ou plans pour les données.

Contrairement à l’instruction DATA, qui déclare une variable (c’est-à-dire un espace mémoire concret), TYPES définit uniquement la structure et les propriétés d’un type de données. Ce type auto-défini peut ensuite être utilisé plusieurs fois pour :

  1. Objets de données (variables avec DATA, constantes avec CONSTANTS) à déclarer.
  2. Symboles de champ (FIELD-SYMBOLS) à typer.
  3. Paramètres de procédures (méthodes, modules fonction, routines FORM) ou types génériques à définir.

Avantages de l’utilisation de TYPES :

  • Réutilisabilité : Les définitions de types complexes (structures, tables) ne doivent être définies qu’une seule fois et peuvent ensuite être utilisées plusieurs fois.
  • Lisibilité & Structuration : Le code devient plus clair et mieux structuré, en particulier pour les structures de données complexes.
  • Maintenabilité : Les modifications du type ne doivent être effectuées qu’à la définition centrale TYPES.
  • Sécurité de type : Permet un typage plus strict des variables et paramètres.

Distinction :

  • TYPES : Définit un type (plan), ne réserve pas de mémoire. La validité est généralement locale au programme/objet.
  • DATA : Définit une variable (objet de données), réserve de la mémoire basée sur un type.
  • ABAP Dictionary (SE11) : Définit des types globaux (éléments de données, structures, types de table), disponibles dans tout le système. TYPES peut référencer ces types globaux.

Syntaxe

Il existe différentes façons de définir des types avec TYPES :

1. Basé sur un type existant (Préféré)

TYPES <nom_type> TYPE <type_base> [LENGTH <longueur>] [DECIMALS <decimales>].
  • <nom_type> : Nom du nouveau type local.
  • <type_base> : Un type déjà existant (type ABAP élémentaire comme I, P, STRING, D, T ; un type Dictionary global comme matnr, bukrs ; un autre type local ; une classe/interface pour REF TO).

2. Basé sur un objet de données existant (Obsolète)

TYPES <nom_type> LIKE <objet_donnees>.
  • <objet_donnees> : Une variable, constante ou composant de structure déjà déclaré. Devrait être évité dans le nouveau code et remplacé par TYPE.

3. Définir un type de structure

TYPES: BEGIN OF <nom_type_structure>,
        <composant1> TYPE <type1> | LIKE <champ1>,
        <composant2> TYPE <type2> | LIKE <champ2>,
        " Optionnel : INCLUDE TYPE|STRUCTURE ...
        ...
      END OF <nom_type_structure>.

Définit un type composé de plusieurs composants.

4. Définir un type de table (pour tables internes)

TYPES <nom_type_table> TYPE [STANDARD | SORTED | HASHED] TABLE OF <type_ligne>
                      [WITH [UNIQUE | NON-UNIQUE] KEY <composants_cle> | DEFAULT KEY]
                      [INITIAL SIZE 0]. " Pour les types, INITIAL SIZE est souvent 0
  • <type_ligne> : Le type des lignes individuelles dans la table (peut être un type simple, type de structure, type de référence, etc.).
  • STANDARD, SORTED, HASHED : Définit le type de table.
  • WITH KEY : Définit la clé pour les tables SORTED et HASHED.

5. Définir un type de référence

TYPES <nom_type_ref> TYPE REF TO <type> | <classe> | <interface> | DATA.

Définit un type pour les variables de référence (pointeurs).

6. Définir un type de table de plages

TYPES <nom_type_range> TYPE RANGE OF <type_elementaire>.

Définit un type de table spécial (avec les champs SIGN, OPTION, LOW, HIGH), souvent utilisé pour SELECT-OPTIONS ou les clauses WHERE. Le type de LOW et HIGH est déterminé par <type_elementaire>.

7. Instruction en chaîne

Plusieurs définitions TYPES peuvent être combinées avec une instruction en chaîne (deux-points après TYPES, virgules entre les définitions, point à la fin).

Exemples

REPORT z_types_demo.


" --- Définition de différents types locaux ---
TYPES:
  " Types simples
  ty_id          TYPE i,
  ty_description TYPE string,
  ty_plant       TYPE werks_d, " Basé sur élément de données du Dictionary


  " Type de structure pour données utilisateur
  BEGIN OF ty_s_user,
    user_id   TYPE ty_id,         " Utilise le type local ty_id
    user_name TYPE xubname,       " Type Dictionary
    email     TYPE ad_smtpadr,    " Type Dictionary
    active    TYPE abap_bool VALUE abap_true, " Peut aussi avoir une valeur par défaut
  END OF ty_s_user,


  " Type de table pour utilisateurs
  ty_t_users TYPE STANDARD TABLE OF ty_s_user WITH EMPTY KEY, " Table standard


  " Type de table triée pour numéros d'articles
  ty_t_materials_sorted TYPE SORTED TABLE OF matnr WITH UNIQUE KEY table_line,


  " Type de référence sur une classe
  ty_ref_alv TYPE REF TO cl_salv_table,


  " Type range pour plage de dates
  ty_r_date TYPE RANGE OF d.




" --- Utilisation des types définis ---


" Déclarer des variables
DATA gv_user_counter  TYPE ty_id.
DATA gs_current_user  TYPE ty_s_user.
DATA gt_all_users     TYPE ty_t_users.
DATA gt_material_list TYPE ty_t_materials_sorted.
DATA go_alv           TYPE ty_ref_alv.
DATA gr_posting_date  TYPE ty_r_date. " Variable pour range de dates


" Paramètre d'une méthode locale (exemple)
CLASS lcl_processor DEFINITION.
  PUBLIC SECTION.
    METHODS process_users
      IMPORTING it_users TYPE ty_t_users " Utilise le type de table
      RETURNING VALUE(rv_success) TYPE abap_bool.
ENDCLASS.


" Typer un symbole de champ
FIELD-SYMBOLS <fs_user> TYPE ty_s_user.




" --- Logique (exemple) ---
START-OF-SELECTION.


  gv_user_counter = 0.
  gs_current_user-user_id = 1.
  gs_current_user-user_name = sy-uname.
  gs_current_user-email = '[email protected]'.
  APPEND gs_current_user TO gt_all_users.


  gv_user_counter = lines( gt_all_users ).
  WRITE: / 'Nombre d\'utilisateurs :', gv_user_counter.


  LOOP AT gt_all_users ASSIGNING <fs_user>.
    WRITE: / <fs_user>-user_name, <fs_user>-email.
  ENDLOOP.


  " Remplir le range (exemple)
  APPEND VALUE #( sign = 'I' option = 'BT' low = '20250101' high = sy-datum ) TO gr_posting_date.
  WRITE: / 'Range Low :', gr_posting_date[ 1 ]-low.

En résumé : L’instruction TYPES est un outil essentiel pour définir des types de données locaux réutilisables en ABAP. Elle contribue considérablement à la structuration, la lisibilité et la maintenabilité du code ABAP, en particulier lors du travail avec des structures de données complexes et pour assurer la sécurité de type dans les interfaces de procédures.