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.
Esquema del Array Tabla | |||||||
1,1 | 1,2 | 1,3 | 1,4 | 1,5 | 1,6 | 1,7 | 1,8 |
2,1 | 2,2 | 2,3 | 2,4 | 2,5 | 2,6 | 2,7 | 2,8 |
3,1 | 3,2 | 3,3 | 3,4 | 3,5 | 3,6 | 3,7 | 3,8 |
4,1 | 4,2 | 4,3 | 4,4 | 4,5 | 4,6 | 4,7 | 4,8 |
5,1 | 5,2 | 5,3 | 5,4 | 5,5 | 5,6 | 5,7 | 5,8 |
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:
LOCAL aExemp1[5] LOCAL aExemp2[4] aExemp1[1] := 10 aExemp1[2] := 20 aExemp1[3] := 30 aExemp1[4] := 40 aExemp1[5] := 50 aExemp2[1] := "Clipper" aExemp2[2] := aExemp1[3] + aExemp1[5] aExemp2[3] := SQRT(aExemp1[1]) aExemp2[4] := 1 + aExemp1[2]
Un array se puede utilizar en cualquier punto de un programa, incluso como un elemento de otro array. De esta manera, se puede especificar un array multidimensional.
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
El número de elementos de un array se puede determinar por medio de la función LEN():
LOCAL aTabela[5, 8] MSGALERT(LEN(aTabela))
El mensaje anterior mostrará que el array aTabela tiene 5 elementos.
Observe que la función LEN() suministra sólo el número de elementos de la primera dimensión del array aTabela. El motivo es que en el AdvPL las matrices multidimensionales están, en realidad, compuestas por submatrices unidimensionales. Es decir, se puede interpretar que el array aTabela tiene una dimensión con cinco elementos, donde cada uno de los elementos de esta dimensión contiene una referencia a una submatriz de ocho elementos, que forma de esta manera una matriz de dos dimensiones 5 x 8. Por este motivo, cuando se aplica la función LEN() al array aTabela, suministra como resultado sólo cinco elementos.
Parta determinar el número de elementos de la submatrices, es decir, de la segunda dimensión del array aTabela, se debe aplicar la función LEN() al primer elementos de la matriz principal que contiene la primera submatriz, según el siguiente ejemplo:
MSGALERT(LEN(aTabela[1]))
En este caso, el mensaje mostrará que el primer elemento tiene 8 columnas. Si la matriz evaluada está vacía, la función LEN() suministra el valor cero.
Elementos de los Array
Para acceder a un elemento de un array, se debe identificarlo por el nombre del array y, enseguida, ponerlo entre corchetes, por sus índices. Por ejemplo:
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
En este ejemplo, cuando se ejecuta la función Dobro(), se pasa al parámetro aMat una copia de referencia del array aLista La función Dobro() multiplica todos los elementos del array aLista por dos. Cuando se finaliza la función Dobro(), se descarta la referencia aMat, pero se mantienen las modificaciones efectuadas en los valores de los elementos del array aLista.
Un array también se puede suministrar como resultado de funciones. Este recurso permite que una función, que por lo general provee un único valor como resultado, suministre múltiples valores por medio de los elementos de un array y por el comando RETURN. Por ejemplo:
aTabela := CriaTb(5, 10, SPACE(10)) // Función CriaTB, que alimenta al array de acuerdo con el número de líneas y columnas, así como el contenido. FUNCTION CriaTb(nLinhas, nColunas, cConteudo) LOCAL aTab[nLinhas, nColunas] FOR nElem1 := 1 TO nLinhas FOR nElem2 := 1 TO nColunas aTab[nElem1, nElem2] := cConteudo NEXT nElem2 NEXT nElem1 RETURN aTab
Funciones especiales para manejar Arrays
El operador doble igual ( == ) se utiliza para comparar dos arrays, verificando si son equivalentes. Es decir, si tienen el mismo contenido. Por ejemplo:
LOCAL aTabela1 := { 1, 2, 3 }
LOCAL aLista := { 1, 2, 3 }
LOCAL aTabela2 := aTabela1
IF aTabela1 == aTabela2
// Resultado: .T. (verdadero)
MSGALERT(“El contenido de los arrays aTabela1 y aTabela2 son iguales”)
ENDIF
IF aTabela1 == aLista
// Resultado: .F. (falso)
MSGALERT(“El contenido de los arrays aTabela1 y aLista son diferentes”)
ENDIF
El AdvPL tiene dos funciones para cambiar las dimensiones de un array existente:
1. ASIZE( <array>, <elementos> )
La función ASIZE() redefine un array ( <array> ) de acuerdo con un nuevo número de elementos ( <elementos> ). Si el nuevo número de elementos es superior al antiguo, nuevos elementos se agregarán, atribuyéndose el valor NIL a estos. Si el nuevo número de elementos es inferior al antiguo, los elementos que estuvieran por encima de este número se retirarán.
2. AADD( <array>, <expresión> )
La función AADD() agrega un nuevo elemento al array ( <array> ) especificado, atribuyéndole el resultado de la expresión ( <expresión> ) especificada. El nuevo elemento será el último del array.
Para incluir o eliminar elementos de un array existente, el AdvPL tiene dos funciones. Al contrario de las funciones AADD() y ASIZE(), estas funciones no modifican las dimensiones del array, pero sí el contenido de sus elementos.
3. ADEL( <array>, <nº del elemento> )
La función ADEL() elimina el elemento del array ( <array> ) definido por el número del elemento ( <nº del elemento> ). Todos los elementos ubicados después del elemento eliminado se mueven una posición a la izquierda. Al último elemento se atribuye el valor NIL.
4. AINS( <array>, <nº del elemento> )
La función AINS() incluye un elemento al array ( <array> ) en la posición definida por el argumento <nº del elemento>. Al nuevo elemento se atribuye el valor NIL. Los elementos ubicados después del elemento incluido se mueven una posición a la derecha y se eliminará el último elemento del array.
Para efectuar operaciones de copia de arrays, el AdvPL tiene dos funciones:
5. ACOPY()
Esta función copia un conjunto o todos los elementos de un array origen a un array destino existente. Si el array origen contiene subarrays, el array destino solamente tendrá referencias a éstas y no copias reales.
6. ACLONE()
Esta función duplica un array origen entero a un nuevo array destino, creando un nuevo array y realmente copiando los valores de los elementos del array origen a los elementos del nuevo array.
El orden de los elementos de arrays puede realizarse automáticamente por la función ASORT(). Ésta permite el orden o clasificación de todos los elementos de un array o de un determinado conjunto de estos.
El criterio de orden puede especificarse por medio de un bloque de código.
Para ubicar un elemento de un array con un determinado valor, se utiliza la función ASCAN(). Ésta realiza una búsqueda en los elementos del array para ubicar el elemento que contiene un determinado valor especificado por medio de una expresión o bloque de código. Esta función puede buscar todos o solamente un determinado conjunto de los elementos del array. Si se encontrara el valor deseado, la función retorna el índice correspondiente al elemento. En caso contrario, el valor retornado será cero.
Visão Geral
Import HTML Content
Conteúdo das Ferramentas
Tarefas