Est-il possible de faire des tableaux associatifs en REXX?

Question

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

Est-il possible que REXX? Comment coderez je place 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 similaires

/* 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"

Le ci-dessus Rexx imprimera

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

Ils peuvent également être composé comme a.b.c Une variable tige si vide va se retourner. Il n'y a pas moyen d'itérer d'une tige qui n'utilise pas des numéros consécutifs comme l'indice que je connaisse.

IBM manuel avec référence aux souches des variables

Perl est disponible en option sans supplément pour ZOS Outils IBM Ported pour z / OS

Answer 2

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

Simple variables REXX par défaut à leur propre nom. 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 à ce jour. variables souches sont un autre bit. le la tête de la tige est jamais évaluée, seul le bit après le point initial est.

Pour illustrer:

/* 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 les X et les noms souches A ne sont pas évaluées, cependant, la variables X et A apparaissant après eux sont. Certaines personnes trouvent cette peu déroutant - penser pendant un certain temps et il fait grand sens.

La version Z / OS de REXX ne fournit pas un moyen naturel de itérer sur une variable de tige. La meilleure façon de le faire est de construire votre propre indice. 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 tout ce que vous nommez choisir) pour contenir les noms d'indexation pops jamais comme une valeur associative! Si cela est possible, utiliser une autre variable pour contenir l'index.

Le dernier point. Remarquez 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.