AADD()
Añade un nuevo elemento al final de una matriz
------------------------------------------------------------------------------
Sintaxis
AADD(<aDestáno >, <expValor>) --> Valor
Argumentos
<aDestáno> es la matriz a la que se va a a.adir un nuevo elemento.
<expValor> es el valor que se va a asignar al nuevo elemento.
Devuelve
AADD() eval.a <expValor> y devuelve su valor. Si no se especifica
<expValor>, AADD() devuelve NIL.
Descripción
AADD() es una función de tratamiento de matrices que aumenta en uno la
longitud real de la matriz destáno. Al elemento reci.n creado se le
asigna el valor especificado por <expValor>.
AADD() se utiliza para ampliar din.micamente una matriz. Resulta .til
para crear listas o colas din.micas. Un buen ejemplo de esto es la
matriz GetList, que utiliza el sistema GET para almacenar objetos Get.
Despu.s de ejecutar READ o CLEAR GETS, GetList pasa a ser una matriz
vac.a. Cada vez que se ejecuta un mandato @...GET, el sistema GET
utiliza AADD() para a.adir un elemento nuevo al final de la matriz
GetList y, a continúa.ión, asigna un nuevo objeto Get al nuevo elemento.
AADD() es similar a ASIZE(), excepto en que a.ade los elementos de uno
en uno. ASIZE(), en cambio, puede ampliar o reducir una matriz
directamente a un tama.o especificado. AADD() tiene la ventaja de que
permite asignar un valor al nuevo elemento, mientras que ASIZE() no lo
permite. AADD() también puede parecer similar a AINS(), pero se
diferencian en que AINS() desplaza elementos dentro de una matriz, pero
no cambia la longitud de la misma.
Nota: Si <expValor> es otra matriz, el nuevo elemento de la matriz
destáno contendr. una referencia a la matriz especificada por
<expValor>.
Ejemplos
. Los ejemplos siguientes muestran los resultados de llamadas
m.ltiples a AADD() con una matriz:
aMatriz := {} //Resultado: aMatriz es una matriz
//vac.a
AADD(aMatriz, 5) //Resultado: aMatriz es { 5 }
AADD(aMatriz, 10) //Resultado: aMatriz es { 5, 10 }
AADD(aMatriz, { 12, 10 })
//Resultado: aMatriz es
//{ 5, 10, { 12, 10 } }
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ABS()
Devuelve el valor absoluto de una expresión numérica
------------------------------------------------------------------------------
Sintaxis
ABS(<nExp>) --> nPositivo
Argumentos
<nExp> es la expresión numérica que se va a evaluar.
Devuelve
ABS() devuelve un número que representa el valor absoluto de su
argumento. El valor devuelto puede ser un número positivo o cero.
Descripción
ABS() es una función numérica que determina la magnitud de un valor
numérico, independientemente de su signo. Permite, por ejemplo, obtener
la diferencia entre dos números como valor positivo, sin conocer de
antemano cu.l de los dos es mayor.
Formalmente, ABS(x) se define en función de su argumento x de la
siguiente manera: si x >= 0, ABS(x) devuelve x; en caso contrario,
ABS(x) devuelve el valor negativo de x.
Ejemplos
. Los ejemplos siguientes muestran resultados t.picos de ABS():
nNum1 := 100
nNum2 := 150
? nNum1 - nNum2 //Resultado:-50
? ABS(nNum1 - nNum2) //Resultado: 50
? ABS(nNum2 - nNum1) //Resultado: 50
? ABS(-12) //Resultado: 12
? ABS(0) //Resultado: 0
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ACHOICE()
Ejecuta un men. emergente
------------------------------------------------------------------------------
Sintaxis
ACHOICE(<nSup>, <nIzq>, <nInf>, <nDer>,
<acElementosMen.>,
[<alElementosSeleccionables> |
<lElementosSeleccionables>],
[<cfunciónUsuario>],
[<nElementoInicial>],
[<nFilaVentana>]) --> nPosici.n
Argumentos
<nSup>, <nIzq> y <nInf>, <nDer> son las coordenadas
superior izquierda e inferior derecha de la ventana. Los valores de fila
pueden estar comprendidos entre cero y MAXROW() y los valores de columna
entre cero y MAXCOL().
<acElementosMen.> es una matriz de cadenas de carácteres que se va a
mostrar como elementos de men.. Los elementos de men. individuales se
identifican por sus posiciónes numéricas en esta matriz.
<alElementosSeleccionables> es una matriz paralela de valores
lógicos (un elemento para cada elemento de <acElementosMen.>), que
especifica los elementos de men. seleccionables. Los elementos de esta
matriz pueden ser valores lógicos o cadenas de carácteres. ACHOICE() no
permite cadenas nulas y detiene la visualización si encuentra una. Si
alg.n elemento es una cadena de carácteres, se eval.a como
macroexpresión y debe dar un resultado de tipo l.gico. En cualquier
caso, un valor falso (.F.) significa que el elemento de men.
correspondiente no va a estar disponible y un valor verdadero (.T.)
significa que lo estar.. Si se especifica los <lElementosSeleccionables>
en vez de una matriz, falso (.F.) hace que los elementos de men. no
están disponibles y verdadero (.T.) hace que lo están. Por defecto,
todos los elementos de men. están disponibles para su selecci.n.
<cfunciónUsuario> es el nombre de una función que se ejecuta cuando
se pulsa una tecla irreconocible. El nombre de función debe
especificarse como una expresión de carácteres sin paréntesis ni
argumentos. Recuerde que el comportamiento de ACHOICE() se ve afectado
por la presencia de este argumento. Si desea más información, consulte
el comentario siguiente.
<nElementoInicial> es la posición en la matriz <acElementosMen.> del
elemento que aparece resaltado al mostrarse el men. por primera vez. Si
se especifica un elemento de men. no disponible o no se especifican
argumentos, el elemento de men. inicial ser. el primer elemento
seleccionable de la matriz.
<nFilaVentana> es el número de fila de la ventana en la que aparece
el elemento de men. inicial. La numeraci.n de las filas comienza desde
cero. Por defecto, el elemento de men. inicial aparece lo m.s cerca
posible de la parte superior de la ventana, sin dejar filas vac.as al
final. Si existen suficientes elementos de men. a continúa.ión del
elemento inicial para llenar la ventana, el elemento inicial aparece en
la primera fila (fila cero) del men.. Este argumento se utiliza para
controlar el aspecto del men. inicial cuando hay m.s elementos de men.
de los que caben en la ventana.
Como ocurre con las dem.s funciónes, los argumentos opciónales pueden
omitirse utilizando una coma en vez del argumento real.
Devuelve
ACHOICE() devuelve la posición numérica en la matriz <acElementosMen.>
del elemento de men. seleccionado. Si se aborta el proceso de selecci.n,
ACHOICE() devuelve cero.
Descripción
ACHOICE() es una función de interfaz de usuario que permite crear varios
tipos de men.s emergentes. Cada men. utiliza una matriz de cadenas de
carácteres como elementos de men. y una matriz paralela de valores
lógicos para determinar si los elementos deben ser seleccionables o no.
Cuando se invoca ACHOICE(), la lista de elementos de men. aparece dentro
de las coordenadas de ventana especificadas. Si el usuario pulsa Intro,
se selecciona el elemento actual y ACHOICE() devuelve la posición del
elemento de men. en <acElementosMen.>. Si el usuario pulsa Esc,
ACHOICE() se aborta y devuelve cero.
Los elementos de men. pueden desplazarse si el número de elementos
de <acElementosMen.> excede el número de filas de la ventana de men.
y el usuario intenta desplazar la zona resaltada m.s all. del
principio o del final de la ventana. Recuerde que la zona resaltada
no salta de línea cuando se llega al principio o al final de la
lista de elementos. No obstante, la zona resaltada puede saltar de
línea si se pulsa la primera letra de un elemento del grupo cuya
primera letra coincida con la tecla pulsada.
. Desplazamiento por el men.: ACHOICE() posee dos modos,
dependiendo de si se especifica el argumento <cfunciónUsuario>. Si no
se especifica, se activan las siguientes teclas de desplazamiento:
Teclas de ACHOICE() (sin función de usuario)
---------------------------------------------------------------------
Tecla Acción
---------------------------------------------------------------------
Arriba Va al elemento anterior
Abajo Va al elemento siguiente
Inicio Va al primer elemento del men.
Fin Va al último elemento del men.
Ctrl-Inicio Va al primer elemento de la ventana
Ctrl-Fin Va al último elemento de la ventana
ReP.g Va a la p.gina anterior
AvP.g Va a la p.gina siguiente
Ctrl-ReP.g Va al primer elemento del men.
Ctrl-AvP.g Va al último elemento del men.
Intro Selecciona el elemento actual
Esc Anula la selecci.n
Izquierda Anula la selecci.n
Derecha Anula la selecci.n
Primera Letra Va al elemento siguiente que comience con esa letra
---------------------------------------------------------------------
. Color: Los elementos de men. aparecen en el color
estándar, la zona resaltada en el color resaltado y los elementos no
disponibles en el color no seleccionado. Por ejemplo, la siguiente
sentencia de color:
SETCOLOR("W+/N, BG+/B, , , W/N")
muestra un men. blanco brillante sobre negro, la zona resaltada en
c.an brillante sobre azul y los elementos de men. no disponibles en
blanco atenuado sobre negro.
. función de Usuario: Al igual que las restántes funciónes
de interfaz de usuario, ACHOICE() permite utilizar una función
definida por el usuario. Esta función se especifica cuando se desean
anidar invocaciones a ACHOICE() para crear men.s jer.rquicos o
redefinir teclas.
Si se especifica una función de usuario, ACHOICE() sólo procesa
autom.ticamente un grupo de teclas reducido que se lista en la tabla
siguiente. Todas las dem.s teclas generan una excepci.n de teclado
que pasa el control a la función de usuario para su tratamiento. El
control pasa también a la función de usuario cuando ACHOICE() queda
inactiva (es decir, cuando no quedan teclas para procesar).
Teclas de ACHOICE() (función de Usuario Especificada)
---------------------------------------------------------------------
Tecla Acción
---------------------------------------------------------------------
Arriba Va al elemento anterior
Abajo Va al elemento siguiente
Ctrl-Inicio Va al primer elemento de la ventana
Ctrl-Fin Va al último elemento de la ventana
ReP.g Va a la p.gina anterior
AvP.g Va a la p.gina siguiente
Ctrl-ReP.g Va al primer elemento del men.
Ctrl-AvP.g Va al último elemento del men.
---------------------------------------------------------------------
Cuando ACHOICE() ejecuta la función de usuario, le pasa
autom.ticamente estos tres parámetros:
- Modo actual de ACHOICE()
- Elemento actual de la matriz de elementos
- Posici.n de fila relativa en la ventana de men.
El modo indica el estado actual de ACHOICE(), que depende de la tecla
pulsada y de la acci.n que realiza ACHOICE() antes de ejecutar la
función de usuario. El parámetro de modo puede poseer los valores que
se indican a continúa.ión:
Modos de ACHOICE()
---------------------------------------------------------------------
Modo Achoice.ch Descripción
---------------------------------------------------------------------
0 AC_IDLE Inactivo
1 AC_HITTOP Intento de desplazar el cursor por encima del
principio de la lista
2 AC_HITBOTTOM Intento de desplazar el cursor por debajo del
final de la lista
3 AC_EXCEPT Excepciones del teclado
4 AC_NOITEM No quedan elementos seleccionables
---------------------------------------------------------------------
Una vez que la función de usuario completa las acciones
correspondientes al modo de ACHOICE() o de LASTKEY(), devuelve un
valor que solicita ACHOICE() que realice una de las operación.s
siguientes:
Valores de Retorno de la función de Usuario de ACHOICE()
---------------------------------------------------------------------
Valor Achoice.ch Acción
---------------------------------------------------------------------
0 AC_ABORT Anular la selecci.n
1 AC_SELECT Confirmar la selecci.n
2 AC_CONT Continuar ACHOICE()
3 AC_GOTO Ir al pr.ximo elemento cuyo primer carácter
coincida con la tecla pulsada
---------------------------------------------------------------------
Ejemplos
. El ejemplo siguiente utiliza dos matrices literales que
especifican los elementos de men. y los criterios de selecci.n.
Cuando el men. aparece en pantalla y el usuario ha realizado la
selecci.n, se muestra el nombre del elemento de men. seleccionado:
acElementosMenu := {"Uno", "Dos", "-------", "Tres"}
alElementosSeleccionables := {.T., .T., .F., .T.}
nPosicion := ACHOICE(10, 10, 12, 15, acElementosMenu,;
alElementosSeleccionables)
? acElementosMenu [nPosicion]
. El ejemplo siguiente declara una matriz de elementos de men. y
utiliza una función de usuario que muestra un mensaje con cada opción
resaltada:
#include "achoice.ch"
#include "inkey.ch"
PROCEDURE Main()
LOCAL acElementosMenu [4], nValDev
LOCAL nTecla, nPos
acElementosMenu[1] := "A.adir"
acElementosMenu[2] := "Editar"
acElementosMenu[3] := "Borrar"
acElementosMenu[4] := "Actualizar"
CLS
nPos := ACHOICE( 10, 10, 13, 15, acElementosMenu,;
.T., "cfunciónUsuario" )
DO CASE
CASE nPos == 1
// Poner aqu. la rutina que a.ade
CASE nPos == 2
// Poner aqu. la rutina que edita
CASE nPos == 3
// Poner aqu. la rutina que borra
CASE nPos ==4
// Poner aqu. la rutina que actualiza
ENDCASE
RETURN
FUNCTION cfunciónUsuario (nModo nElementoAct nRosFila)
LOCAL nValDev := AC_CONT //Por defecto,
//continúa.
LOCAL nTecla := LASTKEY()
DO CASE
// Despu.s de procesar todas las teclas
//pendientes, se visualiza el mensaje
CASE nModo == AC_IDLE
DO CASE
CASE nElementoAct == 1
@ 22, 5 SAY " A.adiendo "
CASE nElementoAct == 2
@ 22, 5 SAY " Editando "
CASE nElementoAct == 3
@ 22, 5 SAY " Borrando "
CASE nElementoAct == 4
@ 22, 5 SAY " Actualizando "
ENDCASE
nValDev := AC_CONT // Continuar ACHOICE()
CASE nModo == AC_HITTOP // Intento de ir antes
// del principio
TONE( 100, 3 )
CASE nModo == AC_HITBOTTOM // Intento de ir
// por debajo del final
TONE( 100, 3 )
CASE nModo == AC_EXCEPT // Excepci.n de teclado
DO CASE
CASE nTecla == K_RETURN // Si se pulsa la
// tecla INTRO,
// confirmar selecci.n
nValDev := AC_SELECT
CASE nTecla == K_ESC // Si se pulsa la tecla
// ESCAPE, anular selecci.n
nValDev := AC_ABORT
OTHERWISE
nValDev := AC_GOTO // En caso
// contrario, ir al
// elemento
ENDCASE
ENDCASE
RETURN nValDev
. El ejemplo siguiente declara las matrices, especifica una
condición de selecci.n para uno de los elementos de men. y utiliza
una función de usuario:
EXTERNAL UPDATED
//
FUNCTION MiMenu
LOCAL acElementosMenu[4], alElementosSeleccionables[4],;
cfunciónUsuario := "Hacerlo"
//
acElementosMenu[1] := "A.adir Registro"
acElementosMenu[2] := "Editar Registro"
acElementosMenu[3] := "Borrar Registro"
acElementosMenu[4] := "Actualizar Registro"
//
alElementosSeleccionables[1] := .T.
alElementosSeleccionables[2] := .T.
alElementosSeleccionables[3] := .T.
alElementosSeleccionables[4] := "!UPDATED()"
// Condici.n de Selecci.n
RETURN ACHOICE(10, 10, 12, 15, acElementosMenu,;
alElementosSeleccionables, cfunciónUsuario)
. El ejemplo siguiente utiliza dos matrices que especifican los
elementos de men. y los bloques de acci.n correspondientes. Cuando el
men. aparece en pantalla y el usuario ha realizado una selecci.n, se
utiliza el valor de retorno de ACHOICE() para determinar qu. bloque
de acciones de aElementosAcción debe evaluarse:
PROCEDURE Main()
LOCAL nSeleccion
LOCAL aElementosMenu := { "A.adir Registro ", ;
"Editar Registro ", ;
"Borrar Registro", ;
"Actualizar Registro" }
LOCAL aElementosAcción := { {|| AnadFunc() }, ;
{|| EditFunc() }, ;
{|| BorrFunc() }, ;
{|| ActuFunc() } }
nSeleccion := ACHOICE( 10, 10, 13, 22, aElementosMenu )
IF nSeleccion == 0
QUIT // Se ha pulsado ESCAPE
ENDIF
EVAL( aElementosAcción [nSeleccion] )
RETURN
Ficheros: La biblioteca asociada es EXTEND.LIB, los ficheros de cabecera
asociados son Achoice.ch e Inkey.ch.
ACLONE()
Duplica una matriz anidada o multidimensiónal
------------------------------------------------------------------------------
Sintaxis
ACLONE(<aFuente>) --> aDuplicado
Argumentos
<aFuente> es la matriz que se va a duplicar.
Devuelve
ACLONE() devuelve un duplicado de <aFuente>.
Descripción
ACLONE() es una función de matrices que crea un duplicado completo de la
matriz <aFuente>. Si <aFuente> contiene submatrices, ACLONE() crea las
submatrices correspondientes y las llena con copias de los valores de
las submatrices de <aFuente>. ACLONE() es similar a ACOPY(), pero
ACOPY() no duplica matrices anidadas.
Ejemplos
. El ejemplo siguiente crea una matriz y luego la duplica con
ACLONE(). Luego, la primera matriz se modifica, pero la copia
duplicada no resulta afectada:
LOCAL aUno, aDos
aUno := { 1, 2, 3 } //Resultado: aUno es {1, 2, 3}
aDos := ACLONE(aUno) //Resultado: aDos es {1, 2, 3}
aUno[1] := 99 //Resultado: aUno es {99, 2, 3}
//aDos sigue siendo {1, 2, 3}
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ACOPY()
Copia elementos de una matriz a otra
------------------------------------------------------------------------------
Sintaxis
ACOPY(<aFuente>, <aDestáno>, [<nInicio>],
[<nPosiciones>], [<nPosDestáno>]) --> aDestáno
Argumentos
<aFuente> es la matriz cuyos elementos se van a copiar.
<aDestáno> es la matriz en la que se van a copiar los elementos.
<nInicio> es la posición del elemento inicial de la matriz
<aFuente>. Si no se especifica, el valor por defecto es uno.
<nPosiciones> es el número de elementos que se van a copiar de
<aFuente>, comenzando en la posición <nInicio>. Si no se especifica
<nPosiciones>, se copian todos los elementos de <aFuente> desde el
elemento inicial.
<nPosDestáno> es la posición del elemento inicial de la matriz
<aDestáno> que va a recibir los elementos de <aFuente>. Si no se
especifica, el valor por defecto es uno.
Devuelve
ACOPY() devuelve una referencia a la matriz destáno, <aDestáno>.
Descripción
ACOPY() es una función de matrices que copia elementos de la matriz
<aFuente> en la matriz <aDestáno>. La matriz <aDestáno> debe existir
prevíamente y debe ser lo suficientemente grande para almacenar los
elementos copiados. Si la matriz <aFuente> tiene m.s elementos, algunos
de ellos no se copiar.n.
ACOPY() copia valores de cualquier tipo de datos, incluyendo NIL y
bloques de código. Si un elemento de la matriz <aFuente> es una
submatriz, el elemento correspondiente de la matriz <aDestáno> contendr.
una referencia a la submatriz. Por tanto, ACOPY() no crear. un duplicado
completo de una matriz multidimensiónal. Para ello, es necesario
utilizar la función ACLONE().
Ejemplos
. El ejemplo siguiente crea dos matrices, cada una de las cuales
se llena con un valor. A continúa.ión, los dos primeros elementos de
la matriz fuente se copian en la matriz destáno:
LOCAL nPosiciones := 2, nInicio := 1, aUno, aDos
aUno := { 1, 1, 1 }
aDos := { 2, 2, 2 }
ACOPY(aUno, aDos, nInicio, nPosiciones)
//Resultado: aDos ahora es { 1, 1, 2 }
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ADEL()
Borra un elemento de una matriz
------------------------------------------------------------------------------
Sintaxis
ADEL(<aDestáno>, <nPosici.n>) --> aDestáno
Argumentos
<aDestáno> es la matriz cuyo elemento se va a borrar.
<nPosici.n> es la posición del elemento que se va a borrar.
Devuelve
ADEL() devuelve una referencia a la matriz destáno, <aDestáno>.
Descripción
ADEL() es una función de matrices que borra un elemento de una matriz.
El contenido del elemento de matriz especificado se pierde y todos los
elementos que haya desde esa posición hasta el final de la matriz se
desplazan una posición. El último elemento de la matriz toma el valor
NIL.
.Advertencia! CA-Clipper crea las matrices multidimensiónales
anidando unas matrices dentro de otras. Si la matriz <aDestáno> es una
matriz multidimensiónal, ADEL() puede borrar una submatriz completa si
se encuentra en <nPosici.n>, haciendo que <aDestáno> describa una matriz
con una estructura diferente de la original.
Ejemplos
. Este ejemplo crea una matriz constante de tres elementos y, a
continúa.ión, borra el segundo elemento. El tercer elemento se
desplaza una posición y al nuevo tercer elemento se le asigna un
valor NIL:
LOCAL aMatriz
aMatriz := { 1, 2, 3 } //Resultado: aMatriz es
// ahora { 1, 2, 3 }
ADEL(aMatriz, 2) //Resultado: aMatriz es
// ahora { 1, 3, NIL }
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ADIR()*
Llena una serie de matrices con información del directorio
------------------------------------------------------------------------------
Sintaxis
ADIR([<cEspecFichero>],
[<aNombresFichero>],
[<aTama.os>],
[<aFechas>],
[<aHoras>],
[<aAtributos>]) --> nFicheros
Argumentos
<cEspecFichero> es la especificación de la vía de los ficheros que
se van a incluir en la b.squeda del directorio por defecto. Es una
especificación de ficheros estándar, que permite incluir carácteres
comod.n * y ? y referencias de unidades y vías. Si se omite, la
especificación por defecto es *.*.
<aNombresFichero> es la matriz que se va a llenar con los nombres de
ficheros seleccionados con <cEspecFichero>. Cada elemento contiene el
nombre y la extensión del fichero en forma de cadena de carácteres en
mayúsculas.
<aTama.os> es la matriz que se va a llenar con los tama.os de los
ficheros correspondientes de la matriz <aNombresFichero>. Todos sus
elementos son de tipo numérico.
<aFechas> es la matriz que se va a llenar con las fechas de los
ficheros correspondientes de la matriz <aNombresFichero>. Todos sus
elementos son de tipo fecha.
<aHoras> es la matriz que se va a llenar con las horas de los
ficheros correspondientes de la matriz <aNombresFichero>. Todos sus
elementos contienen una cadena de carácteres de formato: hh:mm:ss.
<aAtributos> es la matriz que se va a rellenar con atributos de los
ficheros correspondientes de la matriz <aNombresFichero>. Todosólos
elementos son cadenas de carácteres. Si se especifica <aAtributos>,
pueden incluirse ficheros ocultos, de sistema y de directorio junto a
los ficheros normales. Si no se especifica <aAtributos>, solamente se
incluyen ficheros normales.
Devuelve
ADIR() devuelve el número de ficheros seleccionables con el patr.n de
directorios descrito por <cEspecFichero>.
Descripción
ADIR() es una función de matrices que realiza dos operación.s b.sicas.
En primer lugar, devuelve el número de ficheros seleccionables con la
especificación de ficheros. En segundo lugar, llena una serie de
matrices con los nombres, tama.os, fechas, horas y atributos de los
ficheros.
ADIR() es una función de compatibilidad y, por tanto, su utilización no
es recomendable. Puede sustituirse por la función DIRECTORY(), que
devuelve toda la información de ficheros en una matriz multidimensiónal.
Notas
. Directorios: Si se utiliza un argumento <aAtributos> y una
<cEspecFichero> *.*, pueden incluirse directorios en
<aNombresFichero>. En la matriz <aAtributos>, para indicar
directorios se utiliza un atributo "D." Si se ejecuta ADIR() en un
subdirectorio, las dos primeras entradas de <aNombresFichero> ser.n
"." y "..", los alias de los directorios principal y actual
respectivamente. Se indica también la fecha y hora de la .ltima
actualizaci.n de un directorio, pero su tama.o es siempre cero.
Ejemplos
. El ejemplo siguiente crea una matriz que va a contener los
nombres de todos los ficheros (.txt) del directorio por defecto
actual y, a continúa.ión, utiliza AEVAL() para listarlos en la
consola:
LOCAL aFicheros[ADIR("*.TXT")]
ADIR("*.TXT", aFicheros)
AEVAL(aFicheros, { |elemento| QOUT(elemento) })
Ficheros: La biblioteca asociada es EXTEND.LIB.
AEVAL()
Ejecuta un bloque de código en cada elemento de una matriz
------------------------------------------------------------------------------
Sintaxis
AEVAL(<aMatriz>, <bBloque>,
[<nInicio>], [<nPosiciones>]) --> aMatriz
Argumentos
<aMatriz> es la matriz que se va a recorrer.
<bBloque> es el bloque de código que se va a ejecutar en cada
elemento encontrado.
<nInicio> es el elemento inicial. Si no se especifica, el valor por
defecto es el elemento uno.
<nPosiciones> es el número de elementos que se van a procesar,
contados desde <nInicio>. Si no se especifica, el valor por defecto es
todos los elementos hasta el final de la matriz.
Devuelve
AEVAL() devuelve una referencia a <aMatriz>.
Descripción
AEVAL() es una función de matrices que eval.a un bloque de código en
cada elemento de una matriz, pasando el valor y el índice del elemento
como parámetros al bloque. El valor devuelto por el bloque se ignora. Se
procesan todos los elementos de <aMatriz>, a no ser que se especifique
<nInicio> o <nPosiciones>.
AEVAL() no comprueba el contenido de los elementos de matriz que pasa al
bloque. Se supone que el bloque correspondiente conoce el tipo de datos
que hay en cada elemento.
AEVAL() es similar a DBEVAL(), que aplica un bloque a cada registro de
un fichero de base de datos. Al igual que DBEVAL(), AEVAL() puede
utilizarse como primitiva para crear mandatos iterativos, tanto para
estructuras de matriz simples como complejas.
Si desea más información sobre la teor.a y la sintaxis de los bloques de
código, consulte la secci.n Bloques de C.digo del capítulo Conceptos
Básicos de la guía de Programación y Utilidades.
Ejemplos
. El ejemplo siguiente utiliza AEVAL() para mostrar en pantalla
una matriz de nombres y tama.os de fichero devueltos por la función
DIRECTORY():
#include "Directry.ch"
//
LOCAL aFicheros := DIRECTORY("*.dbf"), nTotal := 0
AEVAL(aFicheros,;
{ | aFicheroDBF |;
QOUT(PADR(aFicheroDBF[F_NAME], 10), aFicheroDBF[F_SIZE]),;
nTotal += aFicheroDBF[F_SIZE]);
} )
//
?
? "Bytes totales:", nTotal
. El ejemplo siguiente utiliza AEVAL() para crear una lista
formada por los elementos seleccionados en una matriz
multidimensiónal:
#include "Directry.ch"
//
LOCAL aFicheros := DIRECTORY("*.dbf"), aNombres := {}
AEVAL(aFicheros,;
{ | fichero | AADD(aNombres, fichero[F_NAME]) };
)
. El ejemplo siguiente modifica el contenido de un elemento de
matriz, dependiendo de una condición. Observe la utilización de los
parámetros de bloque de código: */
LOCAL aMatriz[6]
AFILL(aMatriz,"anterior")
AEVAL(aMatriz,;
{|cValor,níndice| IF(cValor == "anterior",;
aMatriz[níndice] := "nuevo",)})
Ficheros: La biblioteca asociada es CLIPPER.LIB.
AFIELDS()*
Llena matrices con la estructura del fichero actual de base de datos
------------------------------------------------------------------------------
Sintaxis
AFIELDS([<aNombresCampo>], [<aTipos>],
[<aAnchuras>], [<aDecimales>]) --> nCampos
Argumentos
<aNombresCampo> es la matriz que se va a llenar con los nombres de
campo. Todos sus elementos son cadenas de carácteres.
<aTipos> es la matriz que se va a llenar con los tipos de campo de
<aNombresCampo>. Todos sus elementos son cadenas de carácteres.
<aAnchuras> es la matriz que se va a llenar con las anchuras de los
campos de <aNombresCampo>. Todos sus elementos son de tipo numérico.
<aDecimales> es la matriz que se va a llenar con el número de
decimales definido para los campos de <aNombresCampo>. Todosólos
elementos son de tipo numérico. Si el tipo del campo no es numérico, el
elemento de <aDecimales> ser. cero.
Devuelve
AFIELDS() devuelve el número de campos o la longitud del argumento de
matriz m.s corto, el que sea menor de los dos. Si no se especifican
argumentos o no se est. utilizando un fichero de base de datos en el
área de trabajo actual, AFIELDS() devuelve cero.
Descripción
AFIELDS() es una función de matrices que llena una serie de matrices (de
atributos de estructura) con la estructura del fichero de base de datos
actualmente abierto, un elemento de cada matriz por campo. AFIELDS()
act.a como ADIR(), que llena una serie de matrices existentes con
información. Para utilizar AFIELDS(), primero debe crear las matrices
que van a contener la información de la estructura de la base de datos.
Todas las matrices deben tener el mismo número de elementos que de
campos (es decir, FCOUNT()). Una vez que se hayan creado las matrices de
atributos de estructura, puede invocar AFIELDS() para rellenar estas
matrices con la información de cada campo.
Por defecto, AFIELDS() opera en el área de trabajo actual. Para operar
en un área de trabajo no seleccionada, debe especificarla con una
expresión de alias (consulte el ejemplo siguiente).
AFIELDS() es una función de compatibilidad y, por tanto, su utilización
no es recomendable. Puede sustituirse por DBSTRUCT(), que no requiere la
existencia de matrices antes de la invocaci.n y devuelve una matriz
multidimensiónal que contiene la estructura de fichero actual de base de
datos.
Ejemplos
. Este ejemplo muestra la forma de utilizar AFIELDS() y
ACHOICE() simultáneamente para crear una lista de selecci.n de
campos:
USE Ventas NEW
PRIVATE aNombresCampo[FCOUNT()]
AFIELDS(aNombresCampo)
@ 1, 0 TO 10, 10 DOUBLE
nSeleccion := ACHOICE(2, 1, 9, 9, aNombresCampo)
@ 12, 0 SAY IF(nSeleccion != 0, aNombresCampo[nSeleccion],;
"Ninguno seleccionado")
RETURN
. El ejemplo siguiente utiliza AFIELDS() con una expresión de
alias para llenar matrices con la estructura del fichero Ventas.dbf,
abierto en un área de trabajo no seleccionada:
LOCAL aNombresCampo, aTipos, aAnchuras, aDecimales
USE Ventas NEW
USE Cliente NEW
//
aNombresCampo := Ventas->(ARRAY(FCOUNT()))
aTipos := Ventas->(ARRAY(FCOUNT()))
aAnchuras := Ventas->(ARRAY(FCOUNT()))
aDecimales := Ventas->(ARRAY(FCOUNT()))
//
Ventas->(AFIELDS(aNombresCampo, aTipos, ;
aAnchuras, aDecimales))
Ficheros: La biblioteca asociada es EXTEND.LIB.
AFILL()
Rellena una matriz con un valor especificado
------------------------------------------------------------------------------
Sintaxis
AFILL(<aDestáno>, <expValor>,
[<nInicio>], [<nPosiciones>]) --> aDestáno
Argumentos
<aDestáno> es la matriz que se va a rellenar.
<expValor> es el valor que se va a colocar en cada elemento de la matriz.
Puede ser una expresión de cualquier tipo víaacute;lido.
<nInicio> es la posición del primer elemento que se va a llenar. Si
se omite este argumento, el valor por defecto es uno.
<nPosiciones> es el número de elementos que se van a llenar
comenzando por <nInicio>. Si se omite este argumento, los elementos se
rellenan desde el elemento inicial hasta el final de la matriz.
Devuelve
AFILL() devuelve una referencia a <aDestáno>.
Descripción
AFILL() es una función de matrices que rellena la matriz especificada
con un valor de cualquier tipo de datos (incluyendo matrices, bloques de
código o valores NIL), asignando <expValor> a cada elemento de matriz
dentro del rango especificado.
.Advertencia! AFILL() no puede utilizarse para llenar matrices
multidimensiónales. CA-Clipper crea las matrices las multidimensiónales
anidando unas matrices dentro de otras. La utilización de AFILL() con
una matriz multidimensiónal sobreescribe las submatrices que se utilizan
para las otras dimensiónes de la matriz.
Ejemplos
. El ejemplo siguiente crea una matriz de tres elementos, la
rellena con el valor l.gico (.F.) y, finalmente, a los elementos de
las posiciónes dos y tres les asigna el valor verdadero (.T.):
LOCAL aLogico[3]
//Resultado: aLogico es { NIL, NIL, NIL }
AFILL(aLogico, .F.)
//Resultado: aLogico es { .F., .F., .F. }
AFILL(aLogico, .T., 2, 2)
//Resultado: aLogico es { .F., .T., .T. }
Ficheros: La biblioteca asociada es CLIPPER.LIB.
AINS()
Inserta un elemento NIL en una matriz
------------------------------------------------------------------------------
Sintaxis
AINS(<aDestáno>, <nPosici.n>) --> aDestáno
Argumentos
<aDestáno> es la matriz en la que se va a insertar el nuevo
elemento.
<nPosici.n> es la posición en la que se va a insertar el nuevo
elemento.
Devuelve
AINS() devuelve una referencia a la matriz destáno, <aDestáno>.
Descripción
AINS() es una función de matrices que inserta un nuevo elemento en una
matriz especificada. El elemento reci.n insertado ser. de tipo NIL hasta
que se le asigne un nuevo valor. Despu.s de la inserci.n, el último
elemento de la matriz se descarta y todos los elementos que van detrás
del elemento nuevo se desplazan una posición.
.Advertencia! AINS() debe utilizarse con cuidado en matrices
multidimensiónales. En CA-Clipper las matrices multidimensiónales se
crean anidando unas matrices dentro de otras. La utilización de AINS()
en una matriz multidimensiónal elimina el último elemento de la matriz
y, si dicho elemento es una submatriz, se pierden una o más dimensiónes.
Para insertar una nueva dimensión en una matriz, a.ada primero un nuevo
elemento al final de la matriz mediante AADD() o ASIZE() antes de
utilizar AINS().
Ejemplos
. El ejemplo siguiente muestra el resultado de la utilización de
AINS() en una matriz:
LOCAL aMatriz
aMatriz := { 1, 2, 3 } //Resultado: aMatriz es
// ahora { 1, 2, 3 }
AINS(aMatriz, 2) //Resultado: aMatriz es
// ahora { 1, NIL, 2 }
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ALERT()
Muestra en pantalla un panel de diálogo modal sencillo
------------------------------------------------------------------------------
Sintaxis
ALERT( <cMensaje>, [<aOpciones>] ) --> nSelecci.n
Argumentos
<cMensaje> es el texto del mensaje, mostrado y centrado en el cuadro
de advertencia. Si el mensaje contiene uno o m.s signos de punto y coma,
el texto que va detrás de estos signos se centra en las líneas
siguientes del panel de diálogo.
<aOpciones> define una lista de hasta cuatro posibles respuestas al
panel de diálogo.
Devuelve
ALERT() devuelve un valor numérico que indica la opción escogida. Si se
pulsa la tecla Esc, el valor devuelto es cero.
Descripción
La función ALERT() crea un panel de diálogo modal sencillo. Es .til para
manejadores de error y otras funciónes de "pausa". El usuario puede
responder moviendo una barra resaltada y pulsando las teclas Intro o
Barra espaciadora, o pulsando la tecla correspondiente a la primera
letra de la opción. Si no se especifica <aOpciones>, sólo aparece la
opción "OK".
ALERT() es sensible a la utilización del sistema de entrada/salida de
pantalla completa de CA-Clipper. Si no se utiliza el sistema de pantalla
completa, ALERT() utiliza la entrada/salida estándar y muestra el
mensaje y las opciónes en estilo de teleimpresora (es decir, 80
columnas, sin saltos de línea autom.ticos y cada línea terminada con un
retorno de carro/salto de línea).
Ejemplos
. El ejemplo de la p.gina siguiente muestra la utilización de un
panel de advertencia . Primero se define la matriz de las opciónes,
la función ALERT() recoge la selecci.n del usuario y, finalmente,
ésta se procesa con una estructura de control DO CASE...ENDCASE:
#define AL_SAVE 1
#define AL_CANCEL 2
#define AL_CONT 3
// Define una matriz de opciónes
aOpciones := {"Salvar", "No Salvar", "Continuar"}
// Muestra el panel de diálogo y recoge la
// selecci.n del usuario
nSeleccion := ALERT("El fichero ha sido modificado ..", aOpciones)
// Procesa la selecci.n del usuario
DO CASE
CASE nSeleccion == AL_SAVE
? "Salvar"
CASE nSeleccion == AL_CANCEL
? "No Salvar"
CASE nSeleccion == AL_CONT
? "Continuar"
OTHERWISE
? "Escape"
ENDCASE
//
RETURN
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ALIAS()
Devuelve el alias del área de trabajo especificada
------------------------------------------------------------------------------
Sintaxis
ALIAS([<nAreaTrabajo>]) --> cAlias
Argumentos
<nAreaTrabajo> es cualquier número de área de trabajo.
Devuelve
ALIAS() devuelve el alias del área de trabajo, especificado como una
cadena de carácteres. Si no se indica <nAreaTrabajo>, se devuelve el
alias del área de trabajo actual. Si no se est. utilizando ningún
fichero de base de datos en el área de trabajo especificada, ALIAS()
devuelve una cadena nula ("").
Descripción
ALIAS() es una función de base de datos que determina el alias del .rea
de trabajo especificada. Un alias es el nombre asignado a un .rea de
trabajo cuando utiliza un fichero de base de datos. El nombre asignado
realmente es el nombre del fichero de base de datos o un nombre asignado
explícitamente con la cláusula ALIAS del mandato USE.
ALIAS() es la función inversa de SELECT(). ALIAS() recibe un número de
área de trabajo y devuelve el alias. SELECT() recibe el alias y devuelve
el número del área de trabajo.
. El ejemplo siguiente devuelve el nombre del área de trabajo
seleccionada:
USE Fichero1 NEW ALIAS Prueba1
nAreaAnterior := SELECT()
USE Fichero2 NEW ALIAS Prueba2
? ALIAS( nAreaAnterior ) // Devuelve Prueba1
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ALLTRIM()
Suprime los espacios en blanco iniciales y finales de una cadena de
carácteres
------------------------------------------------------------------------------
Sintaxis
ALLTRIM(<cCadena>) --> cSuprCadena
Argumentos
<cCadena> es la expresión de carácteres que se va a recortar.
Devuelve
ALLTRIM() devuelve una cadena de carácteres en la que se han eliminado
los espacios iniciales y finales en blanco.
Descripción
ALLTRIM() es una función de carácteres que elimina tanto los espacios
iniciales como los finales de una cadena. Está relacionada con LTRIM() y
RTRIM(), que eliminan los espacios iniciales y finales, respectivamente.
Las funciónes inversas de ALLTRIM(), LTRIM() y RTRIM() son PADC(), PADL() y
PADR(), que centran, justifican a la izquierda o justifican a la derecha
cadenas de carácteres, rellen.ndolas con carácteres de relleno.
Ejemplos
. El ejemplo siguiente crea una cadena con espacios iniciales y
finales en blanco y luego los elimina con ALLTRIM():
cCadena := SPACE(10) + "cadena" + SPACE(10)
? LEN(cCadena) //Resultado: 26
? LEN(ALLTRIM(cCadena)) //Resultado: 6
Ficheros: La biblioteca asociada es EXTEND.LIB.
ALTD()
Invoca al depurador de CA-Clipper
------------------------------------------------------------------------------
Sintaxis
ALTD([<nAcción>]) --> NIL
Argumentos
<nAcción> define la acci.n que realiza ALTD() cuando se invoca. A
continúa.ión se da la una lista completa de los valores de <nAcción> y
sus resultados:
Acciónes de ALTD()
------------------------------------------------------------------------
Argumento Acción
------------------------------------------------------------------------
Ninguno Invoca al depurador si est. habilitado
0 Desactiva Alt-D
1 Activa Alt-D
Otro Ninguna acci.n
------------------------------------------------------------------------
Devuelve
ALTD() siempre devuelve NIL.
Descripción
ALTD() realiza distintas acciones, dependiendo de su argumento, tal como
se indica en la tabla anterior. Si desea más información sobre la
utilización del depurador, consulte el capítulo El Depurador de
CA-Clipper de la guía de Programación y Utilidades.
Ejemplos
. El ejemplo siguiente muestra una serie de constantes
declaradas que pueden utilizarse como argumentos de ALTD() antes de
invocar al depurador de programas:
#define ALTD_DISABLE 0
#define ALTD_ENABLE 1
//
ALTD(ALTD_ENABLE)
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ARRAY()
Crea una matriz de una longitud especificada, sin inicializar
------------------------------------------------------------------------------
Sintaxis
ARRAY(<nElementos> [, <nElementos>...]) --> aMatriz
Argumentos
<nElementos> es el número de elementos de la dimensión especificada.
El número máximo de elementos de una dimensión es 4096. Las matrices de
CA-Clipper pueden tener un número de dimensiónes ilimitado.
Devuelve
ARRAY() devuelve una matriz con las dimensiónes especificadas.
Descripción
ARRAY() es una función de matrices que devuelve una matriz no
inicializada con el número de elementos y dimensiónes especificado. Si
se especifica m.s de un argumento <nElementos>, se crear. una matriz
multidimensiónal con un número de dimensiónes igual al número de
argumentos <nElementos> especificado. Si alg.n argumento <nElementos> es
una matriz, se crea una matriz anidada.
En CA-Clipper, existen varias formas de crear una matriz. Puede
declararse utilizando una sentencia LOCAL o STATIC; también puede
crearse con una declaración PRIVATE o PUBLIC; puede asignarse una matriz
en forma literal a una variable existente o puede usarse la función
ARRAY(). ARRAY() tiene la ventaja de que permite crear matrices dentro
de expresiónes o bloques de código.
Ejemplos
. El ejemplo siguiente crea una matriz unidimensiónal de cinco
elementos utilizando la función ARRAY(). Luego, muestra la acci.n
equivalente asignando una matriz literal con valores NIL:
aMatriz := ARRAY(5)
aMatriz := { NIL, NIL, NIL, NIL, NIL }
. El ejemplo siguiente muestra tres sentencias distintas que
crean la misma matriz multidimensiónal:
aMatriz := ARRAY(3, 2)
aMatriz := { {NIL, NIL}, {NIL, NIL}, {NIL, NIL} }
aMatriz := { ARRAY(2), ARRAY(2), ARRAY(2) }
. El ejemplo siguiente crea una matriz anidada multidimensiónal:
aMatriz := ARRAY(3, {NIL,NIL})
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ASC()
Convierte un carácter en su valor ASCII
------------------------------------------------------------------------------
Sintaxis
ASC(<cExp>) --> nC.digo
Argumentos
<cExp> es la expresión de carácteres que va a convertirse en un
número.
Devuelve
ASC() devuelve un valor numérico entero entre 0 y 255 que representa el
valor ASCII de <cExp>.
Descripción
ASC() es una función de conversión de carácteres que devuelve el valor
ASCII del carácter situado m.s a la izquierda de una cadena de
carácteres. ASC() se utiliza fundamentalmente en expresiónes que
requieran cálculos numéricos con el valor ASCII de un carácter. CHR() y
ASC() son funciónes inversas.
Ejemplos
. Los ejemplos siguientes muestran distintos resultados de
ASC():
? ASC("A") //Resultado: 65
? ASC("Apple") //Resultado: 65
? ASC("a") //Resultado: 97
? ASC("Z") - ASC("A") //Resultado: 25
? ASC("") //Resultado: 0
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ASCAN()
Examina una matriz, buscando un valor determinado o hasta que un bloque
devuelva el valor verdadero (.T.)
------------------------------------------------------------------------------
Sintaxis
ASCAN(<aDestáno>, <expB.squeda>,
[<nInicio>], [<nPosiciones>]) --> nParadaEn
Argumentos
<aDestáno> es la matriz que se va a examinar.
<expB.squeda> es el valor de tipo simple que se va a buscar o un
bloque de código. Si <expB.squeda> es un valor simple, puede ser de tipo
carácter, fecha, l.gico o numérico.
<nInicio> es el elemento donde se inicia la b.squeda. Si no se
especifica este argumento, la posición inicial por defecto es uno.
<nPosiciones> es el número de elementos que se van a examinar a
partir de la posición inicial. Si no se especifica este argumento, se
examinan todos los elementos, desde el elemento inicial hasta el final
de la matriz.
Devuelve
ASCAN() devuelve un valor numérico que representa la posición en la
matriz del último elemento examinado. Si <expB.squeda> es un valor
simple, ASCAN() devuelve la posición del primer elemento que coincida, o
cero si no se encuentra ningúno. Si <expB.squeda> es un bloque de
código, ASCAN() devuelve la posición del elemento donde el bloque
devuelve verdadero (.T.).
Descripción
ASCAN() es una función de matrices que busca un valor especificado en
una matriz. funcióna como SEEK cuando se busca un valor simple. El valor
de <expB.squeda> se compara con los elementos de la matriz de destáno,
empezando por el carácter situado m.s a la izquierda de cada elemento y
continúa.do hasta que no queden m.s carácteres en <expB.squeda>. Si no
encuentra ningúna coincidencia, ASCAN() continúa.en el siguiente
elemento de la matriz.
Como ASCAN() utiliza el operador igual (=) para las comparaciones, puede
distinguir el estado de EXACT. Si EXACT est. activado, el elemento de
matriz destáno debe ser exactamente igual que el resultado de
<expB.squeda> para que sean coincidentes.
Si el argumento <expB.squeda> es un bloque de código, ASCAN() examina la
matriz <aDestáno> ejecutando el bloque en todos los elementos a los que
se accede. A medida que encuentra cada elemento, ASCAN() pasa como
argumento el valor del elemento al bloque de código y ejecuta una
función EVAL() en el bloque. La operación.de b.squeda se detiene cuando
el bloque de código devuelve verdadero (.T.) o cuando ASCAN() llega al
último elemento de la matriz.
Ejemplos
. El ejemplo siguiente muestra el examen de una matriz de tres
elementos que contiene valores simples, con un bloque de código como
criterio de b.squeda. El criterio del bloque de código muestra la
forma de realizar una b.squeda que diferencie mayúsculas y
minúsculas:
aMatriz := { "Tom.s", "Mar.a", "Susana" }
? ASCAN(aMatriz, "Mar.a") //Resultado: 2
? ASCAN(aMatriz, "mar.a") //Resultado: 0
//
? ASCAN(aMatriz, { |x| UPPER(x) ;
== "MARIA" }) //Resultado: 2
. El ejemplo siguiente muestra una b.squeda de apariciones
m.ltiples de un argumento tras encontrar una coincidencia:
LOCAL aMatriz := { "Tom.s", "Mar.a", "Susana",;
"Mar.a" }, nInicio := 1
//
// Obtiene la posición del último elemento de la matriz
nEnFin := LEN(aMatriz)
DO WHILE (nPos := ASCAN(aMatriz, "Mar.a", ;
nInicio)) > 0
? nPos, aMatriz[nPos]
//
// Obtiene la nueva posición inicial y
// comprueba la condición l.mite
IF (nInicio := ++nPos) > nEnFin
EXIT
ENDIF
ENDDO
. El ejemplo siguiente examina una matriz bidimensiónal
utilizando un bloque de código. Observe que el parámetro aVal del
bloque de código es una matriz:
LOCAL aMat:={}
CLS
AADD(aMat,{"uno","dos"})
AADD(aMat,{"tres","cuatro"})
AADD(aMat,{"cinco","seis"})
? ASCAN(aMat, {|aVal| aVal[2] == "cuatro"}) // Resultado: 2
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ASIZE()
Amplía o reduce una matriz
------------------------------------------------------------------------------
Sintaxis
ASIZE(<aDestáno>, <nLongitud>) --> aDestáno
Argumentos
<aDestáno> matriz que se va a ampliar o reducir.
<nLongitud> es el nuevo tama.o de la matriz.
Devuelve
ASIZE() devuelve una referencia a la matriz destáno, <aDestáno>.
Descripción
ASIZE() es una función de tratamiento de matrices que cambia la longitud
real de la matriz <aDestáno>. La matriz se acorta o se alarga hasta que
coincida con la longitud especificada. Si la matriz se acorta, los
elementos que se encuentren al final de la misma se pierden. Si la
matriz se alarga, se a.aden nuevos elementos al final de la matriz y se
les asigna el valor NIL.
ASIZE() es similar a AADD(), que a.ade un nuevo elemento al final de una
matriz y, si se desea, le asigna un nuevo valor. Recuerde que ASIZE() es
diferente a AINS() y ADEL(), que no cambian realmente la longitud de la
matriz.
Ejemplos
. Los ejemplos siguientes muestran la adici.n de nuevos
elementos y el borrado de elementos existentes:
aMatriz := { 1 } //Resultado: aMatriz es { 1 }
ASIZE(aMatriz, 3) //Resultado: aMatriz es { 1, NIL, NIL }
ASIZE(aMatriz, 1) //Resultado: aMatriz es { 1 }
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ASORT()
Ordena una matriz
------------------------------------------------------------------------------
Sintaxis
ASORT(<aDestáno>, [<nInicio>],
[<nPosiciones>], [<bOrden>]) --> aDestáno
Argumentos
<aDestáno> es la matriz que se va a ordenar.
<nInicio> es el primer elemento que se va a ordenar. Si no se
especifica, la posición inicial por defecto es uno.
<nPosiciones> es el número de elementos que se van a ordenar. Si no
se especifica, se ordenan todos los elementos de la matriz desde el
elemento inicial.
<bOrden> es un bloque de código opciónal que se utiliza para
determinar el criterio de ordenación. Si no se especifica, el criterio
por defecto es ascendente.
Devuelve
ASORT() devuelve una referencia a la matriz <aDestáno>.
Descripción
ASORT() es una función de matrices que clasifica, total o parcialmente,
una matriz que contiene elementos del mismo tipo de datos. Los tipos de
datos que pueden ordenarse son carácteres, fechas, valores lógicos y
numéricos.
Si no se especifica el argumento <bOrden>, el orden por defecto es
ascendente. Los elementos con valores bajos se sit.an al principio de la
matriz (primer elemento) y los elementos con valores altos se colocan al
final de la misma (último elemento).
Si se especifica un argumento <bOrden> en forma de bloque, el bloque se
eval.a para determinar el orden de clasificaci.n. Cada vez que se eval.a
el bloque, se le pasan como parámetros dos elementos de la matriz
destáno. El bloque devuelve verdadero (.T.) si los elementos están en el
orden correcto. Esta opción permite crear un criterio de ordenación
descendente o cualquier otro. Consulte los ejemplos siguientes.
Al ordenarse, las cadenas de carácteres se sit.an secuencialmente seg.n
el valor de su código ASCII, los valores lógicos se clasifican con falso
(.F.) como valor bajo; los valores de fecha se clasifican
cronol.gicamente; y los valores numéricos se clasifican por su magnitud.
Nota: Como CA-Clipper crea las matrices multidimensiónales anidando
submatrices dentro de otras matrices, ASORT() no puede ordenar
directamente una matriz multidimensiónal. Para ordenar una matriz
anidada, debe especificarse un bloque de código que permita manejar
adecuadamente submatrices.
Ejemplos
. El ejemplo siguiente crea una matriz de cinco elementos sin
ordenar, la clasifica en orden ascendente y, a continúa.ión, la
clasifica en orden descendente con un bloque de código:
aMatriz := { 3, 5, 1, 2, 4 }
ASORT(aMatriz)
//Resultado: { 1, 2, 3, 4, 5 }
ASORT(aMatriz,,, { |x, y| x > y })
//Resultado: { 5, 4, 3, 2, 1 }
. El ejemplo siguiente ordena una matriz de cadenas de
carácteres en orden ascendente, sin diferenciar mayúsculas o
minúsculas. Para ello, utiliza un bloque de código que convierte los
elementos en mayúsculas antes de compararlos:
aMatriz := { "Federico", "Catalina", "ALBERTO", "amigo" }
ASORT(aMatriz,,, { |x, y| UPPER(x) < UPPER(y) })
. El ejemplo siguiente clasifica una matriz anidada utilizando
el segundo elemento de cada submatriz:
aChicos := { {"Mar.a", 14}, {"Jos.", 23}, {"Arturo", 16} }
aClasifChicos := ASORT(aChicos,,, { |x, y| x[2] < y[2] })
Resultado:
{ {"Mar.a", 14}, {"Arturo", 16}, {"Jos.", 23} }
Ficheros: La biblioteca asociada es EXTEND.LIB.
AT()
Devuelve la posición de una subcadena dentro de una cadena de carácteres
------------------------------------------------------------------------------
Sintaxis
AT(<cB.squeda>, <cDestáno>) --> nPosici.n
Argumentos
<cB.squeda> es la subcadena de carácteres que se va a buscar.
<cDestáno> es la cadena de carácteres en la que se realiza la
b.squeda.
Devuelve
AT() devuelve la posición de la primera aparici.n de <cB.squeda> dentro
de <cDestáno>, como valor numérico entero. Si no se encuentra
<cB.squeda>, AT() devuelve cero.
Descripción
AT() es una función de tratamiento de carácteres que se utiliza para
determinar la posición de la primera aparici.n de una subcadena dentro
de otra cadena. Si sólo necesita saber si una subcadena se encuentra
dentro de otra, utilice el operador $. Para encontrar la .ltima
aparici.n de una cadena dentro de otra, utilice RAT().
Ejemplos
. Los ejemplos siguientes muestran la utilización normal de
AT():
? AT("a", "abcde") //Resultado: 1
? AT("bcd", "abcde") //Resultado: 2
? AT("a", "bcde") //Resultado: 0
. El ejemplo siguiente divide una cadena de carácteres bas.ndose
en la posición de una coma en la cadena destáno:
cDestáno := "L.pez, Luisa"
? SUBSTR(cDestáno, 1, AT(",", cDestáno) - 1)
//Resultado: L.pez
? SUBSTR(cDestáno, AT(",", cDestáno) + 2)
//Resultado: Luisa
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ATAIL()
Devuelve el último elemento de una matriz
------------------------------------------------------------------------------
Sintaxis
ATAIL(<aMatriz>) --> Elemento
Argumentos
<aMatriz> es la matriz que se va a tratar.
Devuelve
ATAIL() devuelve un valor o una referencia a una matriz u objeto. La
matriz no se modifica.
Descripción
ATAIL() es una función de matrices que devuelve el elemento de una
matriz que tenga el número m.s alto. Puede utilizarse en las
aplicaciónes como forma abrevíada de <aMatriz>[LEN(<aMatriz>)] cuando
necesite obtener el último elemento de una matriz.
Ejemplos
. El ejemplo siguiente crea una matriz literal y devuelve el
último elemento de la misma:
aMatriz := {"a", "b", "c", "d"}
? ATAIL(aMatriz) //Resultado: "d"
Ficheros: La biblioteca asociada es CLIPPER.LIB.
