C'è un modo per fare array associativi in ​​REXX?

Question

Ho qualche codice Perl (per l'analisi delle prestazioni) per primo ha sviluppato sotto Linux, che deve ora essere portato al mainframe. A quanto pare REXX è il linguaggio di scripting di scelta su quella piattaforma, ma questo script Perl si basa fortemente su array associativi (in pratica le matrici dove l'indice è una stringa).

C'è un modo che nella REXX? Come direbbe codice che ho qualcosa di simile:

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

Answer 1

È possibile utilizzare arginare le variabili, non esattamente come gli array, ma molto simile

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

È possibile che questo Rexx stamperà

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

Si può anche essere composto come a.b.c Una variabile stelo vuote tornerà stessa. Non v'è alcun modo per iterare di uno stelo che non utilizza i numeri consecutivi come l'indice, che io sappia.

IBM manuale con riferimento alle staminali variabili

Perl è disponibile come funzione gratuita extra per ZOS IBM portati su Tools per z / OS

Answer 2

voglio solo aggiungere un po 'di più per la risposta data da Deuian. Sono d'accordo, le variabili REXX staminali sono la risposta.

variabili REXX Semplici predefinito a proprio nome. Ad esempio:

/* REXX */
SAY X

stamperà "X" fino X viene assegnato un altro valore:

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

stamperà "A".

Nessun grande sorpresa finora. variabili staminali sono un po 'diverso. Il testa dello stelo non viene mai valutata, solo il bit dopo il punto iniziale è.

Per illustrare:

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

Avviso nomi del X e lo stelo A non vengono valutati, però, il X e A variabili che compaiono dopo di loro sono. Alcune persone trovano questo un po 'di confusione - pensarci per un po' e si fa grande senso.

La versione di z / OS di REXX non fornisce un modo naturale per iterare su una variabile stelo. Il modo più semplice per farlo è quello di costruire il proprio indice. Ad esempio:

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

piuttosto banale, ma illustra l'idea. Basta essere sicuri che INDEX (o qualsiasi altra cosa è il nome scegliere) per contenere i nomi di indicizzazione non si apre come un valore associativo! Se questa è una possibilità, utilizzare qualche altra variabile per contenere l'indice.

Ultimo punto. Si noti ciascuno dei miei esempi inizia con /* REXX */ si possono trovare che questo deve essere la prima linea di programmi REXX con z / OS.