¿Hay alguna manera de hacer arreglos asociativos en REXX?

Question

Tengo un código Perl (para análisis de rendimiento) desarrollado por primera vez bajo Linux que ahora necesita ser portado al mainframe. Aparentemente REXX es el lenguaje de scripting de elección en esa plataforma, pero este script de Perl se basa en gran medida en matrices asociativas (básicamente matrices donde el índice es una cadena).

¿Hay alguna manera de que en REXX? ¿Cómo iba a codificar hasta algo como:

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

Answer 1

Se pueden utilizar variables madre, no exactamente como matrices, pero muy similar

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

Lo anterior Rexx imprimirá

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

También puede ser compuesto como abc Una variable madre si está vacía se devolverá. No hay forma de iterar de un tallo que no use números consecutivos como el índice que conozco.

IBM Manual with reference to Stem variables

Perl está disponible como una característica adicional gratis para ZOS IBM Ported Tools for z/OS

Answer 2

sólo quiero añadir un poco más a la respuesta dada por Deuian. Acepto, las variables de vástago REXX son la respuesta.

Variables REXX simples de manera predeterminada a su propio nombre. Por ejemplo:

/* REXX */ 
SAY X 

imprimirá "X" hasta X se asigna algún otro valor:

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

imprimirá "A".

Ninguna gran sorpresa hasta el momento. Las variables de Stem son un poco diferentes. El cabezal del vástago nunca se evalúa, solo el bit después del punto inicial .

Para ilustrar:

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

Aviso del X y los nombres A madre no son evaluados, sin embargo, los X y A variables que aparecen después de ellos son. A algunas personas les resulta un poco confuso , piénselo un momento y le da un gran sentido a .

La versión Z/OS de REXX no proporciona una forma natural de iterar sobre una variable de raíz. La forma más fácil de hacerlo es crear su propio índice. Por ejemplo:

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

Bastante trivial, pero ilustra la idea. Solo asegúrese de que INDEX (o el nombre que elija ) para mantener los nombres de indexación nunca aparezca como un valor asociativo. Si esto es una posibilidad, use alguna otra variable para mantener el índice.

Último punto. Observe que cada uno de mis ejemplos comienza con /* REXX */, puede encontrar que esta debe ser la primera línea de sus programas REXX en Z/OS.