Histórico da Página

Un array se puede definir como un conjunto de datos relacionados, llamados de elementos, almacenados con un mismo nombre y se identifican así como se acceden por medio de un índice numérico. En cada uno de estos elementos se pueden almacenar cualquier tipo de datos, excepto campos memo. Incluso, un elemento de un array puede contener una referencia para otros array o bloque de código.

Cada uno de los elementos de un array se identifica por el nombre del mismo y, entre corchetes, por su índice. Por ejemplo, considere un array llamado Tabla, formado por 5 líneas y 8 columnas, de acuerdo con lo el siguiente esquema.

El array Tabla se clasifica como una matriz de dos dimensiones 5 x 8, ya que tiene cinco líneas y ocho columnas. En el esquema se presentan los índices que identifican cada uno de sus elementos. Por ejemplo, el elemento ubicado en la tercera línea de la quinta columna se identifica por el índice 3,5. El elemento ubicado en la segunda línea de la octava columna se identifica por el índice 2,8. Y así por delante. Los índices siempre son números enteros.

En el AdvPL, un array se accede por medio de una referencia. Es decir, una dirección de la memoria en la que está ubicado el array y por medio de la cual se puede acceder. Cuando se crea un array, se le atribuye un nombre para esta referencia, que pasa a identificar el array.

Matrices Multidimensionales

Matrices multidimensionales se implementan en el AdvPL por medio de conjuntos de submatrices unidimensionales intercaladas. En esta arquitectura, cada elementos de una matriz puede contener un datos o entonces una referencia para otra matriz. Veamos el siguiente ejemplo:

aFuncion := { "Marcos", 42, .T. }      
// Array unidimensional con las siguientes informaciones:  
//Nombre del empleado, Edad e indicación si es CLT (Empleado fijo)

Sin embargo, uno de los elementos pueden ser las informaciones de los dependientes del empleado. En este caso, la estructura del array será:

aFuncion := { "Marcos", 42, .T., aDepend }

Donde la estructura del array aDepend será el Nombre del Dependiente, grado de parentesco, Sexo:

aDepend := 	{ { "Cláudia", 1, 35, "F" };
		{ "Rian", 2, 7, "M" } }

Esta arquitectura del AdvPL permite que matrices multidimensionales puedan ser asimétricas. Esto ocurre cuando una de las matrices intercaladas tiene un número diferente de elementos de las otras matrices del mismo nivel o de la matriz en la que está insertada. Supongamos que se haya incluido el RCPF    en el array de dependientes:

aDepend := 	{ { "Cláudia", 1, 35, "F", "27847307849" };
		{ "Rian", 2, 7, "M", "16668978119" } 

En este ejemplo, el array aFuncion contiene 4 elementos en su estructura, mientras que el array aDepend contiene 5 elementos.

En vez de hacer referencia a otro array, las informaciones de los dependientes también se pueden grabar directamente en el array aFuncion, como uno de sus elementos.

aFuncion := 	{ "Marcos", 42, .T., { { "Cláudia", 1, 35, "F", "27847307849" },;
		{ "Rian", 2, 7, "M", "16668978119" }    } }

Creación de los Array

La declaración de los array se realiza por medio de los mismos comandos de las variables de los demás tipos de datos. PRIVATE, PUBLIC, LOCAL y    STATIC.

El  array se puede crear con un tamaño definido o no. Si no se crea con un tamaño definido previamente, sus dimensiones se definen durante la ejecución del programa. Veamos el siguiente ejemplo:

aExemp1 := { 10, 20, 30, 40, 50 }
aExemp2 := { "Clipper", aExemp1[3] + aExemp1[5], SQRT(a[1]), 1 + aExemp1[2] }

El siguiente ejemplo es exactamente equivalente al anterior:

aExemp3 := { { 1, 2, 3 }, { "A", "B", "C" }, { .F., DATE(), .F. } }

Si los elementos del array se mostraran al usuario en la pantalla, tendríamos los siguientes valores:

MSGALERT(aExemp3[1, 1])     // Resultado: 1
MSGALERT(aExemp3[2, 1])     // Resultado: "A"
MSGALERT(aExemp3[3, 3])     // Resultado: .F.

La función ARRAY() se utiliza para crear arrays con dimensiones definidas. Las dimensiones del array que se creará se especifican como argumentos de la función ARRAY(). Ejemplo:

LOCAL    aTabela := ARRAY(5, 10)

En este ejemplo, se creó un array con 5 líneas y 10 columnas.

Un array vacío se define como si fuera una matriz sin elementos. Para crear un array vacío, se utiliza la siguiente instrucción:

LOCAL    aTabela := { }

Los array vacíos son útiles cuando no se sabe, inicialmente, el número de elementos que éstos tendrán. Posteriormente, se podrán utilizar las

funciones AADD() y ASIZE() para cambiar su estructura, agregando el número de elementos que sean necesarios para el procesamiento de la rutina.

Para probar si un array existe o fue creado, se utiliza la función VALTPE(), que suministrará "A" si su argumento es un array. Por ejemplo:

LOCAL    aTabela := { }
	IF    VALTYPE(aTabela) == "A" 
		MSGALERT("Es un array")
	ENDIF

Para probar si un array está vacío, es decir, no tiene elementos, se utiliza la función EMPTY(), de acuerdo con el siguiente ejemplo:

IF    EMPTY(aTabela)
	MSGALERT("O array está vacío")
ENDIF

PRIVATE    aTabela[5,8]     // Crea la matriz aTabela

Cuando se crea un array sin los valores definidos, cada uno de sus elementos tiene el valor NIL   atribuido. Este valor persiste hasta que los elementos se inicien con otros valores. El siguiente ejemplo, demuestra la atribución de diversos datos en algunos elementos del array aTabela.

aTabela[1,1] 	:= 100     // Equivale à aTabela[1][1] := 100
aTabela[2][3] 	:= "AdvPL"
aTabela[5,4] 	:= DATE()
aTabela[2][2] 	:= .T.
aTabela[3,3] 	:= aTabela[1,1] * 2
aTabela[4,4] 	:= SQRT(aTabela[1,1])

Los índices que identifican los elementos de un array son siempre números enteros y comienzan con el número 1. Los índices atribuidos a los elementos de un array deber ser compatibles con sus dimensiones y con el número de elementos de cada dimensión. Si esto no ocurre, se generará un error durante la ejecución del programa. Por ejemplo:

aTabela[6,1] := 1

La atribución anterior causará un error, pues el array aTabela posee sólo 5 líneas.

El AdvPL también permite crear e iniciar un array con base en la estructura de una tabla de datos y de las informaciones de una carpeta de archivos contenidos en el servidor. Los respectivos comandos (DBSTRUCT y DIRECTORY) están descritos en el tópico Funciones.

La función AFILL() está especialmente destinada a iniciar los elementos de los array de una sola dimensión con un determinado dato. Por ejemplo:

LOCAL aVetor[20]
AFILL(aVetor, SPACE(10), 1, 10)	
// Inicia los 10 primeros elementos del array unidimensional aVetor con diez espacios en blanco.
AFILL(aVetor, 0, 11, 20)      	
// Inicia los 10 últimos elementos del array unidimensional aVetor con el valor numérico cero.

Los elementos de un array se pueden iniciar con el resultado de cualquier expresión válida del AdvPL y con cualquier tipo de dato, incluso bloques de código y referencias a otros array. Una vez iniciados, los elementos de un array se pueden utilizar como si fueran variables.

Como en el  AdvPL se puede atribuir una referencia a un array para un elemento de otro array, la estructura del array que ya existe se puede modificar dinámicamente durante la ejecución del programa. Por ejemplo:

PRIVATE aTabela[5,5]     		// El array se ha creado con 5 líneas y 5 columnas.

aTabela[1, 1] := { 10, 20, 30, 50, 80 }	// La estructura del array se modificó en el momento de la ejecución.

Si se muestra el contenido del elemento aTabela[1, 1, 5], aparecerá el contenido 80

Mientras tanto, si se intenta mostrar el contenido de los siguientes elementos, ocurrirá un error, pues no existen estos elementos en la estructura del array:

aTabela[1, 2, 1]
aTabela[2, 1, 1]

Analizando este ejemplo, las tres dimensiones tienen validez sólo para el elemento aTabela[1, 1], ya que el mismo pasó a contener una referencia a otro array con una dimensión. Este poderoso recurso del AdvPL, permite que se aprovechen recursos increíbles de programación. Así mismo, como la estructura de un array puede cambiar dinámicamente, se debe tomar cuidado para utilizarla, puesto que existe el riesgo de perder totalmente el control de una aplicación, volviéndola confusa y susceptible a errores.

Utilización de los array como parámetros de rutinas

Los array se pueden pasar como argumentos para funciones. Cuando el paso se realiza por medio de la sintaxis de las funciones, los array son, por definición, pasados por valor. Esto significa que una copia referente al array se pasa al parámetro que será recibido por la función

que se llamó. En esta situación, cualquier modificación realizada en los elementos del array por la función que se llamó, se reflejará automáticamente en el array original. Por ejemplo:

LOCAL aLista[20]     	// Se crea el array y todos los elementos reciben el valor NIL
AFILL(aLista, 1, 1, 10)	// Atribuye el valor 1 a los 10 primeros elementos
AFILL(aLista, 2, 11, 20)// Atribuye el valor 2 a los 10 últimos elementos.


MSGALERT(aLista[1])     // Muestra el valor 1
MSGALERT(aLista[11])    // Muestra el valor 2


Dobro(aLista)   	// Ejecuta la función Dobro()


MSGALERT(aLista[1])     // Muestra el valor 2
MSGALERT(aLista[11])    // Muestra el valor 4


// Función Dobro()
FUNCTION Dobro(aMat)
LOCAL nElem := 0


FOR nElem 	:= 1 TO LEN(aMat)

aMat[nElem] 	:= aMat[nElem] * 2
NEXT nElem


RETURN NIL