Gibt es eine Möglichkeit, assoziative Arrays in REXX zu tun?

Question

Ich habe einige Perl-Code (für Performance-Analyse) zuerst unter Linux entwickelt, die jetzt auf den Mainframe portiert werden muss. Anscheinend ist REXX die Skriptsprache der Wahl auf dieser Plattform, aber dieses Perl-Skript ist stark auf assoziative Arrays angewiesen (im Grunde Arrays, bei denen der Index ein String ist).

Gibt es eine Möglichkeit, dass in REXX? Wie würde ich Code auf so etwas wie:, nicht genau wie Arrays

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

Answer 1

Sie Stamm Variablen verwenden können, aber sehr ähnlich

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

Die oben Rexx

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

gedruckt werden Sie können auch sei compound wie abc Eine Stammvariable wenn leer wird sich selbst zurückgeben. Es gibt keine Möglichkeit, einen Stamm zu iterieren, der keine fortlaufenden Zahlen als den mir bekannten Index verwendet.

IBM Manual with reference to Stem variables

Perl ist als zusätzliche kostenlose Funktion für ZOS IBM Ported Tools for z/OS

Answer 2

Ich will nur ein bisschen mehr auf die Antwort von Deuian gegeben hinzuzufügen. Ich stimme zu, REXX Stamm Variablen sind die Antwort.

Einfache REXX-Variablen haben standardmäßig ihren eigenen Namen. Zum Beispiel:

/* REXX */ 
SAY X 

druckt "X" bis X einen anderen Wert zugeordnet:

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

gedruckt wird "A".

Keine große Überraschung bisher. Stammvariablen sind ein bisschen anders. Der Kopf des Vorbaus wird nie ausgewertet, nur das Bit nach dem ursprünglichen Punkt ist.

Zur Veranschaulichung:

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

Beachten Sie die X und die A Stamm Namen nicht ausgewertet werden, jedoch die X und A Variablen nach ihnen erscheinen, sind. Einige Leute finden das ein bisschen verwirrend - denken Sie darüber für eine Weile nach und es macht großen Sinn.

Die Z/OS-Version von REXX bietet keine natürliche Möglichkeit, über eine Stammvariable zu iterieren. Der einfachste Weg ist, einen eigenen Index zu erstellen. Zum Beispiel:

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

recht trivial, aber zeigt die Idee. Seien Sie einfach sicher, dass INDEX (oder was auch immer Sie wählen), um die Indexnamen zu halten nie erscheint als assoziativer Wert! Wenn dies möglich ist, verwenden Sie eine andere Variable, um den Index zu halten.

Letzter Punkt. Beachten Sie, dass jedes meiner Beispiele mit /* REXX */ beginnt. Sie finden , dass dies die erste Zeile Ihrer REXX-Programme unter Z/OS sein muss.