Una de las variables en programación que pocas veces se utilizan por desconocimiento son los arrays, también conocidos como arreglos o matrices, aquí los llamaremos por su nombre en inglés ya que es el más común.
Si recuerdan algo de álgebra de la secundaria, tal vez tengan aún en la memoria las enseñanzas sobre "matrices"; esto es casi lo mismo, solo que aplicado a la programación.
En épocas de estudiante recuerdo del libro de Niklaus Wirth, el creador de Pascal, la definición sobre array: "consiste en un número fijo de componentes (definidos cuando se introduce el arreglo), todos del mismo tipo, al que se llama tipo de base o de los componentes... etc. " [1] pero sin embargo aquí nos vamos a refereir a los arrays en Powerbuilder y sus usos, por lo que la definición cambia un poco, o tal vez se esclarece.
Podemos decir que un array es una colección indexada de elementos de un tipo de datos simples. En PowerBuilder, un array puede tener una o más dimensiones. Los arrays de una dimensión pueden tener un tamaño fijo o variable; los array multidimensionales siempre tienen un tamaño fijo. Cada dimensión de un array puede tener 2,147,483,647 bytes de elementos.
¿Cómo se definen los arrays? - Sintaxis
{ acceso } tipo-de-dato nombre-de-la-variable { d1, ..., dn } { = { lista-de-valores } }
- "acceso": se refiere a cómo llegamos a la variable (parent, this,etc.)
- "tipo-de-dato": es el tipo de dato de la variable y puede ser cualquiera de los tipos de datos estándar, un objeto de sistema, o una estructura previamente definida. Si el tipo de dato es numérico y utilizaremos decimales, podemos especificar además la precisión de la siguiente forma:
decimal {2} nombre-de-la-variable [ ]
Donde "decimal" es la palabra reservada para indicar los mismos, el 2 es la cantidad de decimales (obligatorio dentro de llaves), "nombre-de-la-variable" es su homónimo y también es obligatorio el uso de corchetes al final para indicar que nos estamos refiriendo a un array.
{xtypo_warning}En los tipos de variables blob, colocar blobs de longitud fija dentro del array, no se puede, ya que no está soportado. Si se especifica un tamaño luego del tipo de dato en este casos, dicho tamaño es ignorado.{/xtypo_warning}
- "nombre-de-la-variable": es el identificador de la misma y podemos (debemos) usar los mismos nombres que utilizamos en los scripts, es decir, siguiendo esos lineamientos ya explicados en Prefijos en PowerBuilder. También podemos definir array del mismo tipo dentro de la misma definición separándolos con coma, ejemplo:
integer li_precioscosto [3], li_preciosventa[3]
En este caso estamos definiendo dos variables del tipo array de 3 elementos enteros.
[{ d1, ..., dn }]: Corchetes para arrays de tamaños fijos, llaves para arrays de tamaños variables. "d1,...,dn", indican cada una de las dimensiones del array. El limíte en cuanto a la cantidad de dimensiones está dado solo por la capacidad de memoria, podemos poner tantas hasta donde nos de la misma.
Para el caso de arrays de tamaño fijo también podemos especificar un rango de la forma:
[ desde-v1 TO hasta-v1, ..., desde-vn TO hasta-vn ]
Siempre el valor anterior a la palabra TO debe ser inferior al valor del posterior a dicha palabra.
- "lista-de-valores": se refiere a los valores iniciales para cada posición del array. Deben ir separados por coma y la lista completa debe estar entre llaves. La cantidad de valores no puede ser superior a la cantidad de dimensiones y el tipo de dato debe coincidir con el tipo de datos del array.
Ejemplos de definiciones de arrays
- Array de enteros:
integer li_productos[ ]
- Array de números decimales con 2 dígitos de precisión
decimal {2} ld_listaprecios[ ]
- Array del tipo blob:
blob lb_imagen[ ]
- Array de fechas:
date ld_vencimientos[ ]
- Array de tira de caracteres o strings
string ls_ciudades[ ]
Arrays de tamaños fijos:
- Array de tres números enteros:
integer li_codigoprod[3]
- Array de 7 tiras de caracteres o strings.
string ls_dias[7]
- Array de 10 variables blob (recuerden que no se puede asignar tamaño fijo)
blob ib_imagen[10]
- Array de 10 números decimales, cada uno con una precisión de 2 dígitos
dec{2} lc_costos[10]
- Array de 20 números decimales, sin indicar precisión. Al no colocar la cantidad de dígitos luego del punto decimal, los mismos tomarán la configuración global del sistema.
decimal lc_precios[20]
Array de rangos:
- Array de 4 números reales
real lr_tasas[2 to 5] // Se cuenta los items: 2,3,4,5; es decir incluye el item inicial y el final
- Array de 3 números enteros
integer li_calidad[0 to 2]
- Array de 5 tiras de caracteres o strings
string ls_avisos[-2 to 2] // Se cuentan los items: -2,-1,0,1,2; es decir se incluye el 0
- Array de 21 números enteros
integer li_year[76 to 96]
- Array de 26 tiras de caracteres o strings
string ls_nombres[-10 to 15]
MAL uso de Arrays de Rangos o Arrays Inválidos
integer li_conteos[10 to 5] // Es inválido puesto que 10 es más grande que 5.
integer li_precios[-10 to -20] // Es inválido puesto que -10 es mayor que -20
Arrays de 2 o más dimensiones
- Array de dos dimensiones y seis elementos o items.
Los elementos individuales son:
li_puntaje[1,1], li_puntaje[1,2], li_puntaje[1,3], li_puntaje[2,1], li_puntaje[2,2], li_puntaje[2,3]
Con esto podríamos asignarle un valor a cada item o elemento del array.
Para que entienda el neófito, gráficamente esto sería algo así:
│ x │ 1 │ 2 │
│ 1 │ 2 │ 3 │
La primer línea sería la primera dimensión de tres elementos (1, 2 y 3). La segunda línea, sería la segunda dimensión de tres elementos también (1, 2 y 3). (La combinación es cruzada)
La definición sería:
integer li_puntaje[2,3] // Se lee: Array entero de 2 dimensiones con 3 elementos cada una
- Array de dos dimensiones pero especificando rangos de elementos
integer li_tasas[1 to 5, 10 to 25]
Aquí la primer dimensión sería un rango de 1 a 5, es decir, de 5 elementos.
La segunda dimensión sería un rango de 10 a 25, es decir, de 15 elementos.
Lo podríamos leer así: "array de dos dimensiones con 15 elementos en cada item rango".
Gráficamente sería:
│ x │ 1 │ 2 │ 3 │ 4 │ 5 │ │ 25 │
│ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ │ 25 │
│ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ │ 25 │
│ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ │ 25 │
│ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ │ 25 │
Los azules serían los elementos de la primera dimensión, y los que están en negro, serían cada uno de los elementos de cada una de las dimensiones. En total el array contendría 75 elementos.
- Array de 3 dimensiones de 45 mil elementos:
long ll_fechas[3, 300, 50]
- Otros ejemplos:
string ls_plantas[3,10] // Array de dos dimensiones de 30 strings o tiras de caracteres
dec{2} lc_tasas[3,4] // Array de dos dimensiones de de decimales con 2 dígitos de precisión luego del punto decimal.
decimal{3} lc_primero[10], lc_segundo[15,5], lc_tercero[ ] // Definición de tres arrays de decimales
Inicialización y uso de Arrays
¿Como inicializa el sistema cada tipo de variable?
Veamos:
- Las variables del tipo string o tira de caracteres se inicializan con un string vació ("").
- Las variables de los tipos: byte, long, longlong, decimal, real, double, UnsignedInteger,UnsignedLong, se inicializan con 0 (cero).
- Las variables del tipo date (fecha) se inicializan con 1900-01-01 (es decir, 1ro. de Enero de 1900).
- Las variables del tipo datatime (fecha y hora) se inicializan con: 1900-01-01 00:00:00.
- Las variables del tipo blob se inicializan con un blob vacío.
- Las variables del tipo boolean se inicializan con "false".
- Las variables del tipo char se inicializan con el valor ASCII 0.
- Las variables del tipo time (tiempo) se inicializan con la hora de medianoche, es decir con 00:00:00.
Asimismo, podemos inicializar la variable con su valor por defecto indicado arriba o bien asignarles un valor al momento de la definición. Un ejemplo del segundo caso:
real lr_tasas[3]={1.20, 2.40, 4.80}
Aquí estamos definiendo una variable del tipo array de 3 elementos reales y a cada uno le estamos asignando el valor especificado, para el primero 1.20, para el segundo 2.40 y para el tercero 4.80.
Un poco más complicado es cuando queremos inicializar un array de dos dimensiones. Ejemplo:
integer li_unidades[3,4] = {1,2,3, 1,2,3, 1,2,3, 1,2,3}
Aquí definimos una variable del tipo array de dos dimensiones de 4 elementos enteros cada una.
El resultado sería:
Los elementos de la primera dimensión: li_units[1,1], [1,2], [1,3], y [1,4] tomarían todos el valor 1
Los elementos de la segunda dimensión: li_units[2,1], [2,2], [2,3], y [2,4] tomarían todos el valorl 2
Los elementos de la tercera dimensión: li_units[3,1], [3,2], [3,3], y [3,4] tomarían todos el valor 3
Vamos a complicar un poco más, con un array de tres dimensiones, ejemplo:
integer li_unidades[3,4,2] = {1,2,3, 1,2,3, 1,2,3, 1,2,3}
Aquí estamos definiendo una variable del tipo array de tres dimensiones con 2 elementos cada una.
│ x │ 1 │ 2 │ 3 │
│ 1 │ 2 │ 3 │ 4 │
│ 1 │ 2 │
El resultado sería:
- li_unidades[1,1,1], [1,2,1], [1,3,1], y [1,4,1] todos tomarían el valor 1
- li_unidades[2,1,1], [2,2,1], [2,3,1], y [2,4,1] todos tomarían el valor 2
- li_unidades[3,1,1], [3,2,1], [3,3,1], y [3,4,1] todos tomarían el valor 3
- li_unidades[1,1,2], [1,2,2], [1,3,2], y [1,4,2] todos tomarían el valor 0
- li_unidades[2,1,2], [2,2,2], [2,3,2], y [2,4,2] todos tomarían el valor 0
- li_unidades[3,1,2], [3,2,2], [3,3,2], y [3,4,2] todos tomarían el valor 0
En la próxima veremos usos concretos de arrays, esto es solo una introducción. Constituyen una de las herramientas más poderosas de programación y es más que útil conocerlas a fondo.
[1] Pascal, Manual del Usuario e Informe - Kathleen Jensen y Niklaus Wirth, Editorial El Atenero, 2da. edición, Año 1984. [Volver]