lunes, marzo 27, 2017

VFP: Algunas formas de usar los arrays

Los arrays son una colección de elementos muy útil y versátil en cualquier lenguaje, que a diferencia de los cursores o tablas permiten también almacenar objetos o referencias a los mismos.

En Visual FoxPro el uso de los arrays conviene mantererlo controlado en cuanto a tamaño, ya que por encima de algunos cientos de elementos, las búsquedas sobre un array comienzan a ponerse lentas. Por eso, para grandes tamaños siempre conviene usar cursores o tablas.



Definición y dimensionamiento


Hay dos tipos de arrays: en forma de variable y en forma de propiedad, ambos usan la misma sintaxis, pero solo se diferencian en la forma de declararse o en dónde se declaran.

Por ejemplo, como variable un array se puede definir de estas formas:

LOCAL laLista(1), laTabla(1,1)  && Se definen y dimensionan en un paso

Y luego se pueden redimensionar así:

DIMENSION laLista(10), laTabla(4,2)

Para una clase, usando el cuadro de diálogo de agregar propiedad (ej.en un form: menú form/New property), lo mismo de antes se define como laLista[1] y luego otra propiedad nueva como laTabla[4,2]

Luego, para redimensionar las propiedades se hace lo mismo, pero indicando el nombre del objeto:

DIMENSION thisform.laLista(10), thisform.laTabla(4,2)

Hay una sintaxis adicional cuando se requiere agregar un array que no sea posible poner en diseño, que es usando AddProperty:

AddProperty( thisform, "laLista[1]" )



Asignación de valores


Para asignar valores, se hace como cualquier variable o propiedad:

laLista(1) = 100
laLista(2) = CREATEOBJECT("custom")
laLista(3) = "Texto"

thisform.laLista(1) = 100
...



Redimensionamiento


Para redimensionar un array se usa el mismo comando que para definirlo, DIMENSION. Solo hay que tener en cuenta algunos casos:

- Para agrandar un array bidimensional con datos, solo se pueden agregar filas, no columnas, ya que si se agregan columnas (técnicamente posible) se distribuirán los datos existentes para usar las nuevas columnas, lo que hará que ya no estén en sus ubicaciones originales. En este caso conviene copiar de un array a otro nuevo con las columnas que se requieran.

- Para achicar un array, conviene hacerlo desde abajo hacia arriba, o sea, desde el índice mayor al menor

Para ejemplificar la eliminación de elementos, algunos habrán intentado hacerlo así:

lnFilas =  ALEN(laLista)
FOR I = 1 TO lnFilas
   ADEL(laLista, I) 
   lnFilas = lnFilas - 1
   DIMENSION laLista(lnFilas)
ENDFOR

El código anterior tiene el problema de que al llegar a la mitad del array, ocurrirá un error porque se estará intentando borrar (ADEL) un elemento cuyo índice supera la cantidad de elementos, y es por eso que esto debe hacerse en orden inverso:

lnFilas =  ALEN(laLista)
FOR I = lnFilas TO 1 STEP -1
   ADEL(laLista, I) 
   lnFilas = lnFilas - 1
   DIMENSION laLista(lnFilas)
ENDFOR

Si bien el algoritmo anterior no tiene sentido para cuando se quieren borrar todos los elementos, porque es mucho más rápido hacer un DIMENSION laLista(1) y luego laLista = "", es la forma correcta de borrar elementos intermedios.



Caso especial de uso


Normalmente los arrays se usan para listas de valores conocidos, como nombres de ciudades, paises y selecciones en general, pero hay un caso especial que requiere una forma distinta de manipular el array, que es cuando no se sabe con antelación cuántos elementos tendrá el array, pero es necesario tenerlo predefinido con un elemento.

El problema se presenta cuando se quiere agregar un elemento nuevo, ya que normalmente se usa ALEN() para saber cuantos tiene y agregar uno nuevo, pero ALEN() devolverá siempre como mínimo 1 y es posible que ese elemento tenga valor, o no, y no siempre es posible usar EMPTY() para controlar si hay un dato, porque un 0 o una cadena vacía podría ser el dato...

¿Cómo controlar esa situación? Para eso se puede usar un contador de elementos:

lnFilasLista = 0
DIMENSION laLista(1)

Y luego, cuando se va a agregar un nuevo elemento, simplemente se incrementa y redimensiona a la par:

lnFilasLista  = lnFilasLista + 1
DIMENSION laLista(lnFilasLista)
laLista(lnFilasLista) = "nuevo valor"


La siguiente es una técnica que define una API para interactuar con el array anterior, donde se encapsulan las operaciones de dimensionar y agregar valores. En este caso lo defino como una clase instanciable, pero los métodos bien podrían ponerse directamente en un form u otra clase.

Este es un ejemplo de uso:

loArrayMgr = createobject("cl_ArrayMgr") 
loArrayMgr.Add("un valor")
loArrayMgr.Add("otro valor")
loArrayMgr.Add("un valor más")
? loArrayMgr.Length
3
loArrayMgr.Delete(2)
? loArrayMgr.Datos(2)
"Un valor más"
? loArrayMgr.Length
2

Y la clase podría definirse así en un PRG o visualmente en la clase que se requiera:

DEFINE CLASS cl_ArrayMgr AS Custom
   DIMENSIO aDatos[1]
   nDatos = 0 

   FUNCTION Length
      RETURN THIS.nDatos
   ENDFUNC

   PROCEDURE Add(tuValor)
      THIS.nDatos = THIS.nDatos + 1
      DIMENSION THIS.aDatos(THIS.nDatos)
      THIS.aDatos(THIS.nDatos) = tuValor
   ENDPROC

   PROCEDURE Delete(tnElemento)
      IF THIS.nDatos > 1 AND tnElemento <= THIS.nDatos
         ADEL(THIS.aDatos, tnElemento)
         THIS.nDatos = THIS.nDatos - 1
         DIMENSION THIS.aDatos(THIS.nDatos)
      ENDIF
   ENDPROC
ENDDEFINE


Sobre este ejemplo se pueden hacer variaciones y mejoras, pero creo que se entiende la idea de cómo manipular un array en las condiciones comentadas.


Hasta la próxima! :D

No hay comentarios:

Publicar un comentario