Introduction
Application des techniques et concepts de base
Utilisation des classes locales
Lecture des données de la base de données
Utilisation d'objets de données structurés
Utilisation de tables internes complexes
Implémentation de mises à jour de base de données à l'aide d'objets de gestion
Description du modèle de programmation d'applications ABAP RESTful

Utilisation de tables internes simples

Objectives

After completing this lesson, you will be able to:
  • Définissez des tables internes simples.
  • Traitez les données à l'aide de tables internes simples.

Définition de tables internes simples

Tables internes

Les tables internes sont des objets de données variables dans lesquels vous pouvez stocker plusieurs valeurs de type identique. Ce type doit être spécifié dans la déclaration et est appelé type de ligne de la table interne.

Chaque valeur occupe une ligne de la table interne. Le nombre de lignes n'est pas limité. Théoriquement, vous pouvez enregistrer autant de valeurs que vous le souhaitez dans une table interne. Les limitations proviennent uniquement de limites techniques telles que la mémoire disponible ou la configuration système.

La valeur initiale d'une table interne est une table vide ou, en d'autres termes, une table avec 0 ligne. Il existe différentes techniques pour renseigner une table interne. L'exemple utilise l'instruction APPEND pour ajouter une nouvelle ligne à la fin de la table interne et la renseigner avec une valeur.

Types de table

Le type d'une table interne est appelé type de table.

Dans l'exemple précédent, nous avons utilisé TYPE TABLE OF directement dans l'instruction DATA. Le type de table a été lié à la variable déclarée.

Vous pouvez également utiliser TYPE TABLE OF dans une instruction TYPES pour définir un type de table avec un nom. Vous pouvez ensuite utiliser ce type de table, par exemple, dans une instruction DATA. La visibilité de ces types dépend de la position de l'instruction TYPES.

Il existe également des types de tables dans le Dictionnaire ABAP. Ces types de tables sont gérés à l'aide d'un éditeur dédié. Ils sont appelés types de tables globaux car ils sont visibles n'importe où dans le système.

Traitement des données avec des tables internes simples

Regardez cette vidéo pour savoir comment renseigner une table interne avec l'instruction APPEND.

La valeur initiale d'une table interne est une table vide, c'est-à-dire une table interne avec des lignes nulles.

Vous avez déjà appris qu'avec l'instruction CLEAR, vous pouvez réinitialiser une variable ABAP à sa valeur initiale spécifique au type.

Lorsque vous utilisez CLEAR pour une table interne, vous supprimez tout son contenu et définissez le nombre de lignes sur zéro.

Il existe différentes façons d'extraire des données d'une table interne. Cet exemple extrait le contenu d'une seule ligne à l'aide d'une expression de table interne. Dans l'expression de table, le nom de la table interne est immédiatement suivi d'une paire de crochets. Une expression entière entre parenthèses indique la position de la ligne à lire.

Remarque :

Une syntaxe correcte requiert au moins un espace après la parenthèse ouvrante et avant la parenthèse fermante.

Lecture d'une table interne dans une boucle

La vidéo suivante illustre la manière dont vous pouvez lire à partir d'une table interne dans une boucle.

Lorsque vous implémentez une boucle sur une table interne, vous pouvez utiliser une déclaration en ligne après l'ajout INTO au lieu de déclarer explicitement l'espace de travail avec une instruction DATA.

Ce faisant, vous réduisez non seulement la quantité de code que vous devez saisir, mais vous vous assurez également que le type d'espace de travail correspond au type de ligne de la table interne, car le type de l'objet de données déclaré en ligne est dérivé du contexte, qui, dans ce cas, est la table interne.

Essayer : tables internes simples

  1. Comme dans le premier exercice de ce cours, créez une nouvelle classe globale qui implémente l'interface IF_OO_ADT_CLASSRUN.
  2. Copiez l'extrait de code suivant dans la partie implémentation de la méthode if_oo_adt_classrun~main( ) :
    Code Snippet
    12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879
    * Declarations ********************************************************************** " Internal tables DATA numbers TYPE TABLE OF i. "Table type (local) TYPES tt_strings TYPE TABLE OF string. DATA texts1 TYPE tt_strings. " Table type (global) DATA texts2 TYPE string_table. " work areas DATA number TYPE i VALUE 1234. DATA text TYPE string. * Example 1: APPEND ********************************************************************** APPEND 4711 TO numbers. APPEND number TO numbers. APPEND 2 * number TO numbers. out->write( `-----------------` ). out->write( `Example 1: APPEND` ). out->write( `-----------------` ). out->write( numbers ). * Example 2: CLEAR ********************************************************************** CLEAR numbers. out->write( `----------------` ). out->write( `Example 2: CLEAR` ). out->write( `----------------` ). out->write( numbers ). * Example 3: table expression ********************************************************************** APPEND 4711 TO numbers. APPEND number TO numbers. APPEND 2 * number TO numbers. out->write( `---------------------------` ). out->write( `Example 3: Table Expression` ). out->write( `---------------------------` ). number = numbers[ 2 ] . out->write( |Content of row 2: { number }| ). "Direct use of expression in string template out->write( |Content of row 1: { numbers[ 1 ] }| ). * Example 4: LOOP ... ENDLOOP ********************************************************************** out->write( `---------------------------` ). out->write( `Example 4: LOOP ... ENDLOOP` ). out->write( `---------------------------` ). LOOP AT numbers INTO number. out->write( |Row: { sy-tabix } Content { number }| ). ENDLOOP. * Example 5: Inline declaration in LOOP ... ENDLOOP ********************************************************************** out->write( `-----------------------------` ). out->write( `Example 5: Inline Declaration` ). out->write( `-----------------------------` ). LOOP AT numbers INTO DATA(number_inline). out->write( |Row: { sy-tabix } Content { number_inline }| ). ENDLOOP.
  3. Appuyez sur CTRL + F3 pour activer la classe et SUR F9 pour l'exécuter en tant qu'application console.
  4. Analysez la sortie de la console. Jouez avec le code source pour vous familiariser avec les concepts.

Utilisation de tables internes simples

Dans cet exercice, vous utilisez des itérations et des tables internes simples pour calculer et afficher les nombres Fibonacci.

Remarque

Les nombres de Fibonacci sont une suite de nombres dans laquelle chaque nombre est la somme des deux précédents. La séquence commence par 0 et 1 et chaque numéro suivant est la somme des deux numéros précédents. La séquence a diverses propriétés mathématiques, motifs et applications dans des domaines tels que les mathématiques, l'informatique, la nature et l'art.

Modèle :

  • Aucune

Solution :

  • /LRN/CL_S4D400_BTS_ITERATE (classe globale)

Tâche 1: Calculer les nombres

Dans votre propre package, créez une nouvelle classe globale. Définissez une constante pour le nombre d'itérations et une table interne pour les numéros Fibonacci. Calculez ensuite les nombres de Fibonacci dans une itération et sauvegardez-les dans la table interne.

Étapes

  1. Créez une nouvelle classe globale qui implémente l'interface IF_OO_ADT_CLASSRUN (nom proposé : ZCL_##_ITERATE, où ## représente votre numéro de groupe).

    1. Sélectionnez FichierNouvelleclasse ABAP.

    2. Saisissez le nom de votre package dans la zone Package. Dans la zone Nom, saisissez le nom ZCL_##_ITERATE, où ## représente votre numéro de groupe.

    3. Saisissez une description.

    4. Dans le cadre Interfaces, sélectionnez Ajouter.

    5. Saisissez IF_OO_ADT_CLASSRUN. Lorsque l'interface apparaît dans la liste des occurrences, double-cliquez dessus pour l'ajouter à la définition de classe.

    6. Cliquez sur Next.

    7. Sélectionnez votre ordre de transport et cliquez sur Terminer.

  2. Dans la méthode IF_OO_ADT_CLASSRUN~MAIN, définissez une constante pour le nombre d'itérations (nom proposé : max_count) avec une petite valeur, par exemple 20.

    1. Ajoutez le code suivant :

      Code Snippet
      123
      CONSTANTS max_count TYPE i VALUE 20.
  3. Déclarez une table interne simple pour stocker les numéros Fibonacci (nom suggéré : chiffres).

    1. Ajoutez le code suivant :

      Code Snippet
      123
      DATA numbers TYPE TABLE OF i.
  4. Implémentez une itération exécutée max_count fois.

    1. Après les déclarations, ajoutez le code suivant :

      Code Snippet
      12345
      DO max_count TIMES. ENDDO.
  5. Dans l'itération, implémentez une distinction de cas basée sur le compteur d'itérations intégré : Dans la première itération, ajoutez la valeur 0 aux numéros de table internes. Dans la deuxième itération, ajoutez la valeur 1 à la fin des numéros de table internes.

    Astuce

    Le compteur d'itérations intégré est le champ système sy-index.
    1. Entre DO et ENDDO, ajoutez le code suivant :

      Code Snippet
      12345678
      CASE sy-index. WHEN 1. APPEND 0 TO numbers. WHEN 2. APPEND 1 TO numbers. ENDCASE.
  6. Ajoutez une branche exécutée pour toutes les autres valeurs. Dans cette branche, calculez la nouvelle entrée comme la somme des deux entrées précédentes en nombres.

    Astuce

    Accédez aux entrées précédentes à l'aide de l'index sy-index - 1 et sy-index - 2.
    1. Adaptez le code comme suit :

      Code Snippet
      123456789101112
      CASE sy-index. WHEN 1. APPEND 0 TO numbers. WHEN 2. APPEND 1 TO numbers. WHEN OTHERS. APPEND numbers[ sy-index - 2 ] + numbers[ sy-index - 1 ] TO numbers. ENDCASE.

Tâche 2: Préparer une sortie formatée

Dans une boucle par-dessus la table interne, préparez une sortie formatée qui répertorie chaque numéro Fibonacci avec son numéro séquentiel respectif. Préparez la sortie dans une autre table interne de type ligne chaîne.

Étapes

  1. Au début de la méthode if_oo_adt_classrun~main, déclarez une table interne de type ligne chaîne (nom suggéré : output).

  2. Implémentez une boucle sur les numéros de table internes pour lire les numéros Fibonacci un par un dans un nombre variable.

    Astuce

    Utilisez une déclaration en ligne pour le nombre.
    1. À la fin de la méthode, ajoutez le code suivant :

      Code Snippet
      12345
      LOOP AT numbers INTO DATA(number). ENDLOOP.
  3. Déclarez une variable entière (nom suggéré : compteur) que vous définissez sur zéro avant la boucle et augmentez de 1 dans chaque itération.

    Astuce

    Vous pouvez utiliser une déclaration en ligne pour le compteur.
    1. Adaptez le code comme suit :

      Code Snippet
      12345678
      DATA(counter) = 0. LOOP AT numbers INTO DATA(number). counter = counter + 1. ENDLOOP.
  4. Dans chaque itération, ajoutez une nouvelle ligne à la sortie de table interne qui contient le contenu du compteur (4 caractères de large, aligné à gauche), deux points (:) et le contenu du nombre (large de 10 caractères, aligné à droite).

    Astuce

    Utilisez un modèle de chaîne avec des options de format appropriées pour ajuster le format.
    1. Adaptez le code comme suit :

      Code Snippet
      1234567891011
      DATA(counter) = 0. LOOP AT numbers INTO DATA(number). counter = counter + 1. APPEND |{ counter WIDTH = 4 ALIGN = LEFT }: { number WIDTH = 10 ALIGN = RIGHT }| TO output. ENDLOOP.

Tâche 3: Sortie et test

Écrivez le résultat dans la console. Activez et testez ensuite votre classe en tant qu'application de console.

Étapes

  1. À la fin de la méthode, appelez la méthode out->write pour écrire le contenu de la sortie dans la console. Attribuez une légende appropriée au nom du paramètre d'importation.

    1. Après ENDLOOP., ajoutez le code suivant :

      Code Snippet
      123456
      out->write( data = output name = |The first { max_count } Fibonacci Numbers| ) .
  2. Activez la classe.

    1. Appuyez sur Ctrl + F3 pour activer la classe.

  3. Exécutez votre classe en tant qu'application de console.

    1. Appuyez sur F9 pour exécuter la classe en tant qu'application console.