informatica

1. 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.
Arrays en Powerbuilder 11.5
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 NiklausWirth, 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.
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.
"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:

2. integerli_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 tamaños variables:
- Array de enteros:
integerli_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
stringls_ciudades[ ]
Arrays de tamaños fijos:
- Array de tres números enteros:
integerli_codigoprod[3]

3. - Array de 7 tiras de caracteres o strings.
stringls_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
integerli_calidad[0 to 2]
- Array de 5 tiras de caracteres o strings
stringls_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
integerli_year[76 to 96]
- Array de 26 tiras de caracteres o strings
stringls_nombres[-10 to 15]
MAL uso de Arrays de Rangos o Arrays Inválidos
integerli_conteos[10 to 5] // Es inválido puesto que 10 es más grande que 5.
integerli_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.

4. 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:
integerli_puntaje[2,3] // Se lee: Array entero de 2 dimensiones con 3 elementos cada una
- Array de dos dimensiones pero especificando rangos de elementos
integerli_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:
longll_fechas[3, 300, 50]
- Otros ejemplos:
stringls_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
Cuando definimos un arrayPowerbuilder lo inicializa en según el tipo de dato.
¿Como inicializa el sistema cada tipo de variable?

5. 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:
integerli_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:
integerli_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

6. 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.
+++++++++++
Arreglo bidimensionales
en PowerBuilder
12 abr 2013 | PowerBuilderBasico · Taller en PowerBuilder
Tags: Arreglos · PowerBuilder
Arreglo:
En programación, una matriz o vector (llamados en inglés arrays) es una zona de
almacenamiento contiguo, que contiene una serie de elementos del mismo tipo. De esta
forma en PowerBuilderusando el lenguaje Power Script podemos realizar este tipo de
procesos, usando a la memoria RAM para que los datos ingresados queden grabados de
manera volátil en un instante. Para nuestra implementación, realizaremos un programa en la
herramienta PowerBuilder donde se pueda detallar toda esta teoria.
Laboratorio:
Creamos un Espacio de trabajo wrk_arreglo, una aplicación app y diseñamos las siguientes
dos ventanas:
w_listado : Controles: DropDownListBox (lb_nombres, lb_edad), commandbutton
(cb_registrar, cb_cerrar)

7. w_datos:

8. Luego declaramos en la parte Instancia el siguiente código:
w_listado :cb_registrar
w_listado :cb_cerrar
w_listado :
lb_nombres evento: SelectionChanged

9. w_listado :lb_edad evento: SelectionChanged
w_listado : Evento OPEN
w_datos :cb_guardar
w_datos :cb_cancelar

10. Explicación:
Bien, el siguiente programa expuesto tendra el siguiente comportamiento: Al abrir en
primer lugar w_listado, nos saldra una ventana donde no nos mostrara nada, tenemos que
darle en el botonregistrar para que nos abra la ventana: w_datos, donde recien podemos
dar algunos valores que nos piden, de esta forma nuestro arreglo ira creciendo, como
tambiensubira su indice: gi_pos.
En este caso estamos usando el control lista para detallar los datos ingresados, el control
lista tiene como metodo: additem, el cual te permite agregar valores cadena a la lista. Es por
eso que al hacer el for, tenemos que convertir la edad que esta en numero a cadena.
Puede descargar el ejemplo en PB 11.5, en el siguiente enlace: