Objectives
After completing this lesson, you will be able to:
- Déclarer les objets de données.
- Affectez des valeurs.
Objets de données dans ABAP
Un objet de données dans un programme ABAP représente une section réservée de la mémoire du programme.
ABAP connaît trois types d'objets de données : variables, constantes et littéraux.
- Variables
Une variable est un objet de données dont le contenu peut être modifié lors de l'exécution. Une variable est identifiée par un nom. Le nom est également utilisé pour adresser l'objet de données au moment de l'exécution. La valeur de départ d'une variable ABAP est toujours bien définie.
- Constantes
Les constantes sont similaires aux variables. Contrairement aux variables, la valeur est codée en dur dans le code source et ne doit pas être modifiée pendant l'exécution. Comme les variables, les constantes ont un nom sous lequel elles peuvent être réutilisées.
- Littéraux
La valeur des littéraux est également codée en dur dans le code source. Contrairement aux constantes, les littéraux n'ont pas de nom. De ce fait, vous ne pouvez pas réutiliser un littéral. Utilisez uniquement des littéraux pour spécifier les valeurs des constantes et les valeurs de départ des variables.
Les objets de données ABAP sont toujours catégorisés : chaque objet de données est basé sur un type de données qui détermine le type d'information qu'ils peuvent contenir. Le type de données d'un objet de données ABAP reste le même tout au long de l'exécution d'un programme.
Déclaration de variables
Une variable dans un programme ABAP est déclarée avec le mot-clé DATA.
Une instruction DATA se compose de trois parties. Examinons chaque partie plus en détail.
- DATA
- Le mot-clé DATA est suivi du nom de la variable. Le nom d'une variable peut comporter jusqu'à 30 caractères. Il peut contenir les caractères A-Z, les chiffres 0-9 et le trait de soulignement. Le nom doit commencer par une lettre ou un trait de soulignement.
- TYPE
- Le type de la variable est indiqué après l'option TYPE. Dans l'exemple, les types intégrés i (pour les nombres entiers) et chaîne (chaîne de caractères avec longueur variable) sont utilisés.
- VALEUR
- L'option Valeur supplémentaire est facultative et vous pouvez l'utiliser pour indiquer une valeur de début pour la variable. Si VALUE est manquante, la variable est créée avec une valeur initiale qui dépend du type technique de la variable.
Sources des types de données ABAP
ABAP propose les sources de types de données suivantes :
- ABAP intégré
- ABAP dispose d'un ensemble de 14 types de données prédéfinis pour les objets de données numériques, alphanumériques et binaires simples.
- Instruction TYPES
- L'instruction TYPES vous permet de définir des types de données et de les réutiliser à différents endroits, en fonction de l'emplacement de la définition.
- Dictionnaire ABAP
- Le Dictionnaire ABAP fait partie de l'ABAP Repository. Il gère notamment les types de données globaux qui sont disponibles dans tout le système. Les types de Dictionnaire ABAP ne définissent pas seulement des propriétés techniques, ils ajoutent des informations sémantiques, par exemple des étiquettes. Les types de Dictionnaire ABAP sont particulièrement utiles lors de l'implémentation des interfaces utilisateur.
Essayer : types ABAP prédéfinis
- 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( ) :
12345678910111213141516171819202122232425
* Data Objects with Built-in Types
**********************************************************************
" comment/uncomment the following declarations and check the output
DATA variable TYPE string.
* DATA variable TYPE i.
* DATA variable TYPE d.
* DATA variable TYPE c LENGTH 10.
* DATA variable TYPE n LENGTH 10.
* DATA variable TYPE p LENGTH 8 DECIMALS 2.
* Output
**********************************************************************
out->write( 'Result with Initial Value)' ).
out->write( variable ).
out->write( '---------' ).
variable = '19891109'.
out->write( 'Result with Value 19891109' ).
out->write( variable ).
out->write( '---------' ).
- Appuyez sur CTRL + F3 pour activer la classe et SUR F9 pour l'exécuter en tant qu'application console.
- Analysez la sortie de la console. Retirez le commentaire des différentes déclarations de variable. Essayez vos propres déclarations pour vous familiariser avec les concepts.
Constantes et littéraux
Déclaration de constantes
Une constante est un objet de données avec une valeur codée en dur qui ne doit pas être modifiée pendant l'exécution. Tout accès en écriture à une constante entraîne une erreur de syntaxe.
Dans ABAP, vous déclarez une constante à l'aide du mot-clé CONSTANTS. Une instruction CONSTANT se compose des mêmes parties qu'une instruction DATA. La seule différence est que l'option VALUE est obligatoire.
Vous pouvez utiliser l'option VALUE sous la forme spéciale VALUE IS INITIAL si la valeur de la constante doit être la valeur initiale spécifique au type.
Littéraux dans ABAP
Les littéraux sont des objets de données anonymes avec une valeur codée en dur. Les littéraux sont souvent utilisés pour définir des valeurs non initiales pour les constantes et des valeurs initiales non initiales pour les variables.
Techniquement, vous pouvez utiliser des littéraux n'importe où dans votre code. Pour prendre en charge la lisibilité et la maintenabilité, il est recommandé de définir et d'utiliser des constantes à la place.
ABAP connaît trois types de littéraux :
- Les littéraux numériques sont des nombres entiers avec ou sans signe. Les littéraux numériques ont généralement le type de données I. Ce n'est que si la valeur est trop grande pour le type de données I que le type P est utilisé, avec une longueur suffisante et sans décimales.
- Les littéraux textuels sont des chaînes de caractères entre guillemets simples. Les littéraux textuels sont de type C. La longueur est dérivée du contenu entre guillemets. Les espaces vides de fin sont ignorés.
- Les littéraux de chaîne sont des chaînes de caractères entre guillemets arrière (`). Les littéraux de chaîne sont de type STRING. Ils doivent être utilisés pour fournir des valeurs pour les objets de données de type chaîne.
Essayer : objets de données
- 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( ) :
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253
* Example 1: Local Types
**********************************************************************
* Comment/Uncomment the following lines to change the type of my_var
TYPES my_type TYPE p LENGTH 3 DECIMALS 2.
* TYPES my_type TYPE i .
* TYPES my_type TYPE string.
* TYPES my_type TYPE n length 10.
* Variable based on local type
DATA my_variable TYPE my_type.
out->write( `my_variable (TYPE MY_TYPE)` ).
out->write( my_variable ).
* Example 2: Global Types
**********************************************************************
* Variable based on global type .
" Place cursor on variable and press F2 or F3
DATA airport TYPE /dmo/airport_id VALUE 'FRA'.
out->write( `airport (TYPE /DMO/AIRPORT_ID )` ).
out->write( airport ).
* Example 3: Constants
**********************************************************************
CONSTANTS c_text TYPE string VALUE `Hello World`.
CONSTANTS c_number TYPE i VALUE 12345.
"Uncomment this line to see syntax error ( VALUE is mandatory)
* constants c_text2 type string.
out->write( `c_text (TYPE STRING)` ).
out->write( c_text ).
out->write( '---------' ).
out->write( `c_number (TYPE I )` ).
out->write( c_number ).
out->write( `---------` ).
* Example 4: Literals
**********************************************************************
out->write( '12345 ' ). "Text Literal (Type C)
out->write( `12345 ` ). "String Literal (Type STRING)
out->write( 12345 ). "Number Literal (Type I)
"uncomment this line to see syntax error (no number literal with digits)
* out->write( 12345.67 ).
- 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.
- Annulez le commentaire des différentes déclarations de my_type et utilisez F2 et F3 pour analyser la définition de la variable my_variable.
- Utilisez F2 et F3 pour analyser la définition de l'aéroport variable.
- Retirez les commentaires de la définition de la constante c_text2 pour voir l'erreur de syntaxe.
- Retirez les commentaires de la dernière ligne de code pour voir l'erreur de syntaxe.
- ...
Valorisations aux objets de données
Utilisez les valorisations pour modifier la valeur des variables.
Regardez cette vidéo pour en savoir plus.
Conversions de types implicites
Bien qu'ABAP soit un langage de programmation catégorisé, dans une valorisation, le type de l'expression source et le type de la variable cible peuvent être différents. Si c'est le cas, la durée d'exécution tente une conversion de type.
Comme le montre la figure, essayez si possible d'éviter les conversions de types pour les raisons suivantes :
- Consommation supplémentaire de la durée d'exécution : les valeurs avec des conversions de types nécessitent plus de durée d'exécution que les valorisations de types identiques.
- Erreurs d'exécution potentielles : certaines combinaisons de type source et de type cible peuvent entraîner des erreurs d'exécution. Si, par exemple, la variable cible a un type numérique l et que l'expression source a un type caractère like, l'exécution déclenchera une erreur si elle ne peut pas traduire le texte en nombre.
- Perte d'informations potentielle : certaines combinaisons de type source et de type cible n'entraînent pas d'erreurs d'exécution mais peuvent entraîner une perte de données. Si, par exemple, la source et la cible sont toutes les deux de type C mais que le type de la variable cible est plus court. Ensuite, l'exécution tronque simplement la valeur de la source.
Réinitialisation des variables
L'instruction CLEAR est un type spécial de valorisation. Elle est utilisée pour réinitialiser une variable sur sa valeur initiale spécifique au type.
Remarque
L'instruction CLEAR ignore la valeur de départ de l'option VALUE. Après CLEAR, la variable contient toujours la valeur initiale spécifique au type.
Déclarations en ligne dans les valorisations
Regardez cette vidéo pour en savoir plus sur les déclarations en ligne et leur fonctionnement dans les valorisations.
