RAT()
Devuelve la posición de la .ltima aparici.n de una subcadena en una cadena
dada
------------------------------------------------------------------------------
Sintaxis
RAT(<cB.squeda>, <cDestáno>) --> nPosici.n
Argumentos
<cB.squeda> es la cadena de carácteres que se desea buscar.
<cDestáno> es la cadena de carácteres en la que se busca.
Devuelve
RAT() devuelve la posición de <cB.squeda> en <cDestáno>, en forma de
valor numérico entero. Si <cB.squeda> no se encuentra, RAT() devuelve
cero.
Descripción
RAT() es una función que devuelve la posición de la .ltima aparici.n de
una subcadena de carácteres en otra cadena . Para ello, examina la
cadena de destáno empezando por la derecha. RAT() es similar a la
función AT(), que devuelve la posición de la primera aparici.n de una
subcadena dentro de otra cadena. También es similar al operador $, que
determina si una subcadena est. contenida en una cadena.
Tanto la función RAT() como la función AT() se utilizan con SUBSTR(),
LEFT() y RIGHT() para extraer subcadenas.
Ejemplos
. Este ejemplo utiliza RAT() para crear una función,
ViaFichero(), que extrae la vía de una especificación de fichero. Si
no se especifica una vía, devuelve una cadena nula (""):
? ViaFichero("C:\DBF\Sales.dbf") // Resultado: C:\DBF\
FUNCTION ViaFichero(cFichero)
LOCAL nPos, cViaFichero
IF (nPos := RAT("\", cFichero)) != 0
cViaFichero = SUBSTR(cFichero, 1, nPos)
ELSE
cViaFichero = ""
ENDIF
RETURN cViaFichero
Ficheros: La biblioteca asociada es EXTEND.LIB.
READEXIT()
Activa o desactiva las flechas Arriba y Abajo como teclas de salida del READ
------------------------------------------------------------------------------
Sintaxis
READEXIT([<lActivar/desactivar>]) --> lEstadoActual
Argumentos
<lActivar/desactivar> activa o desactiva la utilización de las
flechas Arriba y Abajo como teclas de salida de un mandato READ. Si se
especifica verdadero (.T.), se activan como teclas de salida y, si se
especifica falso (.F.), se desactivan.
Devuelve
READEXIT() devuelve la selecci.n actual, en forma de valor l.gico.
Descripción
READEXIT() es una función de entorno que informa del estado actual de
las flechas Arriba y Abajo como teclas de salida del mandato READ desde
el primer o último objeto Get de una GetList. Si se especifica el
argumento opciónal <lActivar/desactivar>, estas teclas se activan o
desactivan como teclas de salida. Cuando se arranca el programa, Arriba
y Abajo no están activadas como teclas de salida de READ. Normalmente,
las teclas de salida de READ incluyen .nicamente ReP.g, AvP.g, Esc o
Intro desde el último objeto GET.
Ejemplos
. Este ejemplo muestra c.mo READEXIT() activa Arriba y Abajo
como teclas de salida antes de un mandato READ y las desactiva al
finalizar el mismo:
cMiVar = SPACE(10)
lUltimaSalida = READEXIT(.T.) // Resultado:
// Activa las teclas de salida
@ 10, 10 SAY "Intro: " GET cMiVar
READ
READEXIT(lUltimaSalida) // Resultado:
// Restablece la selecci.n anterior
Ficheros: La biblioteca asociada es CLIPPER.LIB.
READINSERT()
Activa o desactiva el modo de inserci.n para los mandatos READ y MEMOEDIT()
------------------------------------------------------------------------------
Sintaxis
READINSERT([<lActivar/desactivar>]) --> lModoActual
Argumentos
<lActivar/desactivar> activa o desactiva el modo de inserci.n.
Verdadero (.T.) lo activa y falso (.F.) lo desactiva. El valor por
defecto es falso (.F.) o el último modo seleccionado por el usuario con
un mandato READ o MEMOEDIT().
Devuelve
READINSERT() devuelve el estado actual del modo de inserci.n, en forma
de valor l.gico.
Descripción
READINSERT() es una función de entorno que informa del estado actual del
modo de inserci.n de los mandatos READ y MEMOEDIT() y, opciónalmente, lo
activa o desactiva, dependiendo del valor de <lActivar/desactivar>. Si
READINSERT() devuelve falso (.F.), los carácteres se sobreescriben al
introducir el usuario carácteres en la memoria intermedia de un objeto
mediante un mandato READ o MEMOEDIT(). Si READINSERT() devuelve
verdadero (.T.), los carácteres introducidos se insertan. El modo de
inserci.n pertenece a la configuración global del sistema y no a un
objeto determinado.
READINSERT() puede ejecutarse antes o durante un mandato READ o
MEMOEDIT(). Si se utiliza con READ, READINSERT() puede invocarse en una
cláusula WHEN o VALID de @...GET o en un procedimiento SET KEY. Si se
utiliza con MEMOEDIT(), puede invocarse con la función de usuario, as.
como con un procedimiento SET KEY.
Ejemplos
. Este ejemplo fija el modo de inserci.n antes de entrar en
MEMOEDIT() y reinicializa el modo cuando MEMOEDIT() finaliza:
USE Ventas NEW
// Activar el modo de inserci.n
lModoIns = READINSERT(.T.)
Ventas->Notas := MEMOEDIT(Ventas->Notas)
// Restablecer el modo de inserci.n anterior
READINSERT(lModoIns)
Ficheros: La biblioteca asociada es CLIPPER.LIB.
READKEY()*
Determina qu. tecla ha finalizado un mandato READ
------------------------------------------------------------------------------
Sintaxis
READKEY() --> nC.digoTeclaRead
Devuelve
READKEY() devuelve un código que representa la tecla que se ha pulsado
para salir de un READ. En CA-Clipper, las siguientes son las teclas de
salida estándar de READ y sus códigos de retorno READKEY():
C.digos de Retorno de READKEY()
------------------------------------------------------------------------
Tecla de Salida C.digo de Retorno
------------------------------------------------------------------------
Arriba 5
Abajo 2
ReP.g 6
AvP.g 7
Ctrl-ReP.g 31
Ctrl-AvP.g 30
Esc 12
Ctrl-Fin, Ctrl-W 14
Escribir m.s all. del fin 15
Intro 15
------------------------------------------------------------------------
Descripción
READKEY() es una función de teclado que emula a la función READKEY() de
dBASE III PLUS. Su finalidad es determinar qu. tecla ha pulsado el
usuario para finalizar un READ. Si UPDATED() es verdadero (.T.),
READKEY() devuelve el código m.s 256. S.lo pueden utilizarse Arriba y
Abajo para salir de un mandato READ si READEXIT() vale verdadero (.T.).
El valor por defecto es falso (.F.). Para permitir una completa
compatibilidad de estas teclas, ejecute READEXIT (.T.) al principio de
su procedimiento principal.
READKEY() se incluye como función de compatibilidad, por lo que su
utilización no es recomendable. Puede sustituirse completamente por
LASTKEY(), que determina la .ltima pulsaci.n obtenida de la memoria
intermedia del teclado. Si la pulsaci.n fue una tecla de salida de READ,
LASTKEY() devuelve el código de INKEY() de esta tecla. Para determinar
si se ha modificado la memoria intermedia de un objeto Get durante un
READ, puede sustituirse por la función UPDATED().
Ficheros: La biblioteca asociada es EXTEND.LIB,
el fichero fuente es SOURCE\SAMPLE\READKEY.PRG
READMODAL()
Activa el modo de edici.n de pantalla completa de la GetList
------------------------------------------------------------------------------
Sintaxis
READMODAL(<aGetList>) --> NIL
Argumentos
<aGetList> es una matriz que contiene la lista de objetos Get que se
van a editar.
Devuelve
READMODAL() devuelve siempre NIL.
Descripción
READMODAL() es una función de interfaz de usuario que activa el modo de
pantalla completa para objetos GET. Forma parte del sistema Get de
arquitectura abierta de CA-Clipper. READMODAL() es similar al mandato
READ, excepto en que toma una matriz GetList como argumento y no
reinicializa la matriz cuando finaliza. Debido a esto, es posible
utilizar m.ltiples listas de objetos Get y activarlas en cualquier
momento de la ejecución de un programa, siempre que la matriz que se va
a utilizar est. visible.
Por compatibilidad con las versiones anteriores de CA-Clipper, el
sistema GET utiliza una matriz pública llamada GetList. Cada vez que se
ejecuta un mandato @...GET, .ste crea un objeto Get y lo a.ade a la
matriz GetList actualmente visible. El mandato READ estándar se
preprocesa mediante una llamada a READMODAL(), que utiliza la matriz
GetList como argumento. Si no se especifica la cláusula SAVE, se asigna
a la variable GetList una matriz vac.a cuando finaliza READMODAL().
Algunas de las funciónes de Getsys.prg se han hecho públicas para que
puedan utilizarse con otros sistemas Get personalizados. En la siguiente
tabla se listan estas funciónes.
funciónes del Sistema Get
------------------------------------------------------------------------
función Descripción
------------------------------------------------------------------------
GETACTIVE() Devuelve el objeto Get actualmente activo
GETAPPLYKEY() Aplica una tecla a un objeto Get desde una rutina de
lectura del Get
GETDOSETKEY() Procesa SET KEY durante la edici.n del objeto GET
GETPOSTVALIDATE() Eval.a la postcondición del objeto Get actual
GETPREVALIDATE() Eval.a la precondición del objeto Get actual
GETREADER() Ejecuta las acciones READ estándares para un objeto
Get
READFORMAT() Devuelve, y opciónalmente establece, el bloque de
código que define un fichero de formato (.fmt)
READKILL() Devuelve, y opciónalmente establece, si debe salirse
del Read actual
READUPDATED() Devuelve, y opciónamente establece, si un objeto Get
se ha modificado durante un Read
------------------------------------------------------------------------
Si desea información sobre los objetos Get y las funciónes antes
listadas, consulte el capítulo El Sistema Get de la guía de Programación
y Utilidades.
Si desea más información sobre las teclas que pueden utilizarse por
defecto con la función READMODAL(), consulte la referencia del mandato
READ de este capítulo.
Ficheros: La biblioteca asociada es CLIPPER.LIB,
el fichero fuente es SOURCE\SYS\GETSYS.PRG
READVAR()
Devuelve el nombre de la variable del Get o del Men. actual
------------------------------------------------------------------------------
Sintaxis
READVAR() --> cNombreVar
Devuelve
READVAR() devuelve el nombre de la variable asociada con el objeto Get
actual o el de la variable asignada mediante el mandato MENU TO, como
una cadena de carácteres en mayúsculas.
Descripción
READVAR() es una función de entorno que se utiliza, fundamentalmente,
para generaráayudas sensibles al contexto para objetos Get y men.s de
barra. READVAR() sólo puede utilizarse con los mandatos READ o MENU TO.
Si se utiliza durante cualquier otro estado de espera, como ACCEPT,
INPUT, WAIT, ACHOICE(), DBEDIT() o MEMOEDIT(), devuelve una cadena nula
(""). Es habitual acceder a ella desde un procedimiento SET KEY o
función invocada con una cláusula WHEN o VALID de un objeto Get.
Ejemplos
. Este ejemplo crea un sistema sencillo de ayuda para objetos
Get, utilizando un fichero de base de datos para almacenar el texto
de ayuda. Cuando el usuario pulsa F1, se busca en el fichero
utilizando READVAR() como valor clave y, si existe texto de ayuda, se
muestra en una ventana:
#include "Inkey.ch"
//
SET KEY K_F1 TO ConsultaAyuda
cCadena = SPACE(10)
@ 5, 5 SAY "Intro:" GET cCadena
READ
RETURN
FUNCTION ConsultaAyuda
USE Ayuda INDEX Ayuda NEW
SEEK READVAR()
IF FOUND()
MostrarAyuda(Ayuda->Tema)
ELSE
MostrarAyuda("No hay ayuda sobre " + READVAR())
ENDIF
CLOSE Ayuda
RETURN NIL
FUNCTION MostrarAyuda(cTema)
LOCAL cPantalla := SAVESCREEN(5,5,15,70),;
cColor := SETCOLOR("BG+/B")
//
SET CURSOR OFF
@ 5, 5 CLEAR TO 15, 70
@ 5, 5 TO 15, 70 DOUBLE
@ 5, 30 SAY " Ayuda para " + READVAR() + " "
MEMOEDIT(cTema, 6, 7, 14, 68, .F.)
//
RESTSCREEN(5, 5, 15, 70, cPantalla)
SETCOLOR(cColor)
SET CURSOR ON
//
RETURN NIL
Ficheros: La biblioteca asociada es CLIPPER.LIB.
RECCOUNT()*
Determina el número de registros del fichero (.dbf) actual
------------------------------------------------------------------------------
Sintaxis
RECCOUNT()* | LASTREC() --> nRegistros
Devuelve
RECCOUNT() devuelve el número de registros f.sicos existentes en el
fichero actual de base de datos, en forma de valor numérico entero. Los
mandatos de filtro como SET FILTER o SET DELETED no afectan al valor
devuelto. RECCOUNT() devuelve cero si no hay ningún fichero de base de
datos abierto en el área de trabajo actual.
Descripción
RECCOUNT() es una función de base de datos similar a LASTREC(). Por
defecto, RECCOUNT() opera en el área de trabajo actual. Si desea
utilizarla en otra área de trabajo, debe especificarla mediante una
expresión de alias (consulte el ejemplo siguiente).
Ejemplos
. Este ejemplo ilustra la relaci.n que existe entre COUNT y
RECCOUNT():
USE Ventas NEW
? RECCOUNT() // Resultado: 84
//
SET FILTER TO Vendedor = "1001"
COUNT TO nRegistros
? nRegistros // Resultado: 14
? RECCOUNT() // Resultado: 84
. Este ejemplo utiliza una expresión de alias para acceder al
número de registros de un área de trabajo no seleccionada:
USE Ventas NEW
USE Cliente NEW
? RECCOUNT(), Ventas->(RECCOUNT())
Ficheros: La biblioteca asociada es CLIPPER.LIB.
RECNO()
Devuelve el número del registro actual de un área de trabajo
------------------------------------------------------------------------------
Sintaxis
RECNO() --> nRegistro
Devuelve
RECNO() devuelve el número del registro actual, en forma de valor
numérico entero. Si el área de trabajo contiene un fichero con cero
registros, RECNO() devuelve uno, BOF() y EOF() devuelven verdadero (.T.)
y LASTREC() devuelve cero.
Si el puntero se desplaza m.s all. del último registro, RECNO() devuelve
LASTREC() + 1 y EOF() devuelve verdadero (.T.). Si se intenta desplazar
antes del primer registro, RECNO() devuelve el número del primer
registro l.gico del fichero de base de datos y BOF() devuelve verdadero
(.T.). Si no hay un fichero de base de datos abierto, RECNO() devuelve
cero.
Descripción
RECNO() es una función de base de datos que devuelve el número del
registro actual de un área de trabajo. En el esquema de ficheros de base
de datos de CA-Clipper, todos los ficheros se ordenan f.sicamente por
los números de registro. A su vez, todas las áreas de trabajo tienen un
puntero en el registro actual de su fichero abierto. RECNO() informa de
este número de registro. La numeraci.n permite accerder directamente a
un registro sin tener que examinar todo el fichero para llegar al
registro especificado.
RECNO() se utiliza normalmente con rutinas que procesan los registros
por su número. Estas incluyen SET RELATION...TO RECNO(), que enlaza
ficheros de base de datos por números de registro. GO RECNO() actualiza
también los datos del registro actual del disco.
Por defecto, RECNO() opera en el área de trabajo actual. Si desea
utilizarla en un área de trabajo no seleccionada, debe especificarla en
una expresión de alias (consulte el ejemplo siguiente).
Ejemplos
. Este ejemplo consulta RECNO() tras desplazar intencionadamente
el puntero de registro:
USE Clientes NEW
GO 3
? RECNO() // Resultado: 3
GO TOP
? RECNO() // Resultado: 1
nRegistro := 3
GO nRegistro
? RECNO() // Resultado: 3
GO BOTTOM
SKIP
? RECNO(), LASTREC() // Resultado: 11 10
. Este ejemplo utiliza expresiónes de alias para obtener el
valor de RECNO() en .reas de trabajo no seleccionadas:
USE Ventas NEW
USE Cliente NEW
//
? Ventas->(RECNO())
? Cliente->(RECNO())
Ficheros: La biblioteca asociada es CLIPPER.LIB.
RECSIZE()
Determina el tama.o de un registro de un fichero de base de datos (.dbf)
------------------------------------------------------------------------------
Sintaxis
RECSIZE() --> nBytes
Devuelve
RECSIZE() devuelve, como valor numérico entero, la longitud en bytes de
un registro del fichero de base de datos abierto en el área de trabajo
actual. Si no hay un fichero de base de datos abierto, RECSIZE()
devuelve cero.
Descripción
RECSIZE() es una función de base de datos que determina la longitud de
un registro, sumando lasólongitudes de cada campo y, a continúa.ión, uno
para el indicador de estado DELETED(). Si este valor se multiplica por
LASTREC(), el resultado es el espacio ocupado por todos los registros
del fichero.
RECSIZE() es útil en programas que realicen autom.ticamente copias de
seguridad del fichero. Si se utiliza con DISKSPACE(), la función
RECSIZE() permite comprobar la existencia de espacio libre suficiente en
el disco antes de guardar un fichero.
Por defecto, RECSIZE() opera en el área de trabajo actual. Si desea
utilizarla en un área de trabajo no seleccionada, debe especificarla en
una expresión de alias (consulte el ejemplo siguiente).
Ejemplos
. La siguiente función, TamanoDbf(), utiliza RECSIZE() para
calcular el tama.o del fichero actual de base de datos:
FUNCTION TamanoDbf
RETURN ((RECSIZE() * LASTREC()) + HEADER() + 1)
. Este ejemplo muestra la forma de utilización de RECSIZE() para
determinar la longitud de registro de un fichero abierto en un .rea
de trabajo no seleccionada.
USE Cliente NEW
USE Ventas NEW
//
? RECSIZE(), Cliente->(RECSIZE())
? TamanoDbf(), Cliente->(TamanoDbf())
Ficheros: La biblioteca asociada es EXTEND.LIB.
REPLICATE()
Devuelve una cadena, repetida el número de veces especificado
------------------------------------------------------------------------------
Sintaxis
REPLICATE(<cCadena>, <nVeces>) --> cCadenaRepetida
Argumentos
<cCadena> es la cadena de carácteres que se va a repetir.
<nVeces> es el número de veces que se va a repetir <cCadena>.
Devuelve
REPLICATE() devuelve una cadena de carácteres de una longitud máxima de
65.535 (64K) bytes. Si se especifica cero como argumento <nVeces>,
devuelve una cadena nula ("").
Descripción
REPLICATE() es una función de carácteres que muestra, imprime o llena la
memoria del teclado con uno o m.s carácteres repetidos. REPLICATE() es
similar a la función SPACE(), que devuelve el número especificado de
carácteres de espacio.
Ejemplos
. Estos ejemplos muestran la repetición de cadenas por medio de
REPLICATE():
? REPLICATE("*", 5) // Resultado: *****
? REPLICATE("Hola", 2) // Resultado: Hola Hola
? REPLICATE(CHR(42), 5) // Resultado: *****
. Este ejemplo utiliza REPLICATE() para llenar la mamoria del
teclado con varias flechas Abajo:
#include "Inkey.ch"
KEYBOARD REPLICATE(CHR(K_DN), 25)
Ficheros: La biblioteca asociada es CLIPPER.LIB.
RESTSCREEN()
Muestra una zona de pantalla prevíamente guardada, en la posición
especificada
------------------------------------------------------------------------------
Sintaxis
RESTSCREEN([<nSuperior>], [<nIzquierda>], [<nInferior>],
[<nDerecha>], <cPantalla>) --> NIL
Argumentos
<nSuperior>, <nIzquierda>, <nInferior> y <nDerecha>
definen las coordenadas de la información de pantalla contenida en
<cPantalla>. Si no se especificaron coordenadas con <cPantalla> para que
se guardara toda la pantalla, tampoco son necesarias con RESTSCREEN().
<cPantalla> es una cadena de carácteres que contiene la zona de
pantalla guardada.
Devuelve
RESTSCREEN() devuelve siempre NIL.
Descripción
RESTSCREEN() es una función que vuelve a mostrar una zona de pantalla
guardada con SAVESCREEN(). La posición de destáno puede ser la posición
de pantalla original u otra diferente. Si se especifica una nueva
posición, la nueva zona debe tener el mismo tama.o que la antigua o se
obtendr.n resultados ambiguos. Al utilizar RESTSCREEN() para recuperar
secciones de pantalla guardadas con SAVE SCREEN, pueden especificarse
coordenadas comprendidas entre 0, 0,y MAXROW(), MAXCOL().
.Advertencia! SAVE SCREEN, RESTORE SCREEN, SAVESCREEN() y
RESTSCREEN() sólo pueden utilizarse con el controlador de pantalla por
defecto. Otros controladores pueden no permitir guardar y recuperar las
pantallas.
Ejemplos
. Este ejemplo muestra RESTSCREEN() como parte de una función de
men. emergente de uso general, MenuEmerg():
? MenuEmerg({1, 1, 3, 10, {"ElementoUno", "ElementoDos"}, ;
"BG+/B"})
FUNCTION MenuEmerg(aLista)
LOCAL cPantalla, nSeleccion, cAntiguoColor := ;
SETCOLOR(aLista[6])
cPantalla := SAVESCREEN(aLista[1], aLista[2],;
aLista[3], aLista[4])
@ aLista[1], aLista[2] TO aLista[3], aLista[4] DOUBLE
nSeleccion := ACHOICE(++aLista[1], ++aLista[2],;
--aLista[3], --aLista[4], aLista[5])
SETCOLOR(cAntiguoColor)
RESTSCREEN(--aLista[1], --aLista[2], ++aLista[3],;
++aLista[4], cPantalla)
RETURN nSeleccion
Ficheros: La biblioteca asociada es EXTEND.LIB.
RIGHT()
Devuelve una subcadena, comenzando por el carácter situado m.s a la derecha
------------------------------------------------------------------------------
Sintaxis
RIGHT(<cCadena>, <nPosiciones>) --> cSubCadena
Argumentos
<cCadena> es la cadena de carácteres de la que se extraen los
carácteres.
<nPosiciones> es el número de carácteres que se van a extraer.
Devuelve
RIGHT() devuelve <nPosiciones> carácteres, contados desde el extremo
derecho de <cCadena>. Si <nPosiciones> es cero, RIGHT() devuelve una
cadena nula (""). Si <nPosiciones> es un número negativo o mayor que la
longitud de la cadena de carácteres, RIGHT() devuelve <cCadena>. El
máximo tama.o de una cadena es de 65.535 (64K) bytes.
Descripción
RIGHT() es una función de carácteres que extrae una subcadena comenzando
por el carácter situado m.s a la derecha de <cCadena>. Es id.ntica a la
expresión de carácteres SUBSTR(<cCadena>, -<nPosiciones>). Por ejemplo,
RIGHT("ABC", 1) esólo mismo que SUBSTR("ABC", -1). RIGHT() est.
relacionada con LEFT(), que extrae una subcadena comenzando por el
carácter m.s a la izquierda de <cCadena>.
Las funciónes RIGHT(), LEFT() y SUBSTR() se utilizan frecuentemente con
las funciónes AT() y RAT() para localizar la primera y/o .ltima posición
de una subcadena antes de extraerla.
Ejemplos
. Este ejemplo muestra la relaci.n que existe entre RIGHT() y
SUBSTR():
? RIGHT("ABCDEF", 3) // Resultado: DEF
? SUBSTR("ABCDEF", -3) // Resultado: DEF
. Este ejemplo extrae una subcadena, desde el final de otra
cadena hasta la .ltima aparici.n de una coma:
LOCAL cNombre := "Jaime,Guillermo"
? RIGHT(cNombre,;
LEN(cNombre) - RAT(",", cNombre) - 1) // Resultado: Guillermo
Ficheros: La biblioteca asociada es EXTEND.LIB.
RLOCK()
Bloquea el registro actual del área de trabajo activa
------------------------------------------------------------------------------
Sintaxis
RLOCK() --> lExito
Devuelve
RLOCK() devuelve verdadero (.T.) si se bloquea el registro; y falso
(.F.) en caso contrario.
Descripción
RLOCK() es una función de red que bloquea el registro actual, impidiendo
que otros usuarios puedan actualizar ese registro hasta que se libere.
RLOCK() permite un bloqueo compartido y los otros usuarios tienen acceso
de sólo lectura al registro bloqueado. S.lo se permite modificarlo al
usuario actual. El bloqueo de registro se mantiene hasta que se bloquee
otro registro, se ejecute un mandato UNLOCK, se cierre el fichero de
base de datos o se ejecute un FLOCK() en el fichero actual.
Por cada invocaci.n de RLOCK(), se realiza un intento de bloquear el
registro actual y el resultado se devuelve como valor l.gico. Los
intentos de bloqueo de un registro fallan cuando otro usuario ha
bloqueado o est. utilizando en modo exclusivo el fichero actual. Si se
intenta ejecutar RLOCK() en una base de datos vac.a, se devuelve
verdadero (.T.).
Por defecto, RLOCK() opera en el área de trabajo actual. Si desea
utilizarla en un área de trabajo no seleccionada, debe especificarla en
una expresión de alias (consulte el ejemplo siguiente). Esto puede ser
muy .til porque RLOCK() no intenta autom.ticamente bloquear los
registros de ficheros relacionados.
Normalmente, RLOCK() opera .nicamente en el registro actual. Esto
incluye los siguientes mandatos:
. @...GET
. DELETE (un registro)
. RECALL (un registro)
. REPLACE (un registro)
Si desea más información, consulte el capítulo Programaci.n en Red de la
guía de Programación y Utilidades.
Notas
. SET RELATION: CA-Clipper no bloquea autom.ticamente todos
los registros de la cadena de relaci.n cuando el usuario bloquea el
registro del área de trabajo actual. Asimismo, un mandato UNLOCK no
afecta a las .reas de trabajo relacionadas.
Ejemplos
. Este ejemplo borra un registro en un entorno de red utilizando
RLOCK():
USE Clientes INDEX NombreCli SHARED NEW
SEEK "Martinez"
IF FOUND()
IF RLOCK()
DELETE
? "Martinez ha sido borrado"
ELSE
? "Otro usuario est. utilizando el registro"
ENDIF
ELSE
? "Martinez no se encuentra en el fichero Clientes"
ENDIF
CLOSE
. Este ejemplo especifica RLOCK() en una expresión de alias para
bloquear un registro en un área de trabajo no seleccionada:
USE Ventas SHARED NEW
USE Clientes SHARED NEW
//
IF !Ventas->(RLOCK())
? "Otro usuario est. utilizando el registro Ventas actual"
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ROUND()
Devuelve un valor numérico, redondeado con el número de cifras especificado
------------------------------------------------------------------------------
Sintaxis
ROUND(<nNúmero>, <nDecimales>) --> nRedondeado
Argumentos
<nNúmero> es el valor numérico que se va a redondear.
<nDecimales> define el número de decimales que se mantienen. Si se
especifica un valor negativo, se redondean números enteros.
Devuelve
ROUND() devuelve un valor numérico.
Descripción
ROUND() es una función numérica que redondea <nNúmero> con el número de
decimales especificado con <nDecimales>. Si se especifica cero o un
valor negativo en <nDecimales> se redondea el número entero. Un valor
negativo de <nDecimales> indica el número de cifras a la izquierda de la
coma decimal que se van a redondear. Las cifras entre cinco y nueve,
ambos inclusive, se redondean por encima y las cifras inferiores a cinco
se redondean por debajo.
La visualización del valor devuelto no obedece el valor de DECIMALS, a
menos que se haya establecido SET FIXED ON. Si se ha establecido SET
FIXED OFF, la visualización del valor devuelto contiene tantas cifras
decimales como las especificadas en <nDecimales> o cero, si <nDecimales>
es menor de uno.
Ejemplos
. Estos ejemplos redondean valores con cifras decimales:
SET DECIMALS TO 2
SET FIXED ON
//
? ROUND(10.4, 0) // Resultado: 10.00
? ROUND(10.5, 0) // Resultado: 11.00
? ROUND(10.51, 0) // Resultado: 11.00
? ROUND(10.49999999999999, 2) // Resultado: 10.50
. Estos ejemplos utilizan un argumento <nDecimales> negativo y
redondean valores numéricos en números enteros:
? ROUND(101.99, -1) // Resultado: 100.00
? ROUND(109.99, -1) // Resultado: 110.00
? ROUND(109.99, -2) // Resultado: 100.00
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ROW()
Devuelve la fila actual del cursor
------------------------------------------------------------------------------
Sintaxis
ROW() --> nFila
Devuelve
ROW() devuelve la posición de fila del cursor, en forma de valor
numérico entero. El rango del valor devuelto es de cero a MAXROW().
Descripción
ROW() es una función de pantalla que devuelve la posición de fila o
línea actual del cursor en la pantalla. El valor de ROW() se actualiza
por los mandatos y funciónes, tanto de consola como de pantalla
completa. @...SAY sólo actualiza ROW() cuando se ha establecido SET
DEVICE TO SCREEN.
ROW() se utiliza con COL() y todas las variantes del mandato @ para
colocar el cursor en una nueva línea respecto a la línea actual. En
concreto, ROW() y COL() pueden utilizarse para crear procedimientos y
funciónes de posición independiente, en los que la fila y columna
superior izquierda se pasan como parámetros.
ROW() está relacionada con PROW() y PCOL(), que controla la posición
actual del cabezal de la impresora en vez de la posición del cursor.
Ejemplos
. En este ejemplo, ROW() simula el mandato LIST, mostrando el
texto en la misma línea, pero en diferentes columnas:
LOCAL nFila
USE Cliente INDEX NombreCli NEW
DO WHILE .NOT. EOF()
CLS
@ 1, 1 SAY PADR("Nombre" LEN(CNombreCli))
@ ROW(), COL() + 2 SAY PADR("Direccion", ;
LEN(Direccion))
@ ROW(), COL() + 2 SAY PADR("Tel.fono", LEN(Telefono))
nFila = 0
DO WHILE nFila++ <= 15 .AND. (!EOF())
@ ROW() + 1, 1 SAY NombreCli
@ ROW(), COL() + 2 SAY Direccion
@ ROW(), COL() + 2 SAY Telefono
SKIP
ENDDO
WAIT
ENDDO
CLOSE Cliente
Ficheros: La biblioteca asociada es CLIPPER.LIB.
RTRIM()
Suprime los espacios finales de una cadena de carácteres
------------------------------------------------------------------------------
Sintaxis
[R]TRIM(<cCadena>) --> cCadenaSuprim
Argumentos
<cCadena> es la cadena de carácteres que se va a copiar sin espacios
finales.
Devuelve
RTRIM() devuelve una copia de <cCadena> sin espacios finales. Si
<cCadena> es una cadena nula ("") o todo espacios, RTRIM() devuelve una
cadena nula ("").
Descripción
RTRIM() es una función que formatea cadenas de carácteres. Sirve para
borrar espacios finales al concatenar cadenas, lo que ocurre con mucha
frecuencia en los campos de base de datos que se almacenan con un
formato de anchura fija. Por ejemplo, RTRIM() puede utilizarse para
concatenar los campos que contienen el nombre y el apellido para formar
una cadena con el nombre completo.
RTRIM() está relacionada con LTRIM(), que suprime los espacios
iniciales, y con ALLTRIM(), que suprime tanto los espacios iniciales
como los finales. Las funciónes inversas de ALLTRIM(), LTRIM() y RTRIM()
son PADC(), PADR() y PADL(), que centra, justifica a la derecha o
justifica a la izquierda, respectivamente, las cadenas de carácteres,
rellen.ndolas con carácteres de relleno.
Ejemplos
. Esta es una función en la que RTRIM() formatea los campos
Ciudad, Provincia y C.digo postal para etiquetas y circulares:
FUNCTION Direccion(cCiudad, cProvincia, cCodigoPostal)
RETURN RTRIM(cCiudad) + ", " ;
+ RTRIM(cProvincia) + " " + cCodigoPostal
. En este ejemplo, la función, Direccion(), muestra un registro
de Clientes.dbf:
USE Clientes INDEX NombreCli NEW
SEEK "Rosa"
? Direccion(Ciudad, Provincia, CodigoPostal)
// Resultado: Oviedo, Asturias 43066
Ficheros: La biblioteca asociada es CLIPPER.LIB.
SAVESCREEN()
Guarda una parte de la pantalla para su posterior visualización
------------------------------------------------------------------------------
Sintaxis
SAVESCREEN([<nSup>], [<nIzq>], [<nInf>], [<nDer>]) --> cPantalla
Argumentos
<nSup>, <nIzq>, <nInf>, y <nDer> definen las coordenadas
de la parte de la pantalla que va a guardarse. Si <nInf> o <nDer> son
mayores que MAXROW() o MAXCOL(), la pantalla se recorta. Si no
especifican coordenadas, se guarda toda la pantalla (es decir, desde 0,0
hasta MAXROW(), MAXCOL()).
Devuelve
SAVESCREEN() devuelve la zona especificada de la pantalla, como cadena
de carácteres.
Descripción
SAVESCREEN() es una función de pantalla que guarda una zona de la
pantalla en una variable de cualquier clase de almacenamiento,
incluyendo variables de campo. M.s adelante, puede volver a mostrar la
imagen de pantalla guardada, en la misma posición o en otra nueva,
utilizando RESTSCREEN( ). Normalmente, las zonas de pantalla se
alamacenan y recuperan cuando se utiliza una rutina de men. desplegable
o se arrastra un objeto de pantalla.
Advertencia SAVE SCREEN, RESTORE SCREEN, SAVESCREEN(), y
RESTSCREEN() se admiten cuando se utiliza el controlador de pantalla por
defecto. Es posible que otros controladores de pantalla no admitan las
operación.s de archivo y recuperaci.n de pantallas.
Ejemplos
. La siguiente función definida por el usuario crea un men. que
aparece en pantalla utilizando ACHOICE() con SAVESCREEN(),
devolviendo la selecci.n en la matriz de opciónes:
FUNCTION Menu( nSup, nIzq, nInf, nDer, ;
aElementos, cColor )
LOCAL cPantalla, nOpcion, cUltColor := ;
SETCOLOR(cColor)
//
cPantalla:= SAVESCREEN(nSup, nIzq, nInf, nDer)
@ nSup, nIzq TO nInf, nDer DOUBLE
//
nOpcion:= ACHOICE(++nSup, ++nIzq, ;
--nInf, --nDer, aElementos)
//
RESTSCREEN(--nSup, --nIzq, ++nInf, ++nDer, ;
cPantalla)
SETCOLOR(cUltColor)
RETURN nOpcion
Ficheros: La biblioteca asociada es EXTEND.LIB.
SCROLL()
Desplaza una zona de la pantalla hacia arriba o hacia abajo, a la derecha o a
la izquierda
------------------------------------------------------------------------------
Sintaxis
SCROLL([<nSup>], [<nIzq>],[<nInf>],[<nDer>],
[<nVert>] [<nHoriz>]) --> NIL
Argumentos
<nSup>, <nIzq>, <nInf>, y <nDer> definen las coordenadas
de la zona de desplazamiento. Los valores de filas y columnas pueden ir
desde 0, 0 hasta MAXROW(), MAXCOL(). Si no especifica argumentos de
coordenadas, se utilizan las dimensiónes de la pantalla visible.
<nVert> define el número de filas de desplazamiento vertical. Un
valor positivo desplaza hacia arriba la pantalla el número especificado
de filas. Un valor negativo desplaza hacia abajo la pantalla el número
especificado de filas. Un valor cero desactiva el desplazamiento
vertical. Si no se especifica <nVert> se asume un valor cero.
<nHoriz> define el número de filas de desplazamiento horizontal. Un
valor positivo hace que la pantalla se desplace hacia la izquierda el
número de columnas especificado. Un valor negativo hace que la pantalla
se desplace hacia la derecha el número de columnas especificado. Un
valor cero desactiva el desplazamiento horizontal. Si no se especifica
<nHoriz>, se asume un valor cero.
Si no introduce los parámetros <nVert> ni <nHoriz> en SCROLL(), el .rea
especificada por los cuatro primero parámetros queda en blanco.
.Advertencia! El desplazamiento horizontal no se puede utilizar en
ningúno de los controladores de terminal alternativos (ANSITERM,
NOVTERM, PCBIOS).
Devuelve
SCROLL() siempre devuelve NIL.
Descripción
SCROLL() es una función de pantalla que desplaza una zona de .sta hacia
arriba o hacia abajo un número especificado de filas. Cuando una
pantalla se desplaza hacia arriba, la primera línea de la zona se borra;
las líneas restántes se desplazan hacia arriba y se muestra una línea en
blanco en el color estándar actual en la .ltima línea de la zona
especificada. Si la zona se desplaza hacia abajo, la operación.se
invierte. Si la zona de pantalla se desplaza m.s de una línea, se repite
este proceso.
SCROLL() se utiliza principalmente para mostrar información de estado en
una zona definida de la pantalla. Cada vez que se muestra un mensaje
nuevo, la zona de la pantalla se desplaza una línea hacia arriba y se
muestra una nueva línea en la parte inferior.
Ejemplos
. Esta función definida por el usuario muestra una cadena de
mensaje al final de una zona de pantalla después de desplazarla una
línea hacia arriba:
FUNCTION DespArr( nSup, nIzq, nInf, nDer, ;
expVisual )
//
SCROLL(nSup, nIzq, nInf, nDer, 1)
@ nInf, nIzq SAY expVisual
//
RETURN NIL
Ficheros: La biblioteca asociada es CLIPPER.LIB.
SECONDS()
Devuelve el número de segundos transcurridos desde la medianoche
------------------------------------------------------------------------------
Sintaxis
SECONDS() --> nSegundos
Devuelve
SECONDS() devuelve la hora del sistema como valor numérico en forma de
segundos.cent.simas. El valor numérico devuelto es el número de segundos
transcurridos desde medianoche y se basa en un reloj de veinticuatro
horas con un rango de cero a 86399.
Descripción
SECONDS() es una función de tiempo que ofrece un m.todo simple para
calcular el tiempo transcurrido durante la ejecución de un programa
bas.ndose en el reloj del sistema. Esta función está relacionada con la
función TIME() que devuelve la hora del sistema como una cadena con el
formato hh:mm:ss.
Ejemplos
. Este ejemplo contrasta el valor de TIME() con SECONDS():
? TIME() // Resultado: 10:00:00
? SECONDS() // Resultado: 36000.00
. Este ejemplo utiliza SECONDS() para controlar el tiempo
transcurrido en segundos:
LOCAL nInicio, nTranscurrido
nInicio:= SECONDS()
.
. <sentencias>
.
nTranscurrido:= SECONDS() - nInicio
? "Transcurrido: " + LTRIM(STR(nTranscurrido)) + " segundos"
Ficheros: La biblioteca asociada es CLIPPER.LIB.
SELECT()
Determina el número de área de trabajo de un alias especificado
------------------------------------------------------------------------------
Sintaxis
SELECT([<cAlias>]) --> nAreadeTrabajo
Argumentos
<cAlias> es el nombre alias del área de trabajo destáno.
Devuelve
SELECT() devuelve el área de trabajo del alias especificado como valor
numérico entero.
Descripción
SELECT() es una función de base de datos que determina el número de .rea
de trabajo de un alias. El número devuelto puede estar comprendido entre
cero y 250. Si no se especifica <cAlias>, se devuelve el número del .rea
de trabajo actual. Si se especifica y el alias no existe, SELECT()
devuelve cero.
Nota: La función SELECT() y el mandato SELECT especificados con un
argumento de expresión ampliado tienen un aspecto muy similar. Esto no
debe constituir un problema ya que la función SELECT() no es muy .til en
s. misma si figura aislada en una línea.
Ejemplos
. Este ejemplo utiliza SELECT() para determinar qu. .rea de
trabajo ha seleccionado USE...NEW:
USE Ventas NEW
SELECT 1
? SELECT("Ventas") // Resultado: 4
. Para volver a seleccionar el valor devuelto por la función
SELECT(), utilice el mandato SELECT con la sintaxis
SELECT(<idVarmem>), del modo siguiente:
USE Ventas NEW
nAreadeTrabajo:= SELECT()
USE Cliente NEW
SELECT (nAreadeTrabajo)
Ficheros: La biblioteca asociada es CLIPPER.LIB.
SET()
Comprueba o modifica un valor de configuración del sistema
------------------------------------------------------------------------------
Sintaxis
SET(<nEspecificador>, [<expNuevoValor>],
[<lModoApertura>]) --> ValorActual
Argumentos
<nEspecificador> es un valor numérico que identifica al valor que
debe comprobarse o modificarse. <nEspecificador> debe proporcionarse
como una constante declarada (ver a continúa.ión).
<expNuevoAjuste> es un argumento opciónal que indica un valor
nuevo para <nEspecificador>. El tipo de este argumento depende de
<nEspecificador>.
<lModoApertura> es un valor l.gico que indica si los ficheros que
se abren para los siguientes pr.positos:
_SET_ALTFILE, _SET_PRINTFILE, _SET_EXTRAFILE
deber.an truncarse o abrirse en modo de adici.n. Un valor de falso
(.F.) signfica que el fichero debe truncarse. Un valor de verdadero
significa que el fichero debe abrirse en modo de adici.n. En
cualquier caso, si el fichero no existe se crea.
Si no se especifica este argumento, el valor por defecto es modo de
adici.n.
Devuelve
SET() devuelve el valor de configuración actual de la carácter.stica
especificada.
Descripción
SET() es una función del sistema que le permite comprobar o modificar
los valores de sistema de CA-Clipper. Para obtener más información
sobre el significado y valores correctos para un ajuste en concreto,
consulte el mandato o función asociados.
Use una constante declarada para especificar el ajuste que deba ser
comprobado o modificado. Estas constantes se definen en un fichero
de cabecera llamado Set.ch. Este fichero debe incluirse al principio
de cualquier módulo fuente que utilice SET().
Set.ch también define una constante llamada _SET _COUNT. Esta constante
es igual al número de ajustes que pueden cambiarse o inspeccionarse con
SET(), permitiendo la construcci.n de una función gen.rica que conserva
todos los ajustes (consulte el ejemplo que aparece m.s adelante).
Nota: Los valores numéricos de las constantes declaradas en
Set.ch dependen de la versi.n y nunca deben utilizarse directamente,
siempre deben utilizarse las constantes declaradas.
Si <nEspecificador> o <expNuevoAjuste> no son víaacute;lidos, se ignora la
llamada a SET().
Valores de Set Definidos en Set.ch
------------------------------------------------------------------------
Constante Tipo de Valor Mandato o función Asociados
------------------------------------------------------------------------
_SET_EXACT L.gico SET EXACT
_SET_FIXED L.gico SET FIXED
_SET_DECIMALS numérico SET DECIMALS
_SET_DATEFORMAT C.racter SET DATE
_SET_EPOCH numérico SET EPOCH
_SET_PATH C.racter SET PATH
_SET_DEFAULT C.racter SET DEFAULT
_SET_EXCLUSIVE L.gico SET EXCLUSIVE
_SET_SOFTSEEK L.gico SET SOFTSEEK
_SET_UNIQUE L.gico SET UNIQUE
_SET_DELETED L.gico SET DELETED
_SET_CANCEL L.gico SETCANCEL()
_SET_DEBUG L.gico ALTD()
_SET_COLOR C.racter SETCOLOR()
_SET_CURSOR numérico SETCURSOR()
_SET_CONSOLE L.gico SET CONSOLE
_SET_ALTERNATE L.gico SET ALTERNATE
_SET_ALTFILE C.racter SET ALTERNATE TO
_SET_DEVICE C.racter SET DEVICE
_SET_PRINTER L.gico SET PRINTER
_SET_PRINTFILE C.racter SET PRINTER TO
_SET_MARGIN numérico SET MARGIN
_SET_BELL L.gico SET BELL
_SET_CONFIRM L.gico SET CONFIRM
_SET_ESCAPE L.gico SET ESCAPE
_SET_INSERT L.gico READINSERT()
_SET_EXIT L.gico READEXIT()
_SET_INTENSITY L.gico SET INTENSITY
_SET_SCOREBOARD L.gico SET SCOREBOARD
_SET_DELIMITERS L.gico SET DELIMITERS
_SET_DELIMCHARS C.racter SET DELIMITERS TO
_SET_WRAP L.gico SET WRAP
_SET_MESSAGE numérico SET MESSAGE
_SET_MCENTER L.gico SET MESSAGE
------------------------------------------------------------------------
Nota: _SET_EXTRAFILE y _SET_SCROLLBREAK no tienen mandatos
correspondientes. _SET_EXTRAFILE le permite especificar un fichero
alternativo adicional y _SET_SCROLLBREAK activar o desactivar la
interpretaci.n de Ctrl-S.
Ejemplos
. Este ejemplo muestra una función definida por el usuario que
conserva o restaura toda la configuración. Esta función podr.a
utilizarse al entrar en un subsistema para garantizar que .ste no
afecta al estado del programa que lo ha llamado:
#include "Set.ch"
//
FUNCTION EstablecerTodo( aNuevosValores )
LOCAL aValoresActuales[_SET_COUNT], nActuales
IF ( aNuevosValores != NIL ) // Establecer los nuevos y devolver los
actuales
FOR nActuales := 1 TO _SET_COUNT
aValoresActuales[nActuales] := ;
SET(nActuales, aNuevosValores[nActuales])
NEXT
ELSE // Devolver sólo actuales
FOR nActuales := 1 TO _SET_COUNT
aValoresActuales[nActuales] := SET(nActuales)
NEXT
ENDIF
RETURN (aValoresActuales)
Ficheros: La biblioteca asociada es CLIPPER.LIB
y el fichero de cabecera Set.ch.
SETBLINK()
Activa o desactiva la interpretaci.n del asterisco (*) en la cadena
SETCOLOR() entre parpadeo e intensidad de fondo
------------------------------------------------------------------------------
Sintaxis
SETBLINK([<lActivar/Desactivar>]) --> lValorActual
Argumentos
<lActivar/Desactivar> modifica el significado del carácter asterisco
(*) cuando se encuentra en una cadena SETCOLOR(). Especificando
verdadero, se establece el parpadeo de los carácteres; falso (.F.)
establece la intensidad del fondo. El valor por defecto es verdadero
(.T.).
Devuelve
SETBLINK() devuelve el valor de la configuración actual como valor
l.gico.
Descripción
SETBLINK() es una función de entorno que activa o desactiva el atributo
de parpadeo/intensidad de fondo e informa sobre el estado actual de
SETBLINK(). Cuando la función est. activada, los carácteres escritos en
la pantalla parpadean mediante la inclusi.n de un asterisco (*) en una
cadena de color pasada a SETCOLOR(). Cuando SETBLINK() est. desactivado,
el asterisco hace que el color del fondo se intensifique. As. pues, los
atributos de parpadeo e intensidad de fondo no están disponibles a la
vez.
Nota: Esta función sólo tiene sentido en PCs de IBM u ordenadores
compatibles con dispositivos de visualización CGA, EGA, o VGA.
Ejemplos
. Este ejemplo guarda el estado actual SETBLINK() antes de pasar
el control a una función definida por el usuario. Tras la devoluci.n
SETBLINK() se restaura a su valor original:
lParpAnti := SETBLINK()
MiFunc()
SETBLINK(lParpAnti)
Ficheros: La biblioteca asociada es CLIPPER.LIB.
SETCANCEL()
Activa o desactiva Alt-C y Ctrl-Intro como teclas de finalizaci.n de programa
------------------------------------------------------------------------------
Sintaxis
SETCANCEL([<lActivar/Desactivar>]) --> lAjusteActual
Argumentos
<lActivar/Desactivar> modifica la disponibilidad de Alt-C y
Ctrl-Intro como teclas de finalizaci.n. Un valor de verdadero (.T.)
permite la utilización de ambas combinaciónes de teclas para finalizar
una aplicación y un valor de falso (.F.) las desactiva. El valor por
defecto es verdadero (.T.).
Devuelve
SETCANCEL() devuelve el ajuste actual como valor l.gico.
Descripción
SETCANCEL() es una función de teclado que activa o desactiva el estado
de las teclas de finalizaci.n Alt-C y Ctrl-Inter, e informa sobre el
estado actual de SETCANCEL().
Tenga en cuenta que si Alt-C o Ctrl-Enter se redefinen con SET KEY, esta
nueva definición tiene precedencia aunque SETCANCEL() devuelva verdadero
(.T.).
.Advertencia! Cuando se establece SETCANCEL() como falso (.F.), el
usuario no puede finalizar un programa fuera de control a menos que se
le proporcione un mecanismo de escape alternativo.
Ejemplos
. Este ejemplo ofrece una vía de escape a partir de un estado de
espera con la función SET CANCEL() desactivada:
#define K_ALTC 302
//
SETCANCEL(.F.) // Desactivar teclas de finalizaci.n
SET KEY K_ALTC TO AltC // Redefinir Alt-C
.
. <sentencias>
.
RETURN
FUNCTION AltC
LOCAL cPantalla, nOpcion, cúltimoColor := ;
SETCOLOR("W/B, N/G")
//
SAVE SCREEN TO cPantalla
@ 6, 20 CLEAR TO 9, 58
@ 6, 20 TO 9, 58 DOUBLE
@ 7, 26 SAY "Alt-C: .Desea salir?"
@ 8, 35 PROMPT " S. "
@ 8, 41 PROMPT " No "
MENU TO nOpcion
SETCOLOR(cúltimoColor)
RESTORE SCREEN FROM cPantalla
//
IF nOpcion = 1
QUIT
ENDIF
//
RETURN NIL
Ficheros: La biblioteca asociada es CLIPPER.LIB.
SETCOLOR()
Devuelve los colores actuales y, opciónalmente, establece algunos nuevos
------------------------------------------------------------------------------
Sintaxis
SETCOLOR([<cCadenaColor>]) cCadenaColor
Argumentos
<cCadenaColor> es una cadena de carácteres que contiene una lista
de atributos de color para la posterior salida por pantalla. La
siguiente es una lista de ajustes y ámbitos relacionados:
configuraciónes de Color
------------------------------------------------------------------------
configuración ámbito
------------------------------------------------------------------------
Est.ndar Todosólos mandatos y funciónes de salida por pantalla
Resaltado GET y zonas resaltadas de opciónes
Borde Borde alrededor de la pantalla; no se usa en EGA y VGA
Fondo No est. admitido
Sin Selec. GET sin seleccionar u opción de men. no accesible
------------------------------------------------------------------------
Cada configuración es un par de colores de primer plano y fondo
separados por un carácter de barra (/) y seguidos por una coma. Todas
las configuraciónes son opciónales. Si se ignora una configuración,
se conserva su valor previo estableci.ndose sólo valores nuevos.
Devuelve
SETCOLOR() devuelve el ajuste de color actual como una cadena de
carácteres.
Descripción
SETCOLOR() es una función de pantalla que guarda la configuración de
color actual o establece nuevos colores para el posterior coloreado
de la pantalla. Una cadena de color est. formada por varias
configuraciónes de color, correspondiendo cada color a diferentes
zonas de la pantalla. Tal y como se ha dicho anteriormente, cada
configuración consta de un color de primer plano y otro de fondo. El
primer plano define el color de los carácteres que se muestran en la
pantalla. El fondo define el color que se muestra detrás del
carácter. Los espacios y carácteres que no se visualización se
muestran como fondo.
En CA-Clipper, las configuraciónes que definen el comportamiento de
los colores son:
Est.ndar: La configuración estándar controla todos los mandatos y
funciónes de consola, pantalla completa e interfaz cuando se muestran
en la pantalla. Esto incluye mandatos como @...PROMPT, @...SAY y ? y
funciónes como ACHOICE(), DBEDIT() y MEMOEDIT().
Resaltado: La configuración resaltada controla la visualización
de las zonas resaltadas. Esto incluye GET si se ha establecido SET
INTENSITY ON y las zonas resaltadas de selecci.n de MENU TO, DBEDIT()
y ACHOICE().
Borde: El borde es un .rea situada alrededor de la pantalla en la
cual no puede escribirse.
Fondo: El fondo no se utiliza.
Sin selecionar: Esta configuración se usa para visualizar los GET
no seleccionados y las opciónes de men. no disponibles. Además de los
colores, los ajustes de primer plano pueden tener atributos de
intensidad alta y/o parpadeo. Con una pantalla monocroma, la intensidad
alta aumenta el brillo del texto. Con una pantalla en color, la
intensidad cambia la tonalidad del color especificado. Por ejemplo, "N"
muestra el texto de primer plano en negro mientras que "N+" lo muestra
en gris. La intensidad alta viene indicada mediante "+". El atributo de
parpadeo hace que el texto de primer plano aparezca y desaparezca a
intervalos r.pidos. Este atributo se indica mediante "*". El carácter
de atributo puede estar en cualquier punto de la cadena de configuración,
pero siempre afecta al color de primer plano con independencia del lugar
en que se introduzca.
Se admiten los siguientes colores:
Lista de Colores
------------------------------------------------------------------------
Color Letra Monocromo
------------------------------------------------------------------------
Negro N, Espacio Negro
Azul B Subrayado
Verde G Blanco
Cian BG Blanco
Rojo R Blanco
Magenta RB Blanco
Marr.n GR Blanco
Blanco W Blanco
Gris N+ Blanco
Azul Intenso B+ Subr. Intenso
Verde Intenso G+ Blanco Intenso
Cian Intenso BG+ Blanco Intenso
Rojo Intenso R+ Blanco Intenso
Magenta Int. RB+ Blanco Intenso
Amarillo GR+ Blanco Intenso
Blanco Intenso W+ Blanco Intenso
Negro U Subrayado
V.deo Inverso I V.deo Inverso
En Blanco X En Blanco
------------------------------------------------------------------------
Notas
. Argumentos no especificados: Al contrario que SET COLOR
TO, SETCOLOR() sin argumentos no restaura los colores a sus valores
por defecto.
. números de colores: SETCOLOR() admite combinaciónes de
letras de colores pero no de números de colores.
Ejemplos
. Este ejemplo asigna la configuración de color actual a la
variable cColor:
cColor:= SETCOLOR()
. Este ejemplo utiliza SETCOLOR() para guardar la configuración
de color actual y establecer una nueva.
cColorNuevo:= "BR+/N, R+/N"
cColorAntiguo:= SETCOLOR(cColorNuevo)
. Este ejemplo utiliza SET COLOR TO para volver a establecer los
colores por defecto:
SET COLOR TO
? SETCOLOR() // Resultado: W/N, N/W, N, N, N/W
. Estos dos ejemplos especifican SETCOLOR() sin algunas
configuraciónes:
// configuraciónes omitidas
SETCOLOR("W/N, BG+/B")
//
// configuraciónes ignoradas dentro de la lista
SETCOLOR("W/N, BG+/B,,,W/N")
. Este ejemplo utiliza SETCOLOR() con ISCOLOR() para establecer
los colores, dependiendo del tipo de pantalla:
FUNCTION ColoresDefecto
IF ISCOLOR()
cFormulario := "W+/N, BG+/B,,,W/N"
cDialogo := "N/N+, BG+/B,,,N/N+"
cAviso := "W+/R, BG+/B,,,W+/R"
ELSE
cFormulario := "W+/N, N/W,,,W/N"
cDialogo := "W+/N, N/W,,,W/N"
cAviso := "W+/N, N/W,,,W/N"
ENDIF
RETURN NIL
Ficheros: La biblioteca asociada es CLIPPER.LIB.
SETCURSOR()
Establece la forma del cursor
------------------------------------------------------------------------------
Sintaxis
SETCURSOR([<nFormaCursor>]) --> nFormaActual
Argumentos
<nFormaCursor> es un número que indica la forma del cursor. Para
códigos sencillos, el fichero de cabecera Setcurs.ch ofrece nombres
descriptivos para las diversas formas del cursor tal y como se muestra
en la siguiente tabla:
Formas del Cursor
------------------------------------------------------------------------
Formas Valor Setcurs.ch
------------------------------------------------------------------------
Ninguna 0 SC_NONE
Subrayado 1 SC_NORMAL
Bloque medio inferior 2 SC_INSERT
Bloque completo 3 SC_SPECIAL1
Bloque medio superior 4 SC_SPECIAL2
------------------------------------------------------------------------
Devuelve
SETCURSOR() devuelve la forma actual del cursor como valor numérico.
Descripción
SETCURSOR() es una función de entorno que controla la forma del cursor
de pantalla. La forma real depende del controlador actual de la
pantalla. Las formas especificadas aparecen en PC de IBM y ordenadores
compatibles. En otros ordenadores, el aspecto puede diferir para cada
valor especificado.
SETCURSOR(0) equivale a SET CURSOR OFF y cualquier valor entero positivo
de <nFormaCursor> menor que 5 equivale a SET CURSOR ON. El cursor se
muestra con la forma seleccionada.
Ejemplos
. Este ejemplo utiliza SETCURSOR() para que el cursor adopte la
forma de bloque completo para el READ posterior. Una vez finalizado
el READ, SETCURSOR() desactiva el cursor:
#include "Setcurs.ch"
//
USE Cliente NEW
@ 10, 10 GET Cliente->Nombre
@ 11, 10 GET Cliente->Telefono
//
SETCURSOR(SC_SPECIAL1) // Cambiar el cursor a bloque
READ
SETCURSOR(SC_NONE) // Desactivar cursor
Ficheros: La biblioteca asociada es CLIPPER.LIB
y el fichero de cabecera Setcurs.ch.
SETKEY()
Asigna un bloque de acci.n a una tecla
------------------------------------------------------------------------------
Sintaxis
SETKEY(<nC.digoInkey>, [<bAcción>]) --> bAcciónActual
Argumentos
<nC.digoInkey> es el valor INKEY() de la tecla a la que va a
asociarse la acci.n o que va a consultarse.
<bAcción> especifica un bloque de código que se ejecuta
autom.ticamente siempre que se pulsa la tecla especificada durante un
estado de espera.
Devuelve
SETKEY() devuelve el bloque de acci.n asociado actualmente a la tecla
especificada o NIL si dicha tecla no est. asociada a ningún bloque.
Descripción
SETKEY() es una función de teclado que establece o consulta la acci.n
autom.tica asociada a una tecla determinada durante un estado de espera.
Un estado de espera es cualquier modo que lee del teclado a excepci.n de
INKEY(), pero incluyendo ACHOICE(), DBEDIT(), MEMOEDIT(), ACCEPT, INPUT,
READ y WAIT. Pueden asignarse hasta 32 teclas a la vez. Al arrancar, el
sistema asigna autom.ticamente la tecla F1 para ejecutar u procedimiento
o función definida por el usuario denominado Help.
Cuando se pulsa una tecla asignada durante un estado de espera, la
función EVAL() eval.a la <bAcción> asociada y los parámetros PROCNAME(),
PROCLINE() y READVAR(). Sin embargo, no es necesario listar los
argumentos al especificar <bAcción> si no se van a utilizar dentro del
bloque de acci.n.
SETKEY() es como el mandato SET KEY que asocia una llamada a un
procedimiento a una tecla.
Ejemplos
. Este fragmento de código asocia un bloque de acci.n a una
tecla, después, tras obtener una tecla con INKEY(), la ejecuta con la
función EVAL():
#include "Inkey.ch"
SETKEY(K_DN, {|cProc, nLinea, cVar| MiProc(cProc, ;
nLinea, cVar)})
.
. <sentencias>
.
DO WHILE .T.
nTecla := INKEY(0)
DO CASE
CASE (bAcción := SETKEY(nTecla)) != NIL
EVAL(bAcción, PROCNAME(), PROCLINE(), READVAR())
CASE nTecla = K_PGUP
Previous()
CASE nTecla = K_PGDN
Next()
CASE nTecla = K_ESC
EXIT
ENDCASE
ENDDO
Ficheros: La biblioteca asociada es CLIPPER.LIB
y el fichero de cabecera Inkey.ch.
SETMODE()
Cambia el modo de visualización a un número especificado de filas y columnas
------------------------------------------------------------------------------
Sintaxis
SETMODE(<nFilas>, <nCols>) --> lCorrecto
Argumentos
<nFilas> es el número de filas en el modo de visualización deseado.
<nCols> es el número de columnas en el modo de visualización
deseado.
Devuelve
SETMODE() devuelve verdadero (.T.) si el cambio de modo ha sido
satisfactorio; en caso contrario, devuelve falso (.F.).
Descripción
SETMODE() es una función de entorno que intenta cambiar el modo del
dispositivo de visualización para que coincida con el número de filas y
columnas especificado. El cambio en el tama.o de la pantalla se refleja
en los valores devueltos por MAXROW() y MAXCOL().
Ejemplos
. Este ejemplo cambia a un modo de visualización de 43 líneas:
IF SETMODE(43, 80)
? "modo de 43 líneas establecido con .xito"
ELSE
? "modo de 43 líneas no disponible"
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
SETPOS()
Desplaza el cursor a una nueva posición
------------------------------------------------------------------------------
Sintaxis
SETPOS(<nFila>, <nCol>) --> NIL
Argumentos
<nFila> y <nCol> definen la nueva posición de pantalla del
cursor. Estos valores pueden estar comprendidos entre 0,0 y MAXROW(),
MAXCOL().
Devuelve
SETPOS() siempre devuelve NIL.
Descripción
SETPOS() es una función de entorno que desplaza el cursor a una nueva
posición en la pantalla. Una vez situado el cursor, ROW() y COL() se
actualizan en consecuencia. Para controlar la forma y visibilidad del
cursor, utilice la función SETCURSOR().
Ejemplos
. Este ejemplo desplaza el cursor a una nueva posición, después
muestra una cadena en la pantalla utilizando un mandato de consola,
??:
SETPOS(1, 1)
?? "Hola a todos"
Ficheros: La biblioteca asociada es CLIPPER.LIB.
SETPRC()
Establece los valores PROW() y PCOL()
------------------------------------------------------------------------------
Sintaxis
SETPRC(<nFila>, <nCol>) --> NIL
Argumentos
<nFila> es el nuevo valor de PROW().
<nCol> es el nuevo valor de PCOL().
Devuelve
SETPRC() siempre devuelve NIL.
Descripción
SETPRC() es una función de impresora que envía códigos de control a la
impresora sin cambiar la posición de la cabeza de impresión. Cuando CA-
Clipper imprime, actualiza el valor de PCOL() con el número de
carácteres envíado a la impresora. No existe diferencia entre carácteres
que pueden imprimirse y aqu.llos que no pueden hacerlo. Si, por ejemplo,
se envía a la impresora una cadena de diez carácteres que contiene dos
carácteres interpretados como código de control por la impresora, el
valor de PCOL() de CA-Clipper se incrementa en diez mientras que la
posición real de la cabeza de impresión sólo se desplaza ocho. Esto
puede llevar a problemas de alíneaci.n. Mediante el uso de SETPRC()
puede compensar estos códigos de control volviendo a establecer PCOL()
tal y como se muestra en el ejemplo que aparece m.s adelante.
SETPRC() también suprime los saltos de p.gina al imprimir con @...SAY.
Esto es importante cuando la siguiente posición de fila es menor que la
fila actual y no se ha ejecutado un EJECT. En esta situaci.n, CA-Clipper
ejecuta un salto de p.gina autom.tico si la siguiente posición de
impresi.n de fila es menor que el valor actual de PROW(). Con SETPRC(),
puede establecer PROW() a un número inferior a la fila actual,
eliminando as. el EJECT autom.tico.
Ejemplos
. Esta función definida por el usuario, ImprimirCodigos(),
utiliza SETPRC() para envíar códigos de control a la impresora sin
afectar a los valores de PROW() y PCOL():
#include "Set.ch"
#define ITALICS_ON CHR(27) + "I"
#define ITALICS_OFFCHR(27) + "E"
//
SET DEVICE TO PRINTER
@ 12, 10 SAY "Se trata de una"
@ PROW(), PCOL() + 2 SAY ImprimirCodigos(ITALICS_ON) + ;
"importante"
@ PROW(), PCOL() + 2 SAY ImprimirCodigos(ITALICS_OFF) + ;
"reuni.n"
SET DEVICE TO SCREEN
RETURN
FUNCTION ImprimirCodigos( cCodigoCtrl )
LOCAL nFila, nCol, lImpresora
lImpresora := SET(_SET_PRINTER, .T.) // SET PRINTER ON
nFila:= PROW() // Guardar posición cabeza
// de impresión
nCol:= PCOL()
//
?? cCodigoCtrl // Envíar código de control
//
SETPRC(nFila, nCol)
SET(_SET_PRINTER, lImpresora) // Recuperar parámetros
// de impresora
RETURN "" // Devolver una cadena nula
Ficheros: La biblioteca asociada es CLIPPER.LIB.
SOUNDEX()
Convierte una cadena de carácteres en su cadena de similitud fon.tica
------------------------------------------------------------------------------
Sintaxis
SOUNDEX(<cCadena>) --> cCadenaSimilFon
Argumentos
<cCadena> es la cadena de carácteres que debe convertirse.
Devuelve
SOUNDEX() devuelve una cadena de carácteres de cuatro dígitos en la
forma A999.
Descripción
SOUNDEX() es una función de carácteres que indexa y busca coincidencias
fon.ticas o sonidos similares. Se utiliza en aplicaciónes en las que no
se conoce la ortograf.a precisa de las claves de carácteres o en las que
existe una probabilidad alta de nombres mal escritos. Los errores
ortogr.ficos son muy normales en sistemas de transacci.n en tiempo real
en los que el operador de entrada de datos recibe la información a
trav.s del tel.fono. SOUNDEX() funcióna reuniendo los sonidos semejantes
bajo el mismo valor clave. Sin embargo, tenga en cuenta que el m.todo de
similitud fon.tica no es absoluto. Claves que son bastante diferentes
pueden dar como resultado el mismo valor de similitud fon.tica.
Ejemplos
. Este ejemplo genera un ííndice utilizando SOUNDEX() para crear
los valores claves. Despu.s, busca un valor encontrado en el campo
Vendedor:
USE Ventas
INDEX ON SOUNDEX(Vendedor) TO Vendedor
SEEK SOUNDEX("Pedrol")
? FOUND(), Vendedor // Resultado: .T. Pedrol
. Aqu., se busca la misma clave que en el ejemplo anterior pero
con una ortograf.a diferente:
SEEK SOUNDEX("Pedroll")
? FOUND(), Vendedor // Resultado: .T. Pedrol
Ficheros: La biblioteca asociada es EXTEND.LIB
y el fichero fuente SOURCE\SAMPLE\SOUNDEX.C
SPACE()
Devuelve una cadena de espacios
------------------------------------------------------------------------------
Sintaxis
SPACE(<nEspacios>) --> cEspacios
Argumentos
<nEspacios> es el número de espacios que va a devolverse hasta un
máximo de 65.535 (64K).
Devuelve
SPACE() devuelve una cadena de carácteres. Si <nEspacios> es cero,
SPACE() devuelve una cadena nula ("").
Descripción
SPACE() es una función de carácteres que devuelve un número especificado
de espacios. Equivale a REPLICATE(" ", <nVeces>). SPACE() puede
inicializar una variable de carácteres antes de asociarla a un GET.
SPACE() puede también rellenar cadenas con espacios iniciales o finales.
Sin embargo, tenga en cuenta que para este prop.sito son m.s eficaces
las funciónes PAD(), PADL() y PADR().
Ejemplos
. Este ejemplo utiliza SPACE() para inicializar una variable
para entrada de datos:
USE Cliente NEW
MEMVAR->Nombre = SPACE(LEN(Cliente->Nombre))
@ 10,10 SAY "Nombre Cliente" GET MEMVAR->Nombre
READ
Ficheros: La biblioteca asociada es CLIPPER.LIB.
SQRT()
Devuelve la ra.z cuadrada de un número positivo
------------------------------------------------------------------------------
Sintaxis
SQRT(<nNúmero>) --> nRa.z
Argumentos
<nNúmero> es un número positivo del cual va a extraerse la ra.z
cuadrada.
Devuelve
SQRT() devuelve un valor numérico calculado con doble precisión. El
número de lugares decimales mostrado se determina mediante SET DECIMALS
sin tener en cuenta SET FIXED. Si <nNúmero> es negativo, SQRT devuelve
cero.
Descripción
SQRT() es una función numérica utilizada en cualquier parte de un
c.lculo numérico para hallar una ra.z cuadrada (por ejemplo, en una
expresión que calcule la desvíaci.n estándar).
Ejemplos
. Estos ejemplos muestran varios resultados de SQRT():
SET DECIMALS TO 5
//
? SQRT(2) // Resultado: 1,41421
? SQRT(4) // Resultado: 2,00000
? SQRT(4) ** 2 // Resultado: 4,00000
? SQRT(2) ** 2 // Resultado: 2,00000
Ficheros: La biblioteca asociada es CLIPPER.LIB.
STR()
Convierte una expresión numérica en una cadena de carácteres
------------------------------------------------------------------------------
Sintaxis
STR(<nNúmero>, [<nLongitud>], [<nDecimales>]) --> cnúmero
Argumentos
<nNúmero> es la expresión numérica que va a convertirse en una
cadena de carácteres.
<nLongitud> es la longitud de la cadena de carácteres que debe
devolverse, incluyendo dígitos decimales, coma decimal y signo.
<nDecimales> es el número de posiciónes decimales que hay que
devolver.
Devuelve
STR() devuelve <nNúmero> con formato de cadena de carácteres. Si no se
especifican los argumentos opciónales de longitud y decimales, STR()
devuelve la cadena de carácteres de acuerdo con las siguientes reglas:
Resultados de STR() sin Argumentos Opcionales
------------------------------------------------------------------------
Expresi.n Longitud de Retorno
------------------------------------------------------------------------
Variable de campo Longitud del campo m.s decimales
Expr./constantes M.nimo de 10 dígitos m.s decimales
VAL() M.nimo de 3 dígitos
MONTH()/DAY() 3 dígitos
YEAR() 5 dígitos
RECNO() 7 dígitos
------------------------------------------------------------------------
Descripción
STR() es una función de conversión numérica que convierte valores
numéricos en cadenas de carácteres. Se utiliza con frecuencia para
concatenar valores numéricos a cadenas de carácteres. STR() tiene
aplicaciónes mostrando números, creando códigos a partir de valores
numéricos como, por ejemplo, números de referencia y creando claves de
índice que combinan datos numéricos y de tipo carácter.
STR() es similar a TRANSFORM(), que da formato a valores numéricos como
cadenas de carácteres útilizando una m.scara en lugar de
especificaciónes de longitud y decimales.
La función inversa de STR() es VAL() que convierte valores de tipo
carácter en números.
Notas
. Si <nLongitud> es menor que el número de dígitos de número
entero de <nNúmero>, STR() devuelve asteriscos en vez del número.
. Si <nLongitud> es menor que el número de dígitos decimales
necesarios para la parte decimal de la cadena de retorno, CA-Clipper
redondea el número al número disponible de posiciónes decimales.
. Si se especifica <nLongitud>, pero se omite <nDecimales> (sin
lugares decimales), el valor de retorno se redondea a un entero.
Ejemplos
. Estos ejemplos demuestran el rango de valores devueltos por
STR(), dependiendo de los argumentos especificados:
nNúmero:= 123.45
? STR(nNúmero) // Resultado: 123.45
? STR(nNúmero, 4) // Resultado: 123
? STR(nNúmero, 2) // Resultado: **
? STR(nNúmero * 10, 7, 2) // Resultado: 1234.50
? STR(nNúmero * 10, 12, 4) // Resultado: 1234.5000
? STR(nNúmero, 10, 1) // Resultado: 1234.5
. Este ejemplo utiliza STR() para crear un ííndice con una clave
compuesta de números de pedido y nombres de cliente:
USE Cliente NEW
INDEX ON STR(NumPedido, 9) + NomClien TO PedClien
Ficheros: La biblioteca asociada es CLIPPER.LIB.
STRTRAN()
Busca y sustituye carácteres dentro de una cadena de carácteres o campo memo
------------------------------------------------------------------------------
Sintaxis
STRTRAN(<cCadena>, <cB.squeda>, [<cSustituir>], [<nInicio>],
[<nNúmero>]) --> cNuevaCadena
Argumentos
<cCadena> es la cadena de carácteres o campo memo en los que debe
realizarse la b.squeda.
<cB.squeda> es la secuencia de carácteres que hay que encontrar.
<cSustituir> es la secuencia de carácteres que va a sustituir a
<cB.squeda>. Si no se especifica este argumento, las apariciones
especificadas del argumento de b.squeda se sustituyen por una cadena
vac.a ("").
<nInicio> es la primera aparici.n que debe sustituirse. Si se ignora
este argumento, el valor por defecto es uno.
<nNúmero> es el número de apariciones que deben sustituirse. Si no
se especifica, el valor por defecto es todas.
Devuelve
STRTRAN() devuelve una nueva cadena de carácteres con los casos
especificados de <cB.squeda> reemplazados por <cSustituir>.
Descripción
STRTRAN() es una función de carácteres que lleva a cabo la b.squeda
estándar de una subcadena dentro de una cadena de carácteres. Cuando
localiza una coincidencia, sustituye la cadena buscada por la cadena de
sustituci.n especificada. Se sustituyen todas las apariciones de
<cB.squeda> a menos que se especifique <nInicio> o <nNúmero>. Tenga en
cuenta que STRTRAN() sustituye subcadenas y, por lo tanto, no tiene en
cuenta palabras enteras.
Ejemplos
. Este ejemplo utiliza STRTRAN() para establecer un an.logo
postmoderno a una famosa cita:
cCadena:= "Calcular o no calcular?"
? STRTRAN(cCadena, "calcular", "ser")
// Resultado: Ser o no ser?
Ficheros: La biblioteca asociada es CLIPPER.LIB.
STUFF()
Borra e inserta carácteres en una cadena
------------------------------------------------------------------------------
Sintaxis
STUFF(<cCadena>, <nInicio>, <nBorrar>, <cInsertar>) --> cNuevaCadena
Argumentos
<cCadena> es la cadena de carácteres destáno en la que se insertan y
borran carácteres.
<nInicio> es la posición inicial en la que se produce la
inserci.n/borrado.
<nBorrar> es el número de carácteres que hay que borrar.
<cInsertar> es la cadena que debe insertarse.
Devuelve
STUFF() devuelve una copia de <cCadena> con los carácteres especificados
borrados y con <cInsertar> insertada.
Descripción
STUFF() es una función de carácteres que borra <nBorrar> carácteres de
<cCadena> empezando en la posición <nInicio>. A continúa.ión, inserta
<cInsertar> en la cadena resultante empezando en la posición <nInicio>
para formar la cadena de retorno. De esta forma, STUFF() puede realizar
las seis operación.s siguientes:
. Insertar: Si <nBorrar> es cero, no se suprimen carácteres
de <cCadena>. <cInsertar> se inserta en <nInicio> y se devuelve toda
la cadena. Por ejemplo STUFF("Mi perro tiene pulgas." 16, 0, "no ")
devuelve "Mi perro no tiene pulgas".
. Sustituir: Si <cInsertar> tiene la misma longitud que
<nBorrar>, <cInsertar> sustituye los carácteres empezando en
<nInicio> y la cadena resultante tiene la misma longitud que la
original. Por ejemplo, STUFF("Mi perro tiene pulgas.", 16, 6,
"huesos") devuelve "Mi perro tiene huesos".
. Borrar: Si <cInsertar> es una cadena nula (""), se borra
de <cCadena> el número de carácteres especificado por <nBorrar> y la
cadena se devuelve sin ningún carácter a.adido. Por ejemplo,
STUFF("Mi perro tiene pulgas.", 1, 3, "") devuelve "perro tiene
pulgas".
. Sustituir e insertar: Si <cInsertar> es m.s largo que
<nBorrar>, se sustituyen todos los carácteres desde <nInicio> hasta
<nBorrar> y se inserta el resto de <cInsertar>. Puesto que se
insertan m.s carácteres de los que se borran, la cadena resultante
siempre es m.s larga que la original. Por ejemplo, STUFF("Mi perro
tiene pulgas.", 10, 5, "nunca ha tenido") devuelve "Mi perro nunca ha
tenido pulgas".
. Sustituir y borrar: Si la longitud de <cInsertar> es menor
que <nBorrar>, se borran m.s carácteres de los que se insertan. Por
lo tanto, la cadena resultante es m.s corta que la original. Por
ejemplo, STUFF("Mi perro tiene pulgas.", 10, 5, "es") devuelve "Mi
perro es pulgas".
. Sustituir y borrar el resto: Si <nBorrar> es mayor o igual
que el número de carácteres restántes de <cCadena> empezando por
<nInicio>, los carácteres restántes se borran antes de insertar
<cInsertar>. Por ejemplo, STUFF("Mi perro tiene pulgas.", 10, 13,
"es") devuelve "Mi perro es".
Ejemplos
. Estos ejemplos demuestran las seis operación.s b.sicas de
STUFF():
// InsertAR
? STUFF("ABCDEF", 2, 0, "xyz") // Resultado: AxyzBCDEF
// Sustituir
? STUFF("ABCDEF", 2, 3, "xyz") // Resultado: AxyzEF
// Borrar
? STUFF("ABCDEF", 2, 2, "") // Resultado: ADEF
// Sustituir e insertar
? STUFF("ABCDEF", 2, 1, "xyz") // Resultado: AxyzCDEF
// Sustituir y borrar
? STUFF("ABCDEF", 2, 4, "xyz") // Resultado: AxyzF
// Sustituir y borrar resto
? STUFF("ABCDEF", 2, 10, "xyz") // Resultado: Axyz
Ficheros: La biblioteca asociada es EXTEND.LIB,
el módulo fuente asociado: SOURCE\SAMPLE\STUFF.C.
SUBSTR()
Extrae una subcadena de una cadena de carácteres
------------------------------------------------------------------------------
Sintaxis
SUBSTR(<cCadena>, <nInicio>, [<nCaracteres>]) --> cSubcadena
Argumentos
<cCadena> es la cadena de carácteres de la que va a extraerse una
subcadena. Puede tener hasta 65.535 (64K) bytes, el tama.o máximo de
cadena en CA-Clipper.
<nInicio> es la posición inicial en <cCadena>. Si <nInicio> es
positivo, es relativo al carácter situado en el extremo izquierdo de
<cCadena>. Si es negativo, es relativo al carácter situado en el extremo
derecho de <cCadena>.
<nCaracteres> es el número de carácteres que hay que extraer. Si se
omite, la subcadena empieza en <nInicio> y continúa.hasta el final de la
cadena. Si <nCaracteres> es mayor que el número de carácteres desde
<nInicio> hasta el final de <cCadena>, los carácteres adicionales se
ignoran.
Devuelve
SUBSTR() devuelve una cadena de carácteres.
Descripción
SUBSTR() es una función de carácteres que extrae una subcadena de otra
cadena de carácteres o campo memo. SUBSTR() está relacionada con las
funciónes LEFT() y RIGHT() que extraen subcadenas empezando por los
carácteres situados m.s a la izquierda y a la derecha de <cCadena>,
respectivamente.
Las funciónes SUBSTR(), RIGHT() y LEFT() se utilizan muy a menudo con
AT() y RAT() para localizar la primera y/o .ltima posición de una
subcadena antes de extraerla. También se utilizan para mostrar o
imprimir sólo una parte de una cadena de carácteres.
Ejemplos
. Estos ejemplos extraen el nombre y apellido de una variable:
cNombre:= "Juan Pedralbes"
? SUBSTR(cNombre, 1, 4) // Resultado: Juan
? SUBSTR(cNombre, 6) // Resultado: Pedralbes
? SUBSTR(cNombre, LEN(cNombre) + 2) // Resultado:
// cadena nula
? SUBSTR(cNombre, -9) // Resultado: Pedralbes
? SUBSTR(cNombre, -9, 3) // Resultado: Ped
. Este ejemplo utiliza SUBSTR() con AT() y RAT() para crear una
función que extrae un nombre de fichero de una especificación de
fichero:
? FichBase("C:\PRG\MIFICHE.OBJ") // Resultado: MIFICHE.OBJ
FUNCTION FichBase( cFichero )
LOCAL nPos
IF (nPos := RAT("\", cFichero)) != 0
RETURN SUBSTR(cFichero, nPos + 1)
ELSEIF (nPos := AT(":", cFichero)) != 0
RETURN SUBSTR(cFichero, nPos + 1)
ELSE
RETURN cFichero
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
