2012-12-20 17 views
5

È necessario concatenare 4 stringhe a una variabile di destinazione in cobol.Concatena una stringa in base alla lunghezza COBOL

Come,

01 WS-S1 X(10) VALUE "HI ". 
01 WS-S2 X(10) VALUE "HOW ". 
01 WS-S3 X(10) VALUE "ARE ". 
01 WS-S4 X(10) VALUE "YOU?". 

in una stringa risultante

"HI HOW ARE YOU?" 

Qualcuno può darmi una mano?

risposta

20

Ecco un esempio di lavoro del STRING verb che fa quello che state cercando:

IDENTIFICATION DIVISION. 
    PROGRAM-ID. EXAMPLE. 
    DATA DIVISION. 
    WORKING-STORAGE SECTION. 
    01 WS-S1 PIC X(10) VALUE 'HI '. 
    01 WS-S2 PIC X(10) VALUE 'HOW '. 
    01 WS-S3 PIC X(10) VALUE 'ARE '. 
    01 WS-S4 PIC X(10) VALUE 'YOU?'. 
    01 WS-CONCAT PIC X(43) VALUE SPACES. 
    PROCEDURE DIVISION. 
    MAIN-PARAGRAPH. 
     STRING WS-S1 DELIMITED BY SPACE 
       ' ' DELIMITED BY SIZE 
       WS-S2 DELIMITED BY SPACE 
       ' ' DELIMITED BY SIZE 
       WS-S3 DELIMITED BY SPACE 
       ' ' DELIMITED BY SIZE 
       WS-S4 DELIMITED BY SPACE 
      INTO WS-CONCAT 
     END-STRING 
     DISPLAY '>' WS-CONCAT '<' 
     GOBACK 
     . 

uscita è:

>HI HOW ARE YOU?       < 
2

OpenCOBOL ha un'estensione funzione intrinseca, CONCATENA.

DISPLAY FUNCTION CONCATENATE(
    FUNCTION TRIM(WS-S1); SPACE; 
    FUNCTION TRIM(WS-S2); SPACE; 
    FUNCTION TRIM(WS-S3); SPACE; 
    FUNCTION TRIM(WS-S4)) 
END-DISPLAY 

ma mi piace il verbo STRING delimitate da risposta, come funzionerà con la maggior parte, se non tutti, i compilatori.

Per quanto riguarda il motivo di delimitatori virgola all'interno degli elenchi di parametro di funzione, non è strettamente necessario, preferenze personali, come a volte evita potenziali problemi con

SPECIAL-NAMES. 
DECIMAL POINT IS COMMA. 

e COBOL, essendo il robusto animale lessicale che è

DISPLAY FUNCTION CONCATENATE(WS-S1 WS-S2 WS-S3 WS-S4) 
DISPLAY FUNCTION CONCATENATE(WS-S1, WS-S2, WS-S3, WS-S4) 

anche la sintassi funziona.

0

C'è un problema con "delimitato dallo spazio". Se ws-s1 = 'how are' - delimitato dallo spazio metterà solo 'how'. ecco alcuni esempi:

01 ws-string-test. 
03 y1    pic x(10) value 'y1 a'. 
03 y2    pic x(10) value 'y2 b'. 
03 y3    pic x(10) value 'y3 c'. 

01 WS-lavoro pic x (200).

 move spaces to ws-work 
     string y1 delimited by size 
       y2 delimited by space 
       y3 delimited by size 
       into ws-work. 
     ws-work = "y1 a  y2y3 c    " 

     move spaces to ws-work 
     string y1 
       y2 
       y3 
       delimited by size into ws-work 
     ws-work = "y1 a  y2 b   y3 c   " 


     string y1 
       y2 
       y3 
       delimited by spaces into ws-work. 
     ws-work = "y1y2y3 

     string y1 y2 y3 into ws-work by csv-format. 
     ws-work = "y1 a,y2 b,y3 c  " 

Spero che possa essere d'aiuto.

zalek

+0

Questo non risolve la domanda reale. Quale compilatore COBOL stai usando quel supporto per la sintassi finale che mostri per 'STRING'? È non standard. –

0

dare a questo un vortice. Dovrebbe essere indipendente dalla piattaforma.

DATA DIVISION. 

    WORKING-STORAGE SECTION. 

    01 result-string-text   X(100). 
    01 result-string-length   9(03). 
    01 result-string-datalength  9(03). 

    01 new-string-text    X(20). 
    01 new-string-length   9(03). 
    01 new-string-datalength  9(03). 

    01 hold-string-text    X(100). 

    01 trailing-space-count   9(03). 

    PROCEDURE DIVISION. 

     MOVE SPACES TO result-string-text. 
     MOVE FUNCTION LENGTH(result-string-text) TO result-string-length. 
     MOVE FUNCTION LENGTH(new-string-text) TO new-string-length. 

     MOVE ws-s1 TO new-string-text. 
     PERFORM 5500-concatenate. 

     MOVE ws-s2 TO new-string-text. 
     PERFORM 5500-concatenate. 

     MOVE ws-s3 TO new-string-text. 
     PERFORM 5500-concatenate. 

     MOVE ws-s4 TO new-string-text. 
     PERFORM 5500-concatenate. 

    5500-concatenate. 
     MOVE ZERO TO trailing-space-count 
     INSPECT FUNCTION REVERSE(result-string-text) TALLYING trailing-space-count FOR LEADING ' ' 
     COMPUTE result-string-datalength = result-string-length - trailing-space-count 

     IF (result-string-datalength > ZERO) 
      MOVE ZERO TO trailing-space-count 
      INSPECT FUNCTION REVERSE(new-string-text) TALLYING trailing-space-count FOR LEADING ' ' 
      COMPUTE new-string-datalength = new-string-length - trailing-space-count 

      MOVE SPACES TO hold-string-text 
      STRING 
       result-string-text(1:result-string-datalength) 
       ' ' 
       new-string-text(1:new-string-datalength) 
        DELIMITED BY SIZE 
      INTO 
       hold-string-text 
      END-STRING 

      MOVE hold-string-text to result-string-text 
     ELSE 
      MOVE new-string-text TO result-string-text 
     END-IF. 
+0

Rilasciare il comando 'MOVE SPACES TO result-string-text', cambia' MOVE ws-s1 TO new-string-text' in 'MOVE ws-s1 TO result-string-text'. Questo elimina il tuo 'SE' nel' 5500-'. Usando 'WITH POINTER' si sbarazza di' hold-string-text'. Ciò ridurrà la dimensione del tuo paragrafo di circa 1/3, rendendolo più chiaro e più facile da mantenere. Alcuni, non io, userebbero la modifica di riferimento per l'intera faccenda. Nell'esempio specifico attuale, con garanzia di assenza di spazi incorporati, è sufficiente il semplice 'STRING' nella risposta accettata. –

+0

Hai punti eccellenti, Bill. Mentre suono con POINTER per intero, non sono sicuro che lo facciano tutti. Non voglio che questo suoni come codice per il programmatore LCD, ma penso a chi ha un'esperienza COBOL limitata, forse uno che è venuto da un'altra lingua e ha vagato o è stato spinto in COBOL, come potrebbero visualizzare il codice.Un modificatore di riferimento non è una sintassi comparabile a SUBSTRING, ma sembra un po 'più intuitivo. – Kennah

+0

Il 'WITH POINTER' Sono d'accordo che pochi usano, o saprebbero come usare :-) Tuttavia, dovrebbe rimanere così? Alziamo lo schermo LCD. Il suo uso può essere commentato. Il vantaggio di STRING rispetto alla modifica del riferimento è che il compilatore si occupa delle dimensioni del campo piuttosto che del programmatore che lo fa (o meno). Altri modi per farlo anche. Ricorda, molti trovano, o creano, anche il complesso 'COMPUTE' :-) –