Nettoyage des cellules vides dans la table interne

Question

Je tente de nettoyer les cellules vides suivantes marquées en rouge à partir de cette table interne avant de l'afficher dans un fichier ALV.

Si une cellule est vide, recherchez les cellules en dessous de celles qui ont la valeur et remontez.

J'ai du mal à comprendre quelle est la meilleure façon de faire cela.

Toute aide serait géniale.

Answer 1

Il ne fait aucun doute que quelque chose ne va pas dans votre logique de fusion, mais votre tâche est très intéressante et c'est l'un des moyens possibles pour la résoudre.

Je pris votre structure et a fait une hypothèse selon laquelle aucune des lignes de votre table est entièrement remplie, à savoir soit trois premières colonnes sont remplies (struct_left) ou trois (struct_right). Voilà comment je le ressens à partir de vos captures d'écran.

REPORT z_sections. 
TYPES: 
     BEGIN OF struct_left, " left structure 
     LEFTDAMAGED TYPE c LENGTH 1, 
     LEFTDAMAGEDDESC TYPE c LENGTH 3, 
     LEFTDAMAGEDDESCT TYPE c LENGTH 30, 
     END OF struct_left, 
     BEGIN OF struct_right, " right structure 
     RIGHTDAMAGED TYPE c LENGTH 1, 
     RIGHTDAMAGEDDESC TYPE c LENGTH 3, 
     RIGHTDAMAGEDDESCT TYPE c LENGTH 30, 
     END OF STRUCT_right. 
     TYPES BEGIN OF ty_table. 
     INCLUDE TYPE struct_left. 
     INCLUDE TYPE struct_right. 
     TYPES END OF ty_table. 

DATA: lt_current_table TYPE TABLE OF ty_table INITIAL SIZE 100, 
     ls_current_table LIKE LINE OF lt_current_table, 
     i TYPE i. 

FIELD-SYMBOLS: <fld> TYPE clike. 
DATA: r_random TYPE REF TO cl_abap_random_packed, 
     seed  TYPE i. 

seed = cl_abap_random=>seed(). 
CALL METHOD cl_abap_random_packed=>create 
    EXPORTING 
    seed = seed 
    min = -999999999999999 
    max = 999999999999999 
    RECEIVING 
    prng = r_random. 

DEFINE randomize. " filling row with random data 
    ASSIGN COMPONENT &1 OF STRUCTURE &2 TO <fld>. 
    <fld> = r_random->get_next(). 
    &1 = &1 + 1. 
    ASSIGN COMPONENT &1 OF STRUCTURE &2 TO <fld>. 
    <fld> = r_random->get_next(). 
    &1 = &1 + 1. 
    ASSIGN COMPONENT &1 OF STRUCTURE &2 TO <fld>. 
    <fld> = r_random->get_next(). 
END-OF-DEFINITION. 

START-OF-SELECTION. 
* filling table with random stuff 
DO 100 TIMES. 
    CLEAR ls_current_table. 
    IF sy-index MOD 3 = 0. 
     i = 1. 
     randomize i ls_current_table. 
    ELSE. 
     i = 4. 
     randomize i ls_current_table. 
    ENDIF. 
    APPEND ls_current_table TO lt_current_table. 
ENDDO. 

DATA: ls_left TYPE struct_left, 
     ls_right TYPE struct_right. 

DATA lt_new LIKE lt_current_table. 

* collapsing table 
LOOP AT lt_current_table ASSIGNING FIELD-SYMBOL(<fs_current>) WHERE leftdamaged IS NOT INITIAL. 
     DELETE lt_current_table WHERE leftdamaged IS INITIAL AND leftdamageddesc IS INITIAL AND leftdamageddesct IS INITIAL AND 
     rightdamaged IS INITIAL AND rightdamageddesc IS INITIAL AND rightdamageddesct IS INITIAL. " remove empty lines 
     MOVE-CORRESPONDING <fs_current> TO ls_left. 

     READ TABLE lt_current_table ASSIGNING FIELD-SYMBOL(<fs_right>) WITH KEY leftdamaged = ''. 
     IF <fs_right> IS ASSIGNED. 
     MOVE-CORRESPONDING <fs_right> TO ls_right. 
     CLEAR: <fs_right>. 
     ENDIF. 
     CLEAR: <fs_current>. 

     IF ls_left IS NOT INITIAL AND ls_right IS NOT INITIAL. 
     CLEAR: ls_current_table. 
     MOVE-CORRESPONDING ls_left TO ls_current_table. 
     MOVE-CORRESPONDING ls_right TO ls_current_table. 
     APPEND ls_current_table TO lt_new. 
     CLEAR: ls_left, ls_right. 
     ENDIF. 
ENDLOOP. 

Answer 2

Vous pouvez trier la table interne et le stocker dans une table temporaire interne, et de les échanger. Par exemple:

data: lt_itab_temp like table of lt_itab. 
move lt_itab[] to lt_itab_temp[]. 
clear:lt_itab[],lt_itab. 
sort lt_itab_temp descending by rightdamagedesc rightdamagedesct. 
move lt_itab_temp[] to lt_itab[]. 

OU, vous pouvez faire une boucle à travers le fieldcatalog, réglez "no_display" ou "no_out" champ 'X'.