Cobol Chaîne Délimitée Par des ESPACES

WORKING-STORAGE.
    FIRST-STRING    PIC X(15) VALUE SPACES.
    SECOND-STRING     PIC X(15) VALUE SPACES.
    OUTPUT-STRING     PIC X(31) VALUE SPACES.

Si FIRST-NAME = 'JON SNOW, ' and LAST-NAME = 'KNOWS NOTHING. ', comment puis-je obtenir:

Je veux Obtenir :

OUTPUT-STRING = 'JON SNOW, KNOWS NOTHING.         '

Quand j'essaie :

String FIRST-STRING DELIMITED BY SPACES
       ' ' DELIMITED BY SIZE
       SECOND-STRING DELIMITED BY SIZE
       INTO OUTPUT-STRING

- Je Obtenir 'JON KNOWS NOTHING. '

Et Quand j'essaie :

String FIRST-STRING DELIMITED BY SIZE
       SECOND-STRING DELIMITED BY SIZE
       INTO OUTPUT-STRING

- Je obtenir 'JON SNOW, KNOWS NOTHING. '

J'ai trouvé un réglage qui se composent de String FIRST-STRING DELIMITED BY ' ' (deux places)
Mais il n'y a aucune garantie que ma PREMIÈRE CHAÎNE ne contient deux espaces qui vous fera perdre la partie.

J'ai mis à jour ma réponse, important si votre PREMIÈRE CORDE peut être vide,
codereview.stackexchange.com/questions/69220/...
CodeReview est pour Code qui fonctionne comme prévu. Ce n'est pas.
oui, je sais. J'ai été le pointage de l'OP, pour cet exemple, comme je le pensais la discussion il n'y aurait aider à la compréhension.
ah, klkl, désolé 🙂

OriginalL'auteur raz_user | 2015-08-11

cobol delimiter

7

Tout d'abord, bravo, comme beaucoup voudraient aller avec la délimité par deux espaces et ne pas être préoccupé par les conséquences possibles. Notez que si les données sont suivies par un espace de fin seulement, vous bénéficiez également de "inattendu" de sortie. Notez également que votre définition de champ pour la SORTIE de CHAÎNE est un octet bref, comme vous l'insérez un espace pour séparer les données. Avec les deux champs entièrement rempli avec des données, vous perdrez de l'octet final de la DEUXIÈME CHAÎNE.

COBOL est un langage de champs de longueur fixe (sauf quand ils sont variables). Donc il n'y a pas de "standard" délimiteurs, donc n'importe quel caractère ou la valeur peut apparaître à n'importe quelle position dans un champ. En outre, le défaut de rembourrage de caractère, où la source est plus court que le champ cible, de l'espace, ce qui est tout à fait normal, séparateur de mots.

Dans votre, et de la beaucoup de semblables, cas vous avez besoin de connaître la longueur de la partie données réelles de votre domaine (à l'exclusion des espaces à droite).

Un moyen très courant de le faire est comme suggéré par @user4341206 dans leur réponse, https://stackoverflow.com/a/31938039/1927206.

En vertu de l'1985 COBOL Standard, INSPECTER peut être utilisée pour compter les leader espaces, mais ne peut pas être utilisée pour compter les de fuite espaces. FUNCTION REVERSE peut être utilisée en premier pour transformer les espaces en espaces, de sorte que INSPECTER pouvez compter.

Une fois que vous savez le nombre d'espaces à droite, vous pouvez utiliser le LENGTH OF spéciale de vous inscrire ou de FUNCTION LENGTH pour déterminer la longueur de la zone de longueur fixe (les deux sont (ou peuvent être, selon le compilateur) évaluée au moment de la compilation). La différence entre la longueur du champ et le nombre d'espaces à droite vous donne la longueur des données.

Une fois que vous avez la longueur des données, et en gardant à l'esprit qu'il peut être vide (dépend des possibilités pour les données) et peut être de la même longueur que le champ

Être conscient que si vous avez beaucoup de données, vous ne pouvez pas revenir sur votre terrain et INSPECTER (probablement une routine d'exécution) par rapport à une simple boucle à partir de la fin de la zone de compter les espaces de droite.

Remarque, que les compilateurs comme AcuCOBOL (qui fait maintenant partie de Micro Focus COBOL offres) ont une Extension du Langage qui offre de FUITE comme une option pour les INSPECTER. Remarque, même les 2014 COBOL Norme n'a pas eu de FUITE comme une option pour les INSPECTER.

De toute façon, avec la longueur des données que vous avez terminé. En quelque sorte.

Vous pouvez utiliser de référence-modification au sein de la CHAÎNE de déclaration:
```
String FIRST-STRING ( 1 : length-field-you-define ) DELIMITED BY SIZE
       ' ' DELIMITED BY SIZE
       SECOND-STRING DELIMITED BY SIZE
   INTO OUTPUT-STRING
```
Note, vous devez être en mesure de supprimer PAR la TAILLE, comme la TAILLE de l'est par défaut, mais il ne le rendre plus clair pour le lecteur humain.

Vous pouvez également utiliser les DÉPLACER avec la référence de la modification sur le champ cible:
```
MOVE FIRST-STRING            TO OUTPUT-STRING  
                                 ( 1 : length-field-you-define )
MOVE SPACE                   TO OUTPUT-STRING  
                                 ( length-field-you-define + 1 : 1 )
MOVE SECOND-STRING           TO OUTPUT-STRING  
                                 ( length-field-you-define + 2 :  )
```
Il y a un problème spécifique avec la référence de la modification (mentionné sur l'autre réponse) qui est vous-longueur de champ ne doit pas être zéro.

L'évaluation de la longueur résultat positif non nul entier.

Longueur dans ce contexte est le deuxième élément, après la :, dans la référence de modification de la notation. Dans ce cas, cela signifie que la longueur de champ-vous-définir ne doit pas être nulle, elle pourrait être calculée si la PREMIÈRE CHAÎNE est entièrement l'espace.

La possibilité d'un problème avec ceci:
```
MOVE FIRST-STRING            TO OUTPUT-STRING  
                                 ( 1 : length-field-you-define )
```
Par conséquent, en fonction de vos données (si elle peut contenir des blancs), vous avez pour "protéger" contre cette.
```
    IF FIRST-STRING EQUAL TO SPACE
        PERFORM                  COPY-SECOND-STRING-ONLY
    ELSE
        PERFORM                  CONCATENATE-FIRST-AND-SECOND
    END-IF
    ...
COPY-SECOND-STRING-ONLY.
    MOVE SECOND-STRING           TO OUTPUT-STRING
    .
CONCATENATE-FIRST-AND-SECOND.
    calculate length
    MOVE FIRST-STRING            TO OUTPUT-STRING  
                                    ( 1 : length-field-you-define )
    MOVE SPACE                   TO OUTPUT-STRING  
                                    ( length-field-you-define + 1 : 1 )
    MOVE SECOND-STRING           TO OUTPUT-STRING  
                                    ( length-field-you-define + 2 :  )
    .
```
Si vous utilisez une référence de modification avec une longueur de zéro, le résultat n'est pas défini, bien qu'il puisse "travailler" avec votre compilateur.

Les solutions avec de la FICELLE et de la longueur variable des champs ne seront pas "en panne", parce que le compilateur en dehors de référence-la modification est heureux avec zéro longueur des éléments.

Cependant, la même "protection" devrait être utilisé pour deux raisons: vous pouvez insérer un des principaux vide (le "séparateur"); vous ferez votre code explicite, afin que les gens n'ont pas à se demander "ce qui se passe lorsque le premier champ est vide"; vous ferez des économies sur le traitement.

De cette façon, votre programme "décrit vos données" mieux. Avec "données" comme une nécessité pour la précision de la conception du programme, plus votre programme décrit les données, plus il est difficile de créer des erreurs de commission ou d'omission, plus il est facile à comprendre, et plus il est facile de changer quand, comme il arrive, la structure de la modification des données.

Vous pouvez aussi regarder la CHAÎNE de l'aide du POINTEUR. Tout d'abord, DÉPLACEZ la PREMIÈRE CHAÎNE de SORTIE de CHAÎNE (qui sera aussi claire le solde non utilisé des octets en SORTIE de CHAÎNE à l'espace). Puis ajouter un à la longueur de champ-vous-définir (par l'intermédiaire de l'espace) et de l'utiliser dans la CHAÎNE de la AVEC le POINTEUR.

Bien que c'est parfaitement valide, si vous l'utilisez, c'est l'occasion de faire des commentaires, comme beaucoup de personnes qui utilisent régulièrement le STRING n'ai aucune idée de l'utiliser AVEC le POINTEUR, afin de leur venir en aide.

Une autre possibilité est d'utiliser la variable de champs de longueur.

Malheureusement, pas tous les compilateurs COBOL rendre cela facile. Un "Complexe ODO", ce qui exiger que, dans sa forme la plus pure, est non-Standard, mais est un IBM Extension de la langue.
```
LINKAGE SECTION.
01  L-MAPPING-OF-OUTPUT-STRING.
    05  L-MOOS-FIRST-STRING.
        10  FILLER OCCURS 0 TO 15 TIMES
            DEPENDING ON length-field-you-define.
            15  FILLER                          PIC X.
    05  L-MOOS-SEPARATOR-SPACE                  PIC X.
    05  L-MOOS-SECOND-STRING                    PIC X(15).

    ...
    SET ADDRESS OF L-MAPPING-OF-OUTPUT-STRING
                             TO ADDRESS OF 
                                 OUTPUT-STRING  
    MOVE FIRST-STRING        TO L-MOOS-FIRST-STRING
    MOVE SPACE               TO L-MOOS-SEPARATOR-SPACE
    MOVE SECOND-STRING       TO L-MOOS-SECOND-STRING
```
Si vous avez beaucoup de données, de la façon la plus rapide est la référence modidifcation seule suggestion. Mon avis de modification, c'est qu'il a tendance à obscurcir, parce que les gens ont tendance à l'utiliser dans un obfuscatory (et inutiles).

Ma préférence est pour la dernière, où la PROCÉDURE de DIVISION de code est très simple: vous devez trouver la longueur des données dans le premier champ; vous venez de faire trois plaine se Déplace.

Peut-être que vous pouvez essayer chacune, à devenir plus conscients des possibilités pour des situations futures.

Personne ne m'a jamais donné une telle réponse complète, je vous remercie beaucoup
Vous n'avez pas déjà demandé un COBOL question 🙂
personne ne m'a jamais donné une telle réponse, jamais, pas en Cobol, j'ai suivi vos instructions, et j'ai utilisé la référence de modification de l'approche, car j'ai déjà calculer la longueur des données, et c'est vraiment génial de travailler, j'ai passé toute la journée à travailler sur ce problème, encore une fois merci beaucoup

OriginalL'auteur Bill Woodger
6

Je ne sais pas si cela va vous aider, mais si vous voulez supprimer les espaces à droite de la première chaîne, vous pourriez quelque chose comme ça avant concating chaînes:
```
INSPECT FUNCTION REVERSE(FIRST-STRING) TALLYING W-SPACES FOR LEADING SPACES

COMPUTE W-FIRST-STRING-LEN = LENGTH OF FIRST-STRING - W-SPACES
```
FIRST-STRING(1:W-FIRST-STRING-LEN) contient alors la première chaîne de caractères sans espaces (JOHN SNOW,)

Merci. Ensuite, c'est un peu de la protection à nouveau la PREMIÈRE CHAÎNE entièrement vide. La longueur de la partie d'un modificateur de référence peut ne pas être égale à zéro.
Merci, je upvoted votre réponse provoquer fournir de l'aide, mais j'ai accepté @BillWoodger réponse pour être l'ultime réponse pour ma question

OriginalL'auteur user4341206

Vous devez vous connecter pour publier un commentaire.