Existe-t-il un moyen de faire des tableaux associatifs dans REXX?

Question

J'ai un peu de code Perl (pour l'analyse des performances) d'abord développé sous Linux qui doit maintenant être porté sur le mainframe. Apparemment, REXX est le langage de script de choix sur cette plate-forme, mais ce script Perl repose fortement sur des tableaux associatifs (essentiellement des tableaux où l'index est une chaîne).

Existe-t-il un moyen pour REXX? Comment puis-je coder quelque chose comme:

$arr{"Pax"} = "Diablo"; 
$arr{"Bob"} = "Dylan"; 
print $arr{"Pax"} . "\n"; 
if (defined $arr{"no"}) { 
     print "Yes\n"; 
} else { 
     print "No\n"; 
} 

Answer 1

Vous pouvez utiliser des variables souches, pas exactement comme des tableaux, mais très similaire

/* REXX */ 
NAME = PAX 
ARRAY.NAME = "DIABLO" 
NAME = BOB 
ARRAY.NAME = "DYLAN" 
NAME = 'PAX' 
SAY "ARRAY.PAX " IS ARRAY.NAME 
NAME = 'BOB' 
SAY "ARRAY.BOB " IS ARRAY.NAME 
NAME = 'SANDY' 
SAY "ARRAY.SANDY " IS ARRAY.NAME 
IF ARRAY.NAME = "ARRAY.SANDY" THEN SAY "ARRAY.SANDY IS EMPTY" 

ci-dessus Rexx imprimera

ARRAY.PAX IS DIABLO 
ARRAY.BOB IS DYLAN 
ARRAY.SANDY IS ARRAY.SANDY 
ARRAY.SANDY IS EMPTY 

Ils peuvent aussi être composé comme abc Une variable de tige si vide retournera elle-même. Il n'y a aucun moyen d'itérer d'une racine qui n'utilise pas de nombres consécutifs comme indice que je connais.

IBM Manual with reference to Stem variables

Perl est disponible en tant que fonctionnalité supplémentaire gratuit pour ZOS IBM Ported Tools for z/OS

Answer 2

Je veux juste ajouter un peu plus à la réponse donnée par Deuian. Je suis d'accord, les variables de racine REXX sont la réponse.

Les variables REXX simples ont leur propre nom par défaut. Par exemple:

/* REXX */ 
SAY X 

imprimera "X" jusqu'à ce que X est attribué une autre valeur:

/* REXX */ 
X = 'A' 
SAY X 

imprimera "A".

Pas de grande surprise jusqu'à maintenant. Les variables de la tige sont un peu différentes. La tête de la tige n'est jamais évaluée, seul le bit après le point initial est.

À titre d'illustration:

/* REXX */               
X. = 'empty' /* all unassigned stem values take on this value */ 
A. = 'nil' 
B = 'A'  /* simple variable B is assigned value A */              
X = 'A'  /* simple variable X is assigned value A */              
SAY X.A  /* prints: empty */         
X.A = 'hello' /* Stem X. associates value of A with 'hello' */ 
SAY X.A  /* prints: hello */         
SAY X.B  /* prints: hello */         
SAY X.X  /* prints: hello */         

Notez que le X et les noms A souches ne sont pas évaluées, cependant, les X et A variables apparaissant après eux sont. Certaines personnes trouvent cela un peu déroutant - pensez à cela pendant un certain temps et cela fait beaucoup de bon sens.

La version Z/OS de REXX ne fournit pas un moyen naturel d'itérer sur une variable racine. La façon la plus simple de le faire est de créer votre propre index. Par exemple:

/* REXX */ 
X. = '' 
DO I = 1 TO 10 
    J = RANDOM(100, 500) /* Random # 100..500 */ 
    X.INDEX = X.INDEX J /* concatinate J's with 1 space between */ 
    X.J = 'was picked' /* Associate 'was picked' with whatever J evalauates to */ 
    END 

DO I = 1 TO WORDS(X.INDEX) /* Number of blank delimited 'words' */ 
    J = WORD(X.INDEX, I)  /* Extract 1 'word' at a time */ 
    SAY J X.J    /* Print 'word' and its associated value */ 
    END 

assez trivial, mais illustre l'idée. Assurez-vous simplement que INDEX (ou quel que soit le nom que vous choisissez ) pour conserver les noms d'indexation n'apparaît jamais comme une valeur associative! Si c'est une possibilité, utilisez une autre variable pour contenir l'index.

Dernier point. Notez que chacun de mes exemples commence par /* REXX */ vous pouvez trouver que cela doit être la première ligne de vos programmes REXX sous Z/OS.