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

Données de traitement

Objectives

After completing this lesson, you will be able to:

Effectuer des calculs arithmétiques.
Appliquez le traitement de chaîne.

Calculs arithmétiques

Les expressions arithmétiques sont des expressions ABAP avec une combinaison de valeurs, d'opérateurs et de fonctions que le système d'exécution traite pour calculer un résultat. Pour les expressions arithmétiques, le type de résultat dépend du type d'opérandes utilisés comme entrée dans l'expression.

Vous pouvez utiliser une expression arithmétique dans n'importe quelle position d'opérande de lecture, par exemple, à droite d'une valorisation.

La vidéo suivante illustre les bases des expressions arithmétiques.

Essayer : calculs arithmétiques

Comme dans le premier exercice de ce cours, créez une nouvelle classe globale qui implémente l'interface IF_OO_ADT_CLASSRUN.

Copiez l'extrait de code suivant dans la partie implémentation de la méthode if_oo_adt_classrun~main( ) :

Code Snippet

12345678910111213141516171819202122232425262728293031

* Declarations
**********************************************************************

    " comment/uncomment these line for different result types
    TYPES t_result TYPE p LENGTH 8 DECIMALS 2.
*    TYPES t_result TYPE p LENGTH 8 DECIMALS 0.
*    TYPES t_result TYPE i.

    DATA result TYPE t_result.

* Calculations
**********************************************************************
    " comment/uncomment these lines for different calculations

    result = 2 + 3.
*    result = 2 - 3.
*    result = 2 * 3.
*    result = 2 / 3.
*
*    result = sqrt( 2 ).
*    result = ipow( base = 2 exp = 3 ).
*
*    result = ( 8 * 7 - 6 ) / ( 5 + 4 ).
*   result = 8 * 7 - 6 / 5 + 4.

* Output
**********************************************************************

    out->write( result ).

Appuyez sur CTRL + F3 pour activer la classe et SUR F9 pour l'exécuter en tant qu'application console.
Jouez avec le code source pour vous familiariser avec les concepts.
- Retirez les commentaires des différents calculs et définitions de type.
- Implémentez vos propres calculs.

Traitement de chaîne

Les modèles de chaîne sont des expressions ABAP de type de résultat Chaîne. Vous pouvez utiliser des modèles de chaîne dans n'importe quelle position d'opérande de lecture, par exemple, à droite d'une valorisation.

Un modèle de chaîne commence et se termine par un symbole de barre verticale ( | ). Le modèle de chaîne le plus simple possible ne contient rien d'autre que du texte littéral. Dans cette forme, un modèle de chaîne n'est pas vraiment différent d'un littéral de chaîne.

Ce qui distingue un modèle de chaîne d'un littéral de chaîne, c'est la possibilité d'incorporer des expressions. Une expression intégrée est une expression ABAP entourée d'une paire d'accolades ( { et } ). Au moment de l'exécution, ABAP évalue l'expression intégrée et traduit le résultat en chaîne. Dans le résultat final, cette chaîne remplace l'expression intégrée (avec les accolades qui l'entourent).

Remarque

La syntaxe ABAP requiert au moins un espace après le parenthèse ouvrante et au moins un espace avant le crochet fermant.

Bien sûr, un modèle de chaîne peut contenir plusieurs expressions intégrées.

À l'intérieur des accolades, vous pouvez placer n'importe quel type d'expression ABAP : expressions arithmétiques, comme dans l'exemple ci-dessus, mais des variables uniques ou même des littéraux peuvent servir d'expressions incorporées.

Un cas d'utilisation important pour les modèles de chaîne est la mise en forme contrôlée des données pour l'édition.

Dans le premier exemple, la variable the_date est de type d et contient une date au format interne (brut) AAAAMMJJ (où AAAA correspond à l'année, MM au mois à deux chiffres et JJ à la date à deux chiffres). Lorsque vous utilisez la variable the_date comme expression intégrée dans un modèle de chaîne, le résultat est identique au format interne. Mais lorsque vous ajoutez l'option de mise en forme DATE = <format_date> entre accolades, le système met en forme la valeur comme une date. Si vous ajoutez DATE = ISO, la sortie sera au format ISO. Avec DATE = USER, le format d'édition dépend des options utilisateur de l'utilisateur actuel.

Le deuxième exemple illustre certaines des options que vous pouvez utiliser pour mettre en forme les nombres. NUMBER vous permet de contrôler la mise en forme générale des nombres, par exemple, si un signe décimal est utilisé ou une virgule décimale. SIGN vous permet de piloter la position du signe et si un signe plus (+) est affiché ou non. À l'aide de STYLE, vous pouvez choisir parmi plusieurs styles prédéfinis, comme un style scientifique ou un style d'ingénierie.

Vous pouvez lier des zones à l'aide de l'opérateur de concaténation &&. Vous pouvez joindre n'importe quelle combinaison d'objets de données et d'expressions de chaîne.

Les parties constitutives de l'expression sont jointes sans espace ou autre séparateur entre elles. Si vous avez besoin d'espaces ou d'un autre caractère de séparation, n'oubliez pas de l'insérer vous-même dans l'expression comme indiqué dans le deuxième exemple.

Essayer : traitement de chaîne

Comme dans le premier exercice de ce cours, créez une nouvelle classe globale qui implémente l'interface IF_OO_ADT_CLASSRUN.

Copiez l'extrait de code suivant dans la partie implémentation de la méthode if_oo_adt_classrun~main( ) :

Code Snippet

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354

 METHOD if_oo_adt_classrun~main.

* Declarations
**********************************************************************
    TYPES t_amount TYPE  p LENGTH 8 DECIMALS 2.

    DATA amount   TYPE t_amount VALUE '3.30'.
    DATA amount1  TYPE t_amount VALUE '1.20'.
    DATA amount2  TYPE t_amount VALUE '2.10'.

    DATA the_date  TYPE d                     VALUE '19891109'.
    DATA my_number TYPE p LENGTH 3 DECIMALS 2 VALUE '-273.15'.

    DATA part1 TYPE string VALUE `Hello`.
    DATA part2 TYPE string VALUE `World`.

* String Templates
**********************************************************************

    " comment/uncomment the following lines for different examples
    DATA(text) = |Hello World|.
*    DATA(text) = |Total: { amount } EUR|.
*    DATA(text) = |Total: { amount1 + amount2 } EUR|.

* Format Options
**********************************************************************

    "Date
*    DATA(text) = |Raw Date: { the_date             }|.
*    DATA(text) = |ISO Date: { the_date Date = ISO  }|.
*    DATA(text) = |USER Date:{ the_date Date = USER }|.

    "Number
*    DATA(text) = |Raw Number { my_number                    }|.
*    DATA(text) = |User Format{ my_number NUMBER = USER      }|.
*    DATA(text) = |Sign Right { my_number SIGN = RIGHT       }|.
*    DATA(text) = |Scientific { my_number STYLE = SCIENTIFIC }|.

* String expression (concatenation Operator)
**********************************************************************

*    DATA(text) = part1 && part2.
*    DATA(text) = part1 && | | && part2.
*    DATA(text) = |{ amount1 } + { amount2 }| &&
*                 | = | &&
*                 |{ amount1 + amount2 }|.


* Output
**********************************************************************

    out->write( text ).

Appuyez sur CTRL + F3 pour activer la classe et SUR F9 pour l'exécuter en tant qu'application console.
Jouez avec le code source pour vous familiariser avec les concepts.
- Supprimez le commentaire des différentes affectations de valeurs pour le texte de variable déclarée en ligne afin d'afficher un résultat différent.
- Essayez vos propres affectations.

Déclarer les variables et traiter les données

Dans cet exercice, vous créez un programme qui effectue un calcul basé sur deux nombres, puis met en forme et édite le résultat.

Modèle :

Aucune

Solution :

/LRN/CL_S4D400_BTS_COMPUTE (classe globale)

Tâche 1: Déclaration variable

Dans votre propre package, créez une nouvelle classe globale et définissez des variables numériques pour l'entrée.

Étapes

Créez une nouvelle classe globale qui implémente l'interface IF_OO_ADT_CLASSRUN (nom proposé : ZCL_##_COMPUTE, où ## correspond à votre numéro de groupe).
1. Sélectionnez Fichier→Nouvelle→classe ABAP.
2. Saisissez le nom de votre package dans la zone Package. Dans la zone Nom, saisissez le nom ZCL_##_COMPUTE, 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.
Dans la méthode IF_OO_ADT_CLASSRUN~MAIN, déclarez deux variables pour les valeurs entières (noms suggérés : nombre1 et nombre2).
1. Ajoutez le code suivant :
  Code Snippet
```
1234

    DATA number1 TYPE i.
    DATA number2 TYPE i.
```
Implémentez une valorisation pour chacune des deux variables numériques. Affectez une valeur négative à la première variable et une valeur positive à la deuxième variable.
1. Ajoutez le code suivant :
  Code Snippet
```
1234

    number1 = -8.
    number2 =  3. 
```

Tâche 2: Traitement des données

Calculez un ratio et écrivez le résultat dans la console.

Étapes

Implémentez une expression arithmétique qui calcule le ratio des deux nombres. Stockez le résultat dans une variable que vous déclarez à l'aide d'une déclaration en ligne (nom suggéré : résultat).
1. Ajoutez le code suivant :
  Code Snippet
```
123

    DATA(result) = number1 / number2.
```
Implémentez un modèle de chaîne qui rassemble un texte comme celui-ci :"6 / 3 = 2", avec les valeurs réelles des variables au lieu de 6, 3 et 2. Stockez le résultat dans une variable que vous déclarez à l'aide d'une déclaration en ligne (nom suggéré : sortie).
1. Ajoutez le code suivant :
  Code Snippet
```
123

    DATA(output) = |{ number1 } / { number2 } = { result }|.
```
Appelez la méthode out->write( … ) pour écrire le texte dans la console.
1. Procédez comme vous l'avez fait dans l'exercice précédent.

Tâche 3: Activer et tester

Activez et testez l'application Console.

Étapes

Activez la classe.
1. Appuyez sur Ctrl + F3 pour activer la classe.
Exécutez l'application de console.
1. Appuyez sur F9 pour exécuter l'application console.
Testez l'application avec différentes valeurs de saisie.
1. Traitez les valorisations, puis activez-les et exécutez-les comme avant.

Tâche 4: Contrôler la précision du résultat

Assurez-vous que le résultat est arrondi à une valeur avec 2 décimales et non à une valeur entière.

Étapes

Au lieu d'une déclaration en ligne, utilisez une déclaration explicite de résultat variable. Utilisez un type numérique qui permet d'indiquer le nombre de décimales.
1. Au début de la méthode if_oo_adt_classrun~main, ajoutez le code suivant :
  Code Snippet
```
123

    DATA result TYPE p LENGTH 8 DECIMALS 2.
```
2. Dans la ligne de code avec la déclaration en ligne, remplacez DATA(result) par result.

Activez à nouveau la classe et testez.

Procédez comme vous l'avez fait auparavant.

Comparez votre code à l'extrait suivant de la solution modèle :

Code Snippet

12345678910111213141516171819202122232425262728293031323334

 METHOD if_oo_adt_classrun~main.

* Declarations
**************************

    DATA number1 TYPE i.
    DATA number2 TYPE i.

    DATA result TYPE p LENGTH 8 DECIMALS 2.

    
* Input Values
**************************

    number1 = -8.
    number2 =  3.

* Calculation
**************************

*    DATA(result) = number1 / number2.   "with inline declaration 
 
   result = number1 / number2.

    DATA(output) = |{ number1 } / { number2 } = { result }|.

* Output
**************************

    out->write( output ).

  ENDMETHOD.

Next lesson