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

Question

Ich habe einige Perl-Code (für die Leistungsanalyse) zunächst unter Linux entwickelt, muss nun an den Mainframe portiert werden. Offenbar REXX ist die Scripting-Sprache der Wahl auf dieser Plattform, aber die Perl-Skript, stützt sich stark auf assoziative Arrays (im Grunde Arrays, bei denen der Index ein String).

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

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

Answer 1

Sie können Variablen verwenden, stammen, nicht genau wie Arrays, 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"

Das oben gezeigte Rexx druckt

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

Sie können auch Verbindung wie a.b.c sein Eine Stamm Variable, wenn leer wird selbst zurück. Es gibt keine Möglichkeit zu Iterierte von einem Stamm, der nicht fortlaufende Nummern wie der Index nicht verwendet, die ich kenne.

IBM Handbuch mit Referenzvariablen auf Stem

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

Answer 2

Ich will nur ein bisschen mehr auf die Antwort von Deuian gegeben hinzuzufügen. Ich bin damit einverstanden, REXX Stamm Variablen ist die Antwort.

Einfache REXX-Variablen auf ihren eigenen Namen Standard. Zum Beispiel:

/* REXX */
SAY X

druckt "X" bis X einen anderen Wert zugeordnet:

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

druckt "A".

Keine große Überraschung so weit. Stem Variablen ist ein bisschen anders. Das Kopf des Stiels wird nie, nur das Bit nach dem ersten Punkt bewertet 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 der A Stamm Namen nicht ausgewertet werden, jedoch die X und A Variablen nach ihnen erscheinen, sind. Einige Leute finden diese ein etwas verwirrend - denken sie für eine Weile und es macht großer Sinn.

Die Z / OS Version von REXX bietet keine natürliche Art und Weise zu iterieren eine Stammvariable. Der einfachste Weg dies zu tun ist, Ihren eigenen Index zu bauen. 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

Pretty trivial, aber zeigt die Idee. Nur sicher sein, dass INDEX (oder was auch immer Sie nennen wählen), den Index-Namen zu halten nie als assoziativer Wert erscheint! Wenn dies eine Möglichkeit ist, verwenden Sie eine andere Variable, um den Index zu halten.

Letzter Punkt. Beachten Sie jede meiner Beispiele beginnt mit /* REXX */ Sie finden dass diese Anforderungen die erste Zeile Ihrer REXX Programme unter Z / O sein.