Comment utiliser l'instruction Perform Till dans COBOL

Une structure de séquence est caractérisée par l'exécution d'une ou plusieurs fonctions dans un ordre spécifique. Par exemple, si vous avez plusieurs paragraphes qui doivent être exécutés dans un ordre spécifique, vous pouvez utiliser l'instruction Perform pour exécuter chaque section de logique qui est représentée par différents paragraphes. Ensuite, la structure de sélection offre un choix entre deux ou plusieurs fonctions, selon une condition donnée. Pour implémenter une structure de sélection dans COBOL, vous pouvez utiliser des constructions telles que la déclaration IF-Else ou l'évaluation Evaluate. Enfin, la structure d'itération exécute à plusieurs reprises une fonction ou un bloc de code tant qu'une certaine condition est satisfaite. À titre d'exemple, le COBOL Effectue jusqu'à ce que la déclaration puisse être utilisée pour exécuter à plusieurs reprises un morceau de logique jusqu'à ce qu'une condition spécifique soit remplie.

Définition:

L'instruction Perform dans COBOL est utilisée pour déplacer le contrôle vers un paragraphe, une section ou une procédure spécifique, soit explicitement ou implicitement. Il y a deux façons dont la déclaration de performance dans COBOL peut être divisée. La première catégorie de l'instruction Perform dans COBOL est la déclaration «en ligne», tandis que la deuxième catégorie est la déclaration de performance «contour».

La principale distinction entre une instruction en ligne et un aperçu de performance est qu'une instruction en ligne de performance exécute le code ou les commandes entre «performance» et «et performant», tandis qu'une instruction PERFOT REFORM. Un exemple d'instruction en ligne de performance est «Effecter jusqu'à l'instruction» où les instructions à l'intérieur du bloc performant sont exécutées jusqu'à ce que l'instruction à l'intérieur du bloc «jusqu'à» soit vraie. En revanche, l'instruction OUTLINE PERCOT est principalement utilisée pour exécuter un ensemble d'instructions ou de logique qui est incluse dans un paragraphe ou une section distinct. Un exemple d'une instruction PERFOT ENTERNE.

Effectuer des variantes de déclaration:

Différentes variantes de la déclaration de COBOL PERCULTES sont les suivantes:

• Effectuer… Nom du paragraphe
• Exécuter…
• Effectuer… jusqu'à la phrase
• Effectuer… une phrase variable

Dans cet article, nous ne discutons que de la performance… jusqu'à la phrase en détail.

Exemple de programmation 1:

Division d'identification.
Programme de programme. Jusqu'à la performance.
Division de l'environnement.
Section d'entrée-sortie.
Contrôle de fichier.
Sélectionnez des employés-doc
Attribuer à '/ home / papan / bureau / emp.dat '
L'organisation est séquentielle de ligne.
Division des données.
Section de dossier.
Section de stockage de travail
01 WS-DOC-SW PIC X (01) Valeur 'N'.
88 Not-eof Value 'n'.
Division des procédures.
Effectuer une lecture de A000 jusqu'à ce que non-EOF
Effectuer jusqu'à ce que non-EOF
Lecture des employés-doc
Termes finaux.
Stop run.
A000-lecture.

Sortir:

Papan @ Papan-VirtualBox: ~ / Desktop / Jusqu'à $ cobc -xjf 1.cbl
Bonjour le monde

Explication:
Un exemple de déclaration de performance est une instruction «Effectuer A000-Read jusqu'à» où le code à l'intérieur du paragraphe A000 Read est exécuté à plusieurs reprises jusqu'à un indicateur qui indique la fin du fichier (EOF).

La logique du paragraphe continue de lire les données du fichier jusqu'à ce qu'il ne reste plus d'enregistrements dans le fichier. Cela signifie l'indicateur lorsque la fin du fichier (EOF) est définie. La deuxième instruction de ce programme COBOL en ligne particulier est effectué lorsque vous spécifiez les logiques de performance et de fin. Ce que nous avons fait dans ce cas, c'est que nous avons spécifié le fichier «LAGIQUE DE LEA. Ainsi, la logique dans le paragraphe continue d'être exécutée jusqu'à la fin de l'indicateur de fichier ne soit pas définie.

Exemple de programmation 2:

Division d'identification.
Programme de programme. Interpréter3.
AUTEUR. Papan.
Division de l'environnement.
Division des données.
Section de stockage de travail.
77 WS-I PIC 9 (1) Valeur 1.
Division des procédures.
Effectuer 1000-matt jusqu'à WS-I> 5
Stop run.
1000-parcar.
Calculer ws-i = ws-i + 1
Afficher «ici cobol montrant performant jusqu'à» ws-i.

Sortir:

Papan @ Papan-VirtualBox: ~ / Desktop / Jusqu'à $ cobc -xjf 2.cbl
Ici cobol montrant performant jusqu'à 2
Ici cobol montrant performant jusqu'à3
Ici cobol montrant performant jusqu'à 4
Ici cobol montrant performant jusqu'à 5
Ici cobol montrant performant jusqu'à 6

Explication:
Ici, nous utilisons la commande appelée «jusqu'à». Nous déclarons la variable et passons certaines valeurs chaque fois que nous voulons utiliser une condition. Ensuite, nous utilisons la commande.

Ici, nous utilisons jusqu'à ws-i> 5. Sur la base de cette condition, nous appelons le paragraphe «ici cobol afficher jusqu'à». C'est ainsi que ce programme est exécuté.

Exemple de programmation 3:

Division d'identification.
Programme de programme. Jusqu'à la performance.
Division de l'environnement.
Division des données.
Section de stockage de travail.
01 WS-A PIC 9 (3) Valeur zéro.
01 WS-B PIC 9 (3) Valeur zéro.
01 k pic 9 valeur zéro.
Division des procédures.
Déplacer 1 à k.
Effectuez l'accept-plaar jusqu'à K> 2.
Stop run.
Accepter.
Acceptez WS-A.
Acceptez WS-B.
Effectuer un affichage.
Étalage.
Afficher WS-A.
Afficher WS-B.
Calculer k = k + 1
Stop run.

Sortir:

Papan @ Papan-VirtualBox: ~ / Desktop / Jusqu'à $ cobc -xjf 3.cbl
dix
12
010
012

Explication:
Dans la performance jusqu'à la condition, le paragraphe est exécuté lorsque la condition est fausse et qu'elle sort du paragraphe lorsque la condition devient vraie.

Ici, nous utilisons trois variables qui sont WS-A, WS-B et K. Dans la division des procédures, nous passons 1 à la variable k. Ensuite, nous appelons l'accept-parar. Ici, nous devons ajouter une condition qui est jusqu'à K> 2. Cela signifie que si la valeur de k est supérieure à 2, ce paragraphe est appelé. La sortie montre WS-A, WS-B. Ensuite, cette valeur de k augmente de 1 et la valeur de k = 2. Cela signifie que cette condition est vérifiée pour la valeur de k = 2. Si la condition est fausse, ce sera à nouveau d'accepter-Parar.

Conclusion

Ici, nous sommes en mesure de comprendre tous les aspects et la syntaxe de la commande performant jusqu'à COBOL pour comprendre cette commande. Nous avons effectué quelques exemples de programmation. Avec l'aide de ces exemples de programmation, nous sommes en mesure de surveiller cette commande et de comprendre comment cela fonctionne dans le domaine réel.