EMPTY()
Determina si el resultado de una expresión es un valor vac.o
------------------------------------------------------------------------------
Sintaxis
EMPTY(<exp>) --> lVac.o
Argumentos
<exp> es una expresión de cualquier tipo de datos.
Devuelve
EMPTY() devuelve verdadero (.T.) si la expresión es un valor vac.o; de
lo contrario, devuelve falso (.F.). Los criterios para determinar si un
valor se considera vac.o dependen del tipo de datos de <exp> de acuerdo
con las reglas siguientes:
Lista de Valores Vac.os
------------------------------------------------------------------------
Tipo de datos Contenido
------------------------------------------------------------------------
Matriz Longitud cero
Car.cter Espacios, tabuladores, CR/LF, o ("")
numérico 0
Fecha CTOD(" ")
L.gico Falso (.F.)
Memo Igual que carácter
NIL NIL
------------------------------------------------------------------------
Descripción
La función EMPTY() cuenta con diferentes útilizaciones. Puede utilizarla
para determinar si un usuario ha introducido un valor en un objeto GET
antes de realizar cambios en un fichero de base de datos. También puede
determinar si un parámetro formal es NIL o no se ha pasado. Además,
puede comprobar una matriz para localizar una longitud cero.
Ejemplos
. Estos ejemplos ilustran la utilización de EMPTY() frente a
varios tipos de datos diferentes:
? EMPTY(SPACE(5)), EMPTY("") // Resultado: .T. .T.
? EMPTY(0), EMPTY(CTOD("")) // Resultado: .T. .T.
? EMPTY(.F.), EMPTY(NIL) // Resultado: .T. .T.
. Este ejemplo utiliza EMPTY() para determinar si el usuario ha
introducido un valor en el primer objeto Get antes de escribir el
nuevo valor en el fichero de base de datos:
LOCAL cCliente := SPACE(15), nCantidad := 0
USE Ventas NEW
@ 10, 10 GET cCliente
@ 11, 10 GET nCantidad PICTURE "999.99"
READ
//
IF !EMPTY(cCliente)
APPEND BLANK
REPLACE Ventas->Cliente WITH cCliente;
Ventas->Cantidad WITH nCantidad
ENDIF
. Este ejemplo utiliza EMPTY() como parte de la cláusula VALID
para forzar al usuario a introducir datos en el objeto Get actual:
LOCAL cCodigo := SPACE(5)
@ 2, 5 SAY "Introduzca código" GET cCodigo VALID;
!EMPTY(cCodigo)
READ
Ficheros: La biblioteca asociada es CLIPPER.LIB.
EOF()
Determina cu.ndo se detecta el final del fichero
------------------------------------------------------------------------------
Sintaxis
EOF() --> lL.mite
Devuelve
EOF() devuelve verdadero (.T.) cuando se efect.a un intento de desplazar
el puntero de registros sobrepasando el último registro l.gico de un
fichero de base de datos; de lo contrario, devuelve falso (.F.). Si no
hay fichero de base de datos abierto en el área de trabajo actual, EOF()
devuelve falso (.F.). Si el fichero de base de datos actual no contiene
registros, EOF() devuelve verdadero (.T.).
Descripción
EOF() es una función de base de datos utilizada para comprobar una
condición l.mite de fin de fichero cuando el puntero del registro avanza
por un fichero de base de datos. Cualquier mandato que pueda desplazar
el puntero del registro puede establecer EOF().
La aplicación m.s habitual es como una parte del argumento <lCondici.n>
de una construcci.n DO WHILE que procesa secuencialmente registros en un
fichero de base de datos. Aqu. <lCondici.n> incluir.a una comprobaci.n
de .NOT. EOF(), forzando al bucle DO WHILE a terminar cuando EOF()
devuelve verdadero (.T.).
EOF() y FOUND() se utilizan, frecuentemente, de manera intercambiable
para comprobar si un mandato SEEK, FIND, o LOCATE ha resultado fallido.
Sin embargo, con estos mandatos es preferible FOUND().
Cuando EOF() devuelve verdadero (.T.), el puntero del registro se sit.a
en LASTREC() + 1 con independencia de si existe un filtro activo o si se
ha establecido SET DELETED ON. Otros intentos de avanzar el puntero del
registro devuelven el mismo resultado sin error. Una vez que EOF() est.
establecido en verdadero (.T.), retiene su valor hasta que se produce
otro intento de desplazar el puntero del registro.
Por defecto, EOF() opera en el área de trabajo seleccionada actualmente.
Se puede hacer que act.e en un área de trabajo no seleccionada
especific.ndola dentro de una expresión con alias (consulte el ejemplo a
continúa.ión).
Ejemplos
. En este ejemplo se muestra el uso de EOF() desplazando
deliberadamente el puntero del registro m.s all. del último registro:
USE Ventas
GO BOTTOM
? EOF() // Resultado: .F.
SKIP
? EOF() // Resultado: .T.
. En este ejemplo se utilizan expresiónes con alias para
consultar el valor de EOF() en .reas de trabajo no seleccionadas:
USE Ventas NEW
USE Cliente NEW
? Ventas->(EOF())
? Cliente->(EOF())
. En este ejemplo se ilustra c.mo EOF() puede utilizarse como
parte de una condición para operación.s de ficheros de bases de datos
secuenciales:
USE Sales INDEX NumClie NEW
DO WHILE !EOF()
nClieAnt := Ventas->NumClie
nCantTotal := 0
DO WHILE nClieAnt = Ventas->NumClie .AND. (!EOF())
? Ventas->NumClie, Ventas->Descripción,
Ventas->CantVentas
nCantTotal += Ventas->CantVentas
SKIP
ENDDO
? "Cantidad total: ", nCantTotal
ENDDO
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ERRORBLOCK()
Establece un bloque de código para que se ejecute cuando surja un error de
tiempo de ejecución
------------------------------------------------------------------------------
Sintaxis
ERRORBLOCK([<bManejadorError>]) --> bManejadorErrorActual
Argumentos
<bManejadorError> es el bloque de código que debe ejecutarse siempre
que se produzca un error de tiempo de ejecución. Cuando se eval.a, el
sistema pasa un objeto de error a <bManejadorError> como argumento.
Devuelve
ERRORBLOCK() devuelve el bloque de código de manejo de errores. Si no se
ha fijado ningún bloque de manejo de errores desde que se llam. al
programa, ERRORBLOCK() devuelve el bloque de manejo de errores por
defecto.
Descripción
ERRORBLOCK() es una función de error que define la ejecución de un
manejador de errores siempre que se produzca un error. Especifique el
manejador de errores como un bloque de código con la forma siguiente:
{ |<objError>| <lista de expresiónes>,... }
donde <objError> es un objeto error que contiene información sobre el
error. Dentro del bloque de código, pueden envíarse mensajes al objeto
con el fin de obtener información sobre el error. Si el bloque de manejo
de errores devuelve verdadero (.T.) se reintenta la operación.fallida y
si devuelve falso (.F.) se reanuda el proceso.
El bloque de código de manejo de errores puede especificarse como una
lista de expresiónes o como una llamada a una función definida por el
usuario. La segunda opción es m.s .til puesto que pueden utilizarse las
sentencias de control de CA-Clipper en lugar de expresiónes. Este es
especialmente el caso si existe BEGIN SEQUENCE pendiente y desea
efectuar BREAK a la sentencia RECOVER m.s pr.xima.
Como esto implica, los bloques de manejo de errores pueden utilizarse en
combinación con estructuras de control BEGIN SEQUENCE...END. En un
bloque puede manejar errores de dispositivo, de bajo nivel y comunes que
cuentan con un mecanismo de recuperaci.n general. Si la operación. requiere un manejo espec.fico de errores, defina BEGIN SEQUENCE y
después, BREAK a la sentencia RECOVER, devolviendo el objeto de error
para el procesamiento local. Consulte el ejemplo que se muestra m.s
adelante.
Si no se ha especificado <bManejadorError> utilizando ERRORBLOCK() y se
ha producido un error de tiempo de ejecución, se eval.a el bloque de
manejo de errores por defecto. Este manejador de errores muestra un
mensaje descriptivo en la pantalla, establece ERRORLEVEL() en 1 y
después sale mediante QUIT del programa.
Puesto que ERRORBLOCK() devuelve el bloque de manejo de errores actual,
es posible especificar un bloque de manejo de errores para una operación. guardando el bloque actual y restableci.ndolo después de que se haya
completado la operación. Del mismo modo, los gestores de errores
especificados como bloques de códigos, pueden pasarse a los
procedimientos y funciónes definidas por el usuario y devolverse
mediante RETURN como valores.
Para obtener más información sobre la estructura y operación.s de
objetos de error, consulte la entrada Clase de Error dentro de este
capítulo y el capítulo Estrategias de Manejo de Errores en la gu.a
Programaci.n y Utilidades.
Ejemplos
. El fragmento de código de la p.gina siguiente establece un
bloque de manejo de errores, que se llamar. cuando se produzca un
error dentro de una construcci.n BEGIN SEQUENCE:
LOCAL bManejadorError, búltimoManejador, objErr
bManejadorError := { |objError| ;
MiManejadorError(objError) }
//
// Guardar el manejador actual
búltimoManejador := ERRORBLOCK(bManejadorError)
//
BEGIN SEQUENCE
.
. <sentencias de operación.gt;
.
// Recibir el objeto de error desde BREAK
RECOVER USING objError
.
. <sentencias de recuperaci.n>
.
END
ERRORBLOCK(búltimoManejador) // Restaurar el
// manejador
RETURN
FUNCTION MiManejadorError( objError )
//
BREAK objError // Devolver el objeto de
// error a RECOVER
RETURN NIL
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ERRORLEVEL()
Establece el código de retorno de CA-Clipper
------------------------------------------------------------------------------
Sintaxis
ERRORLEVEL([<nNuevoC.digoRetorno>]) --> nC.digoRetornoActual
Argumentos
<nNuevoC.digoRetorno> es la nueva selecci.n de código de retorno.
Esta puede tener un valor entre cero y 255. El valor por defecto al
inicio es cero. Si no se especifica, ERRORLEVEL() informa sobre la
selecci.n actual sin asignar un nuevo valor.
Devuelve
ERRORLEVEL() devuelve el código de salida de CA-Clipper actual como un
valor numérico, si se ha seleccionado uno utilizando ERRORLEVEL() con un
argumento; de lo contrario, devuelve cero.
Descripción
ERRORLEVEL() es una función de entorno que tiene una doble finalidad.
Devuelve el código de retorno de CA-Clipper actual y establece,
opciónalmente, un nuevo código de retorno. El código de retorno es un
valor establecido por un proceso hijo de forma que el proceso padre
pueda comprobar su estado de finalizaci.n. Normalmente, el proceso padre
es el DOS y el hijo es un programa de aplicación. Puede comprobar el
valor de retorno mediante la variable ERRORLEVEL del DOS o bien mediante
la función 4Dh de la INT 21h.
Cuando finaliza un programa de CA-Clipper, el código de retorno se
establece en 1 si el proceso finaliza con un error grave. Si el proceso
finaliza normalmente, el código de retorno se establece en cero o en el
último valor de ERRORLEVEL() definido en el programa.
Normalmente, puede fijar un código de retorno con ERRORLEVEL() para
indicar un estado de error al programa que ha llamado al programa de
CA-Clipper actual. En la mayor.a de casos, se trata del fichero de
proceso por lotes de la aplicación. Aqu. puede comprobar el código de
retorno utilizando la variable del DOS ERRORLEVEL. Consulte el manual de
DOS para obtener más información.
Notas
. ERRORLEVEL() no se actualiza después de que finalice un
mandato RUN. Para obtener el código de retorno del programa llamado,
debe crear una rutina en ensamblador o C que consulte el código de
retorno del proceso secundario utilizando la función 4Dh de la INT
21. Consulte el manual de Referencia T.cnica del DOS para obtener m.s
información.
Ejemplos
. Este ejemplo guarda el código de retorno actual de CA-Clipper,
seguidamente, establece un nuevo valor:
nAntCodigo := ERRORLEVEL() // Obtiene el nivel
// de error actual
ERRORLEVEL(1) // Establece el nuevo
// nivel de error
. Este ejemplo utiliza ERRORLEVEL() para establecer un código de
retorno que puede comprobar el proceso padre:
#define ERR_FICH_PERDIDO 255
#define ERR_EST_INCOMPLETO 254
//
IF !FILE("Sisfich.dbf")
@ 0, 0
@ 1, 0
@ 0, 0 SAY "Error fatal: Fichero de sistema perdido...saliendo"
ERRORLEVEL(ERR_FICH_PERDIDO)
QUIT
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
EVAL()
Eval.a un bloque de código
------------------------------------------------------------------------------
Sintaxis
EVAL(<bBloque>, [<ListaArgBloque>]) --> últimoValorBloque
Argumentos
<bBloque> es el bloque de código que se debe evaluar.
<ListaArgBloque> es una lista de argumentos para envíar al bloque de
código antes de que se eval.e.
Devuelve
EVAL() devuelve el valor de la .ltima expresión dentro del bloque. Un
bloque de código puede devolver un valor de cualquier tipo.
Descripción
EVAL() es una función de bloque de código. Es la función m.s b.sica de
evaluaci.n de bloque de código del sistema CA-Clipper. Un bloque de
código es un valor de datos especial que hace referencia a un fragmento
de código de programa compilado. Para obtener más información sobre
bloques de código, consulte el capítulo Conceptos Básicos de la gu.a
Programaci.n y Utilidades.
Para ejecutar o evaluar un bloque de código, llame a EVAL() con el valor
de bloque y cualquier parámetro. Cuando se ejecuta el bloque se le
suministran los parámetros. Los bloques de código pueden ser una serie
de expresiónes separadas por comas. Cuando se eval.a un bloque de
código, el valor de retorno es el valor de la .ltima expresión del
bloque.
Normalmente, el compilador de CA-Clipper compila un bloque de código en
el tiempo de compilación. Sin embargo, existen ocasiones en las que es
necesario compilar un bloque de código desde una cadena de carácteres en
tiempo de ejecución. Este proceso puede realizarse utilizando el
operador de macroexpresiónes (&).
EVAL() se utiliza, con frecuencia, para crear funciónes de iteraci.n.
Estas son funciónes que aplican un bloque a cada miembro de una
estructura de datos. AEVAL(), ASORT(), ASCAN() y DBEVAL() son funciónes
de iteraci.n (por ejemplo, AEVAL() eval.a un bloque para cada elemento
de una matriz).
Ejemplos
. En este ejemplo se crea un bloque de código que incrementa un
número y despuésólo eval.a:
bBloque := { |nArg| nArg + 1 }
? EVAL(bBloque, 1) // Resultado: 2
. En este ejemplo se muestra la compilación de un bloque de
código en el tiempo de ejecución utilizando el operador de
macroexpresiónes (&):
// Compilar una cadena en un bloque
bBloque := &("{ |nArg| nArg + 1 }")
// Evaluar el bloque
? EVAL(bBloque, 1)
Ficheros: La biblioteca asociada es CLIPPER.LIB.
EXP()
Calcula e**x
------------------------------------------------------------------------------
Sintaxis
EXP(<nExponente>) --> nAntilogaritmo
Argumentos
<nExponente> es el logaritmo natural para el que debe calcularse un
valor numérico.
Devuelve
EXP() devuelve un valor numérico que es equivalente al valor e elevado a
la potencia especificada.
Descripción
EXP() es una función matem.tica que calcula el valor de 'y' en la
ecuaci.n siguiente:
e**x = y
Donde e es la base de logaritmos naturales (2,71828...) y x es
<nExponente>. El valor máximo de <nExponente> es 45 antes de que se
produzca un desbordamiento numérico. EXP() y LOG() son funciónes
inversas.
El número de posiciónes decimales que se muestra est. determinado
.nicamente por SET DECIMALS con independencia del valor SET FIXED
actual.
Ejemplos
. En este ejemplo se muestran diversas llamadas a EXP():
? EXP(1) // Resultado: 2.72
SET DECIMALS TO 10
? EXP(1) // Resultado: 2.7182818285
? LOG(EXP(1)) // Resultado: 1.0000000000
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FCLOSE()
Cierra un fichero binario abierto y escribe memorias intermedias del DOS en
disco
------------------------------------------------------------------------------
Sintaxis
FCLOSE(<nManejador>) --> lError
Argumentos
<nManejador> es el manejador de fichero obtenido prevíamente de
FOPEN() o FCREATE().
Devuelve
FCLOSE() devuelve falso (.F.) si se ha producido un error mientras
estaba escribiendo; de lo contrario, devuelve verdadero (.T.).
Descripción
FCLOSE() es una función de fichero de bajo nivel que cierra ficheros
binarios y fuerza a que las memorias intermedias asociadas del DOS se
graben en disco. Si la operación.falla, FCLOSE() devuelve falso (.F.).
FERROR() puede utilizarse para determinar el motivo del fallo. Por
ejemplo, si intenta utilizar FCLOSE() con un manejador no víaacute;lido
devuelve falso (.F.) y FERROR() devuelve el error 6 de DOS, manejador no
víaacute;lido. Consulte FERROR() para obtener una lista completa de números de
errores.
.Advertencia! Esta función permite el acceso de bajo nivel a los
ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
requiere un conocimiento profundo del sistema operativo.
Ejemplos
. Este ejemplo utiliza FCLOSE() para cerrar un fichero binario
que se ha creado recientemente y muestra un mensaje de error si falla
el proceso de cierre:
#include "Fileio.ch"
//
nManejador := FCREATE("Fichprueba", FC_NORMAL)
IF !FCLOSE(nManejador)
? "Error cerrando el fichero, error número: ", FERROR()
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FCOUNT()
Devuelve el número de campos del fichero (.dbf) actual
------------------------------------------------------------------------------
Sintaxis
FCOUNT() --> nCampos
Devuelve
FCOUNT() devuelve el número de campos del fichero de base de datos en el
área de trabajo actual como un valor numérico entero. Si no hay ningún
fichero de base de datos abierto, FCOUNT() devuelve cero.
Descripción
FCOUNT() es una función de base de datos. Es .til en aplicaciónes que
contienen programas independientes de los datos que pueden funciónar con
cualquier fichero de base de datos. Estos incluyen programas
generalizados de importaci.n/exportaci.n y de informes. Normalmente,
debe utilizarse FCOUNT() para establecer el l.mite superior de un bucle
FOR...NEXT o DO WHILE que procesa un campo cada vez.
Por defecto, FCOUNT() funcióna en el área de trabajo seleccionada
actualmente.
Ejemplos
. Este ejemplo ilustra FCOUNT(), devolviendo el número de campos
del área de trabajo actual y de una no seleccionada:
USE Ventas NEW
USE Cliente NEW
? FCOUNT() // Resultado: 5
? Ventas->(FCOUNT()) // Resultado: 8
. Este ejemplo utiliza FCOUNT() para declarar una matriz con
información de campo:
LOCAL aCampos := ARRAY(FCOUNT())
AFIELDS(aCampos)
. Este ejemplo utiliza FCOUNT() como l.mite superior de un bucle
FOR que procesa la lista de los campos del área de trabajo actual:
LOCAL nCampo
USE Ventas NEW
FOR nCampo := 1 TO FCOUNT()
? FIELD(nCampo)
NEXT
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FCREATE()
Crea y/o trunca un fichero binario a longitud cero
------------------------------------------------------------------------------
Sintaxis
FCREATE(<cFichero>, [<nAtributo>]) --> nManejador
Argumentos
<cFichero> es el nombre del fichero que va a crearse. Si el fichero
ya existe, su longitud se trunca a cero sin aviso previo.
<nAtributo> es uno de los atributos de fichero binario que se
muestran en la tabla siguiente. Si se omite este argumento, el valor por
defecto es cero.
Atributos de Fichero Binario
------------------------------------------------------------------------
Valor Fileio.ch Atributo Descripción
------------------------------------------------------------------------
0 FC_NORMAL Normal Crea un fichero de lectura/escritura normal
(por defecto)
1 FC_READONLY S.lo lectura Crea un fichero de sólo
lectura
2 FC_HIDDEN Oculto Crea un fichero oculto
4 FC_SYSTEM Sistema Crea un fichero de sistema
------------------------------------------------------------------------
Devuelve
FCREATE() devuelve el número de manejador de fichero de DOS del nuevo
fichero binario en el rango 0-65.535. Si se produce un error, FCREATE()
devuelve -1 y FERROR() se establece de forma que indique un código de
error.
Descripción
FCREATE() es una función de fichero de bajo nivel que crea un nuevo
fichero o abre y trunca uno existente. Si <cFichero> no existe, se crea
y se abre para escritura. Si existe y puede abrirse para escritura, se
trunca a una longitud de cero. Si no puede abrirse para escritura,
FCREATE() devuelve -1 y FERROR() devuelve el valor de error apropiado.
Cuando FCREATE() crea un nuevo fichero de forma satisfactoria, .ste se
deja abierto en modo compartido compatible y en el de acceso de
lectura/escritura. El atributo de fichero especificado por el argumento
<nAtributo> se aplica al nuevo fichero cuando se cierra, permitiendo la
escritura en un fichero reci.n creado de sólo lectura. Si desea obtener
una lista de modos de acceso, consulte FOPEN().
Puesto que se requiere un manejador de ficheros para identificar un
fichero abierto para otras funciónes de fichero, el valor de retorno de
FCREATE() se asigna siempre a una variable para su utilización
posterior.
Al igual que otras funciónes de fichero, FCREATE() no utiliza los
valores SET DEFAULT o SET PATH para su operación. En su lugar, escribe
en el directorio actual del DOS a menos que se establezca una vía de
forma expl.cita.
.Advertencia! Esta función permite el acceso de bajo nivel a los
ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
requiere un conocimiento profundo del sistema operativo.
Ejemplos
. En este ejemplo se crea un fichero llamado Fichprueba y lo
abre para lectura y escritura:
#include "Fileio.ch"
//
IF (nManejador := FCREATE("Fichprueba", FC_NORMAL)) == -1
? "No se puede crear el fichero:", FERROR()
BREAK
ELSE
FWRITE(nManejador, "Hola a todos")
FCLOSE(nManejador)
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB,
el fichero de cabecera asociado es Fileio.ch.
FERASE()
Borra un fichero del disco
------------------------------------------------------------------------------
Sintaxis
FERASE(<cFichero>) --> nExito
Argumentos
<cFichero> es el nombre del fichero que debe borrarse del disco
incluyendo la extensión, opciónalmente precedido por una especificación
de unidad y/o vía.
Devuelve
FERASE() devuelve -1 si la operación.falla y cero si es satisfactoria.
En el caso de que se produzca un fallo, puede utilizarse FERROR() para
determinar la naturaleza del error.
Descripción
FERASE() es una función de fichero que borra un fichero especificado del
disco. FERASE() es igual que el mandato ERASE, pero devuelve un valor y
puede especificarse dentro de una expresión. Cuando se llama a FERASE(),
<cFichero> se borra del disco .nicamente si se encuentra en el
directorio del DOS actual o en el directorio especificado, de forma
expl.cita, como parte del nombre del fichero. Al igual que otras
funciónes de fichero y mandatos, FERASE() no utiliza los valores de SET
DEFAULT ni SET PATH para localizar <cFichero>.
.Advertencia! Los ficheros deben cerrarse antes de borrarlos con
FERASE().
Ejemplos
. En este ejemplo se borra un conjunto de ficheros que coinciden
con un patr.n comod.n:
#include "Directry.ch"
AEVAL(DIRECTORY("*.BAK"), { |aFichero| ;
FERASE(aFichero[F_NAME]) })
. En este ejemplo se borra un fichero y se muestra un mensaje si
falla la operación.
IF FERASE("Fichero.txt") == -1
? "Error de borrado de archivo:", FERROR()
BREAK
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FERROR()
Comprueba si existen errores después de una operación.de fichero binario
------------------------------------------------------------------------------
Sintaxis
FERROR() --> nC.digoError
Devuelve
FERROR() devuelve el error del DOS de la .ltima operación.de fichero
como un valor numérico entero. Si no hay ningún error, FERROR() devuelve
cero.
Valores de Retorno de FERROR()
------------------------------------------------------------------------
Error Significado
------------------------------------------------------------------------
0 Satisfactorio
2 Fichero no encontrado
3 V.a no encontrada
4 Demasiados ficheros abiertos
5 Acceso denegado
6 Manejador no víaacute;lido
8 Memoria insuficiente
15 Unidad especificada no víaacute;lida
19 Ha intentado escribir en un disco protegido contra escritura
21 Unidad no preparada
23 Error CRC de datos
29 Fallo de escritura
30 Fallo de lectura
32 Violaci.n de compartici.n
33 Violaci.n de bloqueo
------------------------------------------------------------------------
Descripción
FERROR() es una función de fichero de bajo nivel que indica un error del
DOS después de que se haya utilizado una función de fichero. Estas
funciónes incluyen FCLOSE(), FCREATE(), FERASE(), FOPEN(), FREAD(),
FREADSTR() y FRENAME(). FERROR() retiene su valor hasta la siguiente
ejecución de una función de fichero.
.Advertencia! Esta función permite el acceso de bajo nivel a los
ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
requiere un conocimiento profundo del sistema operativo
Ejemplos
. Este ejemplo comprueba FERROR() después de crear un fichero
binario y muestra un mensaje de error si falla la creaci.n:
#include "Fileio.ch"
//
nManejador := FCREATE("Temp.txt", FC_NORMAL)
IF FERROR() != 0
? "No se puede crear el fichero, error DOS ", FERROR()
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FIELDBLOCK()
Devuelve un bloque de código de asignación/lectura de un campo determinado
------------------------------------------------------------------------------
Sintaxis
FIELDBLOCK(<cNombreCampo>) --> bBloqueCampo
Argumentos
<cNombreCampo> es el nombre del campo al que har. referencia el
bloque de asignación/lectura.
Devuelve
FIELDBLOCK() devuelve un bloque de código que, cuando se eval.a, asigna
o lee el valor del campo determinado. Si <cNombreCampo> no existe en el
.rea de directorio actual, FIELDBLOCK() devuelve NIL.
Descripción
FIELDBLOCK() es una función de base de datos que crea un bloque de
código. Cuando se ejecuta con un argumento, el bloque de código creado
mediante esta función asigna el valor del argumento a <cNombreCampo>.
Cuando se ejecuta sin un argumento, el bloque de código recupera el
valor de <cNombreCampo>.
Observe que es posible que la variable de campo especificada no exista
cuando se cree el bloque de código, pero debe existir antes de que .ste
se ejecute.
Notas
. área de trabajo: El bloque de código devuelto por
FIELDBLOCK() asigna o recupera el valor del campo especificado en
cualquier área de trabajo en la que est. actualmente cuando se
ejecute el bloque. Por ejemplo, las .reas de trabajo 1 y 2
determinadas, contienen ambas el campo NomC:
SELECT 1
NomC := "Maribel"
SELECT 2
NomC := "Sonia"
bNomC := FIELDBLOCK("NomC")
SELECT 1
? EVAL(bNomC) // Resultado: "Maribel"
SELECT 2
? EVAL(bNomC) // Resultado: "Sonia"
La función FIELDWBLOCK() proporciona un bloque de asignación/lectura
para un campo en un área de trabajo espec.fica.
Ejemplos
. Este ejemplo compara FIELDBLOCK() con un bloque de código
creado utilizando el operador de macroexpresiónes. Observe que
utilizando FIELDBLOCK() evita los problemas de velocidad y tama.o
asociados con el citado operador:
// Bloque de asignación/lectura definido por medio del
// operador de macroexpresiónes
bAsilec := &( "{ |ValorAsig| IF( ValorAsig == NIL,;
NomC, NomC := ValorAsig ) }" )
// Bloque de asignación/lectura definido por medio de
// FIELDBLOCK()
// bAsilec creado aqu. es el equivalente
// funciónal del bAsilec anterior
bAsilec := FIELDBLOCK("NomC")
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FIELDGET()
Obtiene el valor de un campo a partir de su posición en la estructura de
la base de datos
------------------------------------------------------------------------------
Sintaxis
FIELDGET(<nCampo>) --> ValorCampo
Argumentos
<nCampo> es la posición ordinal del campo en la estructura de
registro para el área de trabajo actual.
Devuelve
FIELDGET() devuelve el valor del campo especificado. Si <nCampo> no
corresponde a la posición de ningún campo del fichero de base de datos
actual, FIELDGET() devuelve NIL.
Descripción
FIELDGET() es una función de base de datos que obtiene el valor de un
campo utilizando su posición dentro de la estructura del fichero de la
base de datos en lugar de su nombre de campo. Dentro de las funciónes
gen.ricas de servicio de base de datos esto permite, entre otras cosas,
recuperar los valores de campos sin utilizar el operador de
macroexpresiónes.
Ejemplos
. Este ejemplo compara FIELDGET() con el código funciónalmente
equivalente que utiliza el operador de macroexpresiónes para obtener
el valor de un campo:
LOCAL nCampo := 1, NomC, ValC
USE Cliente NEW
//
// Usando el operador de macroexpresiónes
NomC := FIELD( nCampo ) // Obtener el nombre
// del campo
ValC := &NomC // Obtener el valor
// del campo
// Usando FIELDGET()
ValC := FIELDGET( nCampo ) // Obtener el valor
// del campo
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FIELDNAME()/FIELD()
Devuelve un nombre de campo del fichero (.dbf) actual
------------------------------------------------------------------------------
Sintaxis
FIELDNAME/FIELD(<nPosici.n>) --> cNombreCampo
Argumentos
<nPosici.n> es la posición de un campo en la estructura del fichero
de base de datos.
Devuelve
FIELDNAME() devuelve el nombre del campo especificado como una cadena de
carácteres. Si <nPosici.n> no corresponde con un campo existente en el
fichero de base de datos actual o si no se abre ningún fichero de base
de datos en el área de trabajo actual, FIELDNAME() devuelve una cadena
nula ("").
Descripción
FIELDNAME() es una función de base de datos que devuelve un nombre de
campo utilizando un ííndice en la posición del nombre de campo en la
estructura de base de datos. Util.celo en aplicaciónes independientes de
los datos donde el nombre de campo es desconocido. Si requiere
información de m.s de un campo, utilice AFIELDS() para crear una matriz
de información de campos o COPY STRUCTURE EXTENDED para crear una base
de datos de información de campos.
Si necesita información adicional sobre estructuras de ficheros de base
de datos, utilice TYPE() y LEN(). Para obtener el número de posiciónes
decimales de un campo numérico, utilice la expresión siguiente:
LEN(SUBSTR(STR(<idCampo>), RAT(".", ;
STR(<idCampo>)) + 1))
Por defecto, FIELDNAME() funcióna en el área de trabajo seleccionada
actualmente, tal como se muestra en el ejemplo siguiente.
Ejemplos
. En estos ejemplos se ilutra FIELDNAME() utilizado con otras
funciónes:
USE Ventas
? FIELDNAME(1) // Resultado: SUCURSAL
? FCOUNT() // Resultado: 5
? LEN(FIELDNAME(0)) // Resultado: 0
? LEN(FIELDNAME(40)) // Resultado: 0
. En este ejemplo se utiliza FIELDNAME() para listar el nombre y
tipo de cada campo de Cliente.dbf:
USE Cliente NEW
FOR nCampo := 1 TO FCOUNT()
? PADR(FIELDNAME(nCampo), 10),;
VALTYPE(&(FIELDNAME(nCampo)))
NEXT
. En este ejemplo se accede a campos en .reas de trabajo no
seleccionadas, utilizando expresiónes de alias:
USE Ventas NEW
USE Cliente NEW
USE Facturas NEW
//
? Ventas->(FIELDNAME(1)) // Resultado: NUMVENTA
? Cliente->(FIELDNAME(1)) // Resultado: NUMCLIE
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FIELDPOS()
Devuelve la posición de un campo en un área de trabajo
------------------------------------------------------------------------------
Sintaxis
FIELDPOS(<cNombreCampo>) --> nPosCampo
Argumentos
<cNombreCampo> es el nombre de un campo en el área de trabajo actual
o especificada.
Devuelve
FIELDPOS() devuelve la posición del campo especificado dentro de la
lista de campos asociados con el área de trabajo actual o especificada.
Si el área de trabajo actual no tiene ningún campo con el nombre
especificado, FIELDPOS() devuelve cero.
Descripción
FIELDPOS() es una función de base de datos que realiza el proceso
inverso de la función FIELDNAME(). FIELDPOS() se utiliza frecuentemente
junto con las funciónes FIELDPUT() y FIELDGET().
FIELDPOS() devuelve los nombres de campos en cualquier área de trabajo
no seleccionada, haciendo referencia a la función por medio de una
expresión con alias. Consulte el ejemplo que se muestra m.s adelante.
Ejemplos
. En este ejemplo se muestra una especificación t.pica de la
función FIELDPOS():
USE Cliente NEW
? FIELDPOS("Nombre") // Resultado: 1
? FIELDGET(FIELDPOS("Nombre")) // Resultado: Sonia
. En este ejemplo se utiliza FIELDPOS() para devolver la
posición de un campo especificado en un área de trabajo no
seleccionada:
USE Cliente NEW
USE Facturas NEW
? Cliente->(FIELDPOS("Nombre")) // Resultado: 1
? Cliente->(FIELDGET(FIELDPOS("Nombre")))
// Resultado: Sonia
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FIELDPUT()
Establece el valor de una variable de campo a partir de su posición en
la estructura de la base de datos
------------------------------------------------------------------------------
Sintaxis
FIELDPUT(<nCampo>, <expAsignar>) --> ValorAsignado
Argumentos
<nCampo> es la posición ordinal del campo en el fichero de base de
datos actual.
<expAsignar> es el valor que debe asignarse al campo dado. El tipo
de datos de esta expresión debe coincidir con el tipo de datos de la
variable de campo designada.
Devuelve
FIELDPUT() devuelve el valor asignado al campo designado. Si <nCampo> no
corresponde con la posición de ningún campo del fichero de base de datos
actual, FIELDPUT() devuelve NIL.
Descripción
FIELDPUT() es una función de base de datos que asigna <expAsignar> al
campo en la posición ordinal <nCampo> en el área de trabajo actual. Esta
función le permite establecer el valor de un campo utilizando su
posición dentro de la estructura del fichero de base de datos en lugar
de su nombre de campo. Dentro de las funciónes gen.ricas de servicio de
base de datos esto permite, entre otras cosas, seleccionar valores de
campo sin tener que utilizar el operador de macroexpresiónes.
Ejemplos
. En este ejemplo se compara FIELDPUT() con el código
funciónalmente equivalente, que utiliza el operador de
macroexpresiónes para establecer el valor de un campo:
// Usando el operador de macroexpresiónes
NomC := FIELD(nCampo) // Obtener nombre de campo
FIELD->&NomC := ValC // Establecer valor de campo
// Usando FIELDPUT()
FIELDPUT(nCampo, ValC) // Establecer valor de campo
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FIELDWBLOCK()
Devuelve un bloque de código de asignación/lectura de un campo en un .rea
de trabajo determinada
------------------------------------------------------------------------------
Sintaxis
FIELDWBLOCK(<cNombreCampo>, <nAreaTrabajo>) --> bBloqueCampoT
Argumentos
<cNombreCampo> es el nombre del campo especificado como una cadena
de carácteres.
<nAreaTrabajo> es el número de área de trabajo donde reside el campo
especificado.
Devuelve
FIELDWBLOCK() devuelve un bloque de código que, cuando se eval.a, asigna
u obtiene el valor de <cNombreCampo> en el área de trabajo designada por
<nAreaTrabajo>. Si <cNombreCampo> no existe en el área de trabajo
especificada, FIELDWBLOCK() devuelve NIL.
Descripción
FIELDWBLOCK() es una función de base de datos que crea un bloque de
código. Cuando se eval.a el bloque de código con la función EVAL(), en
primer lugar, selecciona el <nAreaTrabajo> designada. Si se ha pasado un
argumento, el bloque de código asigna el valor del argumento a
<cNombreCampo>. Si no se ha pasado ningún argumento, el bloque de código
obtiene el valor de <cNombreCampo>. El área de trabajo original se
vuelve a seleccionar antes de que el bloque de código devuelva el
control.
Observe que es posible que no exista la variable de campo especificada
cuando se cree el bloque de código, pero debe existir antes de que se
ejecute.
Notas
. FIELDWBLOCK() es similar a FIELDBLOCK(), con la excepci.n de
que FIELDWBLOCK() incorpora un área de trabajo fija en el bloque de
asignación/lectura.
Ejemplos
. Este ejemplo compara FIELDWBLOCK() con un bloque de código
creado utilizando el operador de macro. Observe que utilizando
FIELDWBLOCK() se evitan los problemas de velocidad y tama.o asociados
con el operador de macroexpresiónes:
// Bloque de asignación/lectura para el área de trabajo 1
// definido con el operador de macroexpresiónes
bAsilec := &( "{ |ValorAsig| IF( ValorAsig == NIL, ;
1->NomC, 1->NomC := ValorAsig ) }" )
// Bloque de asignación/lectura definido por medio de
// FIELDWBLOCK()
// bAsilec creado aqu. es el equivalente
// funciónal del bAsilec anterior
bAsilec := FIELDWBLOCK("NomC", 1)
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FILE()
Determina si existen ficheros en el directorio o vía por defecto de
CA-Clipper
------------------------------------------------------------------------------
Sintaxis
FILE(<cEspecFichero>) --> lExiste
Argumentos
<cEspecFichero> determina una especificación de fichero estándar que
puede incluir carácteres comod.n * y ?, as. como una referencia de
unidad y de vía. Las referencias expl.citas a un fichero deben incluir
también una extensión.
Devuelve
FILE() devuelve verdadero (.T.) si alg.n fichero coincide con el patr.n
<cEspecFichero>; de lo contrario, devuelve falso (.F.).
Descripción
FILE() es una función de entorno que determina si se ha localizado alg.n
fichero que coincida con un patr.n de especificación de fichero. FILE()
busca el directorio especificado si se ha especificado una vía de forma
expl.cita.
Si no se ha especificado una vía, FILE() busca en el directorio por
defecto de CA-Clipper y posteriormente, la vía de CA-Clipper. En ningún
caso se busca en la vía del DOS. Observe también que FILE() no reconoce
los ficheros ocultos o de sistema en su b.squeda.
Ejemplos
. En este ejemplo FILE() intenta localizar Ventas.dbf en otro
directorio de CA-Clipper, que no sea el utilizado por defecto:
? FILE("Ventas.dbf") // Resultado: .F.
? FILE("\APPS\DBF\Ventas.dbf") // Resultado: .T.
//
SET PATH TO \APPS\DBF
? FILE("Ventas.dbf") // Resultado: .T.
//
SET PATH TO
SET DEFAULT TO \APPS\DBF\
? FILE("Ventas.dbf") // Resultado: .T.
? FILE("*.dbf") // Resultado: .T.
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FKLABEL()*
Devuelve un nombre de tecla de función
------------------------------------------------------------------------------
Sintaxis
FKLABEL(<nTeclafunción>) --> cEtiqTecla
Devuelve
FKLABEL() devuelve una cadena de carácteres que representa el nombre de
la tecla de función especificada por el argumento numérico,
<nTeclafunción>. Si el argumento es menor que uno o mayor que 40, la
función devuelve una cadena ("") nula.
Descripción
FKLABEL() es una función de compatibilidad que se utiliza para duplicar
la función FKLABEL() en dBASE III PLUS. Como principio general, la
utilización de esta función no es recomendable ni necesaria en
CA-Clipper. Las teclas de función se etiquetan con Fn, donde n abarca de
uno a 40 y corresponde directamente con el argumento FKLABEL().
Ficheros: La biblioteca asociada es EXTEND.LIB,
el módulo fuente es SOURCE\SAMPLE\FKLABEL.PRG.
FKMAX()*
Devuelve el número de teclas de función como una constante
------------------------------------------------------------------------------
Sintaxis
FKMAX() --> nTeclasfunción
Descripción
FKMAX() es una función de compatibilidad que se utiliza para duplicar la
función FKMAX() en dBASE III PLUS. Como principio general, la
utilización de esta función no es recomendable ni necesaria en
CA-Clipper. Simplemente, devuelve un valor constante igual a 40.
Ficheros: La biblioteca asociada es EXTEND.LIB,
el módulo fuente es SOURCE\SAMPLE\FKMAX.PRG.
FLOCK()
Bloquea un fichero de base de datos abierto en modo compartido
------------------------------------------------------------------------------
Sintaxis
FLOCK() --> lExito
Devuelve
FLOCK() devuelve verdadero (.T.) si el intento de bloquear un fichero de
base de datos en uso en el área de trabajo actual es satisfactorio; de
lo contrario, devuelve falso (.F.). Si desea obtener más información
sobre el bloqueo de ficheros, consulte el capítulo Programaci.n en Red
en la gu.a Programaci.n y Utilidades.
Descripción
FLOCK() es una función de base de datos que se utiliza en entornos de
red para bloquear un fichero de base de datos abierto en modo
compartido, evitando as. que otros usuarios actualicen el fichero hasta
que se libere el bloqueo. Los registros en el fichero bloqueado sólo
están accesibles para operación.s de lectura.
FLOCK() se relaciona con USE...EXCLUSIVE y RLOCK(). USE...EXCLUSIVE abre
un fichero de base de datos, de forma que ningún otro usuario pueda
abrir el mismo fichero al mismo tiempo y se trata del mecanismo de
bloqueo m.s restrictivo de CA-Clipper. RLOCK() es el menos restrictivo e
intenta situar un bloqueo de actualizaci.n en un registro compartido,
impidiendo que otros usuarios actualicen el registro actual. FLOCK()
representa un nivel de restricci.n medio.
FLOCK() se utiliza en operación.s que acceden a la totalidad del fichero
de base de datos. Normalmente, estos son mandatos que actualizan el
fichero con un ámbito o una condición, como por ejemplo, DELETE o
REPLACE ALL. A continúa.ión, se muestra una lista de estos mandatos:
Mandatos que requieren FLOCK()
------------------------------------------------------------------------
Mandato Modo
------------------------------------------------------------------------
APPEND FROM FLOCK() o USE...EXCLUSIVE
DELETE (varios registros) FLOCK() o USE...EXCLUSIVE
RECALL (varios registros) FLOCK() o USE...EXCLUSIVE
REPLACE (varios registros) FLOCK() o USE...EXCLUSIVE
UPDATE ON FLOCK() o USE...EXCLUSIVE
------------------------------------------------------------------------
Por cada llamada de FLOCK(), existe un intento de bloquear el fichero de
base de datos y el resultado se devuelve como un valor l.gico. Un
bloqueo de fichero falla si otro usuario tiene actualmente un bloqueo de
fichero o de registro para el mismo fichero de base de datos o bien, si
otro usuario est. usando la base de datos en modo exclusivo. Si FLOCK()
es satisfactorio, el bloqueo de fichero permanece hasta que efect.e
UNLOCK, CLOSE DATABASE o RLOCK().
Por defecto, FLOCK() funcióna en el área de trabajo seleccionada, tal
como se muestra en el ejemplo siguiente.
Notas
. SET RELATION: CA-Clipper no bloquea autom.ticamente todas
las .reas de trabajo en la cadena de relaci.n cuando bloquea el .rea
de trabajo actual y el uso de la función UNLOCK no es efectivo en
.reas de trabajo relacionadas.
Ejemplos
. Este ejemplo utiliza FLOCK() para una actualizaci.n por lotes
de los precios de Inventar.dbf:
USE Inventar NEW
IF FLOCK()
REPLACE ALL Inventar->Precio WITH ;
Inventar->Precio * 1.1
ELSE
? "Fichero no disponible"
ENDIF
. Este ejemplo utiliza una expresión con alias para intentar un
bloqueo de fichero en un área de trabajo no seleccionada:
USE Ventas NEW
USE Cliente NEW
//
IF !Ventas->(FLOCK())
? "Ventas est. siendo usado por otro usuario"
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FOPEN()
Abre un fichero binario
------------------------------------------------------------------------------
Sintaxis
FOPEN(<cFichero>, [<nModo>]) --> nManejador
Argumentos
<cFichero> es el nombre del fichero que se va a abrir incluyendo la
vía, si existe.
<nModo> es el modo de apertura del DOS solicitado, que indica c.mo
puede accederse al fichero abierto. El modo de apertura se compone de
elementos de los dos tipos de modos que se describen en las tablas que
aparecen m.s adelante. Si .nicamente se utiliza el Modo de Acceso, el
fichero se abre como no compartido. El modo de apertura por defecto es
cero, lo que indica no compartido y sólo de lectura.
Modos de Acceso FOPEN()
------------------------------------------------------------------------
Modo Fileio.ch Operaci.n
------------------------------------------------------------------------
0 FO_READ Abierto para lectura (por defecto)
1 FO_WRITE Abierto para escritura
2 FO_READWRITE Abierto para lectura o escritura
------------------------------------------------------------------------
Los Modos de Utilizaci.n Compartida determinan c.mo pueden acceder otros
procesos al fichero.
Los Modos de Acceso en combinación (+) con los modos Compartidos
determinan la accesibilidad del fichero en un entorno de red.
Modos de Utilizaci.n Compartida FOPEN()
------------------------------------------------------------------------
Modo Fileio.ch Operaci.n
------------------------------------------------------------------------
0 FO_COMPAT Modo de compatibilidad (por defecto)
16 FO_EXCLUSIVE Uso exclusivo
32 FO_DENYWRITE Evita que otros escriban
48 FO_DENYREAD Evita que otros lean
64 FO_DENYNONE Permite que otros lean o escriban
64 FO_SHARED Igual que FO_DENYNONE
------------------------------------------------------------------------
Devuelve
FOPEN() devuelve el manejador del fichero abierto en el rango 0-65.535.
Si se produce un error, FOPEN() devuelve -1.
Descripción
FOPEN() es una función de fichero de bajo nivel, que abre un fichero
binario existente para lectura y escritura, según el argumento <nModo>.
Siempre que exista un error de apertura, FERROR() devuelve el número de
error del DOS. Por ejemplo, si el fichero no existe, FOPEN() devuelve -1
y FERROR() devuelve 2 para indicar que no se ha localizado el fichero.
Consulte FERROR() para obtener una lista completa de números de error.
Si el fichero especificado se abre de forma satisfactoria, el valor
devuelto es el manejador del DOS para el fichero. Este valor es similar
a un alias en el sistema de base de datos y es necesario para
identificar el fichero abierto para otras funciónes de fichero. Por lo
tanto, es importante asignar el valor de retorno a una variable para su
utilización posterior, tal como se muestra en el ejemplo que aparece m.s
adelante.
.Advertencia! Esta función permite el acceso de bajo nivel a los
ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
requiere un conocimiento profundo del sistema operativo.
Notas
. Acceso a ficheros en otros directorios: FOPEN() no act.a
seg.n los valores de SET DEFAULT ni SET PATH. En su lugar, busca en
el directorio y vía actual del DOS, a menos que se establezca una
vía, de forma expl.cita, como parte del argumento <cFichero>.
Ejemplos
. Este ejemplo utiliza FOPEN() para abrir un fichero con estado
compartible de lectura/escritura y muestra un mensaje de error si
falla la apertura:
#include "Fileio.ch"
//
nManejador := FOPEN("Temp.txt", FO_READWRITE + FO_SHARED)
IF FERROR() != 0
? "No se puede abrir el fichero, error DOS", FERROR()
BREAK
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB,
el fichero de cabecera asociado es Fileio.ch.
FOUND()
Determina si se encontr. el registro buscado en la anterior operación. de b.squeda
------------------------------------------------------------------------------
Sintaxis
FOUND() --> lExito
Devuelve
FOUND() devuelve verdadero (.T.) si el último mandato de b.squeda ha
sido satisfactorio; de lo contrario, devuelve falso (.F.).
Descripción
FOUND() es una función de base de datos que determina si una operación. de b.squeda (es decir, FIND, LOCATE, CONTINUE, SEEK o SET RELATION) ha
sido satisfactoria. Cuando se ejecuta uno de estos mandatos, FOUND()
devuelve verdadero (.T.) si encuentra una coincidencia; de lo contrario,
devuelve falso (.F.).
Si el mandato de b.squeda es LOCATE o CONTINUE, una coincidencia es el
siguiente registro que cumpla con el ámbito y la condición. Si el
mandato de b.squeda es FIND, SEEK o SET RELATION, una coincidencia es la
primera clave del índice de control que es igual al argumento de
b.squeda. Si el valor clave es igual al argumento de b.squeda, FOUND()
devuelve verdadero (.T.); de lo contrario, es falso (.F.).
El valor de FOUND() se retiene hasta que se ejecuta otro mandato de
movimiento de registro. A menos que sea otro mandato de b.squeda,
FOUND() se establece autom.ticamente en falso (.F.).
Cada área de trabajo tiene un valor FOUND(). Esto significa que si un
área de trabajo tiene una relaci.n establecida con un área de trabajo
secundaria, la consulta de FOUND() en el .rea secundaria devuelve
verdadero (.T.) si encuentra una coincidencia.
Por defecto, FOUND() act.a en el área de trabajo seleccionada
actualmente. Puede hacer que funcióne en un área de trabajo no
seleccionada especific.ndola dentro de una expresión de alias (consulte
el ejemplo siguiente).
FOUND() devuelve falso (.F.) si no hay ningúna base de datos abierta en
el área de trabajo actual.
Ejemplos
. En este ejemplo se ilustra el comportamiento de FOUND()
después de un mandato de movimiento de registro:
USE Ventas INDEX Ventas
? INDEXKEY(0) // Resultado: VENDEDOR
SEEK "1000"
? FOUND() // Resultado: .F.
SEEK "100"
? FOUND() // Resultado: .T.
SKIP
? FOUND() // Resultado: .F.
. En este ejemplo se comprueba un valor FOUND() en un .rea de
trabajo no seleccionada utilizando una expresión de alias:
USE Ventas INDEX Ventas NEW
USE Cliente INDEX Cliente NEW
SET RELATION TO Numclien INTO Ventas
//
SEEK "Casanova"
? FOUND(), Ventas->(FOUND())
. Este fragmento de código procesa todos los registros de
Cliente con el valor clave "Casanova" utilizando FOUND() para
determinar cu.ndo cambian los valores clave:
USE Cliente INDEX Cliente NEW
SEEK "Casanova"
DO WHILE FOUND()
.
. <sentencias>
.
SKIP
LOCATE REST WHILE Nombre == "Casanova"
ENDDO
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FREAD()
Lee carácteres de un fichero binario en una variable de memoria intermedia
------------------------------------------------------------------------------
Sintaxis
FREAD(<nManejador>, @<cVarMemInter>, <nBytes>) --> nBytes
Argumentos
<nManejador> es el manejador de fichero que se obtiene de FOPEN(),
FCREATE() o predefinido por el DOS.
<cVarMemInter> es el nombre de una variable de carácter inicializada
y existente que se utiliza para almacenar datos le.dos de un fichero
especificado. La longitud de esta variable debe ser mayor que o igual a
<nBytes>. <cVarMemInter> debe pasarse por referencia y, por lo tanto,
debe ir precedida por el operador pasar por referencia (@).
<nBytes> es el número de bytes que deben leerse en la memoria
intermedia.
Devuelve
FREAD() devuelve el número de bytes le.dos satisfactoriamente como un
valor numérico entero. Un valor de retorno menor que <nBytes> o cero
indica el final del fichero o cualquier otro error de lectura.
Descripción
FREAD() es una función de fichero de bajo nivel que lee carácteres de un
fichero binario en una variable de carácteres existente. Lee el fichero
comenzando en la posición del puntero de fichero del DOS, avanzando
dicho puntero el número de bytes le.dos. Se leen todos los carácteres
incluyendo los de control, nulos y los de código ASCII superior a 127.
FREAD() es similar en ciertos aspectos a FREADSTR() y FSEEK().
FREADSTR() lee un número especificado de bytes de un fichero hasta el
carácter nulo siguiente (CHR(0)). FSEEK() desplaza el puntero del
fichero sin leer.
Si surge un error durante la lectura del fichero, FERROR() devuelve el
número de error del DOS. Consulte FERROR() para obtener una lista de
números de error.
.Advertencia! Esta función permite el acceso de bajo nivel a los
ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
requiere un conocimiento profundo del sistema operativo.
Ejemplos
. Este ejemplo utiliza FREAD() después de abrir un fichero, de
forma satisfactoria, para leer 128 bytes en un .rea de memoria
intermedia:
#define BLOQUE_F 128
//
cMemInter := SPACE(BLOQUE_F)
nManejador := FOPEN("Temp.txt")
//
IF FERROR() != 0
? "Error de apertura de fichero:", FERROR()
ELSE
IF FREAD(nManejador, @cMemInter, BLOQUE_F) <> BLOQUE_F
? "Error de lectura en Temp.txt"
ENDIF
FCLOSE(nManejador)
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FREADSTR()
Lee carácteres de un fichero binario
------------------------------------------------------------------------------
Sintaxis
FREADSTR(<nManejador>, <nBytes>) --> cCadena
Argumentos
<nManejador> es el manejador de ficheros obtenido de FOPEN(),
FCREATE() o predefinido por el DOS.
<nBytes> es el número de bytes que deben leerse, comenzando en la
posición del puntero del fichero del DOS actual.
Devuelve
FREADSTR() devuelve una cadena de carácteres de un máximo de 65.535
(64K) bytes. Un valor de retorno nulo ("") indica un error o el final
del fichero.
Descripción
FREADSTR() es una función de fichero de bajo nivel que lee carácteres de
un fichero binario abierto que comienza en la posición de puntero del
fichero del DOS actual. Los carácteres se leen hasta <nBytes> o hasta
que se encuentra un carácter nulo (CHR(0)). Se leen todos los carácteres
incluyendo los de control, con la excepci.n de CHR(0). El puntero del
fichero avanza <nBytes>. Si este número es mayor que el número de bytes
desde la posición del puntero hasta el final del fichero, el puntero se
sit.a en el último byte del fichero.
.Advertencia! Esta función permite el acceso de bajo nivel a los
ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
requiere un conocimiento profundo del sistema operativo.
Ejemplos
. El ejemplo de la p.gina siguiente muestra los valores ASCII de
los primeros 16 bytes de un fichero de texto:
#include "Fileio.ch"
//
nManejador := FOPEN("Nuevo.txt", FC_NORMAL)
IF FERROR() != 0
? "Error de apertura de fichero:", FERROR()
ELSE
cCadena := FREADSTR(nManejador, 16)
? cCadena
FCLOSE(nManejador)
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FRENAME()
Cambia el nombre de un fichero
------------------------------------------------------------------------------
Sintaxis
FRENAME(<cFicheroAntiguo>, <cNuevoFichero>) --> nExito
Argumentos
<cFicheroAntiguo> es el nombre del fichero que debe renombrarse,
incluyendo su extensión. También puede incluirse la letra de la unidad
y/o nombre de vía, como parte del nombre del fichero.
<cNuevoFichero> es el nuevo nombre del fichero, incluyendo su
extensión. También puede incluirse la letra de la unidad y/o nombre de
vía como parte del nombre.
Devuelve
FRENAME() devuelve -1 si la operación.falla y cero si es satisfactoria.
En el caso de que se produzca un fallo, puede utilizarse FERROR() para
determinar la naturaleza del error.
Descripción
FRENAME() es una función de fichero que cambia el nombre de un fichero
especificado por uno nuevo y act.a de forma id.ntica al mandato RENAME.
Cuando se llama FRENAME(), el <cFicheroAntiguo> sólo se renombra si est.
situado en el directorio del DOS actual o en la vía especificada.
FRENAME() no utiliza los valores de SET DEFAULT o SET PATH para
localizar <cFicheroAntiguo>.
Si el directorio fuente es diferente del directorio destáno, el fichero
se desplaza al directorio destáno. En el caso de que exista
<cNuevoFichero> o est. abierto actualmente, FRENAME() falla y devuelve -
1, indicando que no ha realizado la acci.n designada. Con FERROR() puede
determinarse la naturaleza del error.
.Advertencia! Los ficheros deben cerrarse antes de renombrarlos. Si
se intenta renombrar un fichero abierto pueden producirse resultados
impredecibles. Cuando se renombra un fichero de base de datos, el
fichero memo asociado (.dbt) también debe renombrarse. Si no lo hace de
este modo, puede poner en peligro la integridad de sus bases de datos.
Ejemplos
. En este ejemplo se muestra c.mo se renombra un fichero:
IF FRENAME("FichAnt.txt", "NuevFich.txt") == -1
? "Error de fichero:", FERROR()
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
FSEEK()
Sitúa el puntero de fichero binario en una nueva posición
------------------------------------------------------------------------------
Sintaxis
FSEEK(<nManejador>, <nDesplazamiento>, [<nOrigen>]) --> nPosici.n
Argumentos
<nManejador> es el manejador de ficheros obtenido de FOPEN(),
FCREATE() o predefinido por el DOS.
<nDesplazamiento> es el número de bytes que se va a desplazar el
puntero del fichero desde la posición definida por <nOrigen>. Puede ser
un número positivo o negativo. Un número positivo desplaza el puntero
hacia adelante y uno negativo lo desplaza hacia atr.s en el fichero.
<nOrigen> define la situaci.n inicial del puntero del fichero antes
de que se ejecute FSEEK(). El valor por defecto es cero, representando
el inicio del fichero. Si <nOrigen> es el final del fichero,
<nDesplazamiento> debe ser cero o negativo.
M.todos para Desplazar el Puntero del Fichero
------------------------------------------------------------------------
Origen Fileio.ch Descripción
------------------------------------------------------------------------
0 FS_SET Busca desde el principio del fichero
1 FS_RELATIVE Busca desde la posición actual del puntero
2 FS_END Busca desde el final del fichero
------------------------------------------------------------------------
Devuelve
FSEEK() devuelve la nueva posición del puntero del fichero relativa al
inicio del fichero (posición 0) como un valor numérico entero. Este
valor es independiente de la posición original del puntero del fichero.
Descripción
FSEEK() es una función de fichero de bajo nivel que desplaza el puntero
del fichero hacia adelante o hacia atr.s en un fichero binario abierto
sin leer realmente el contenido del fichero especificado. La posición
inicial y desplazamiento se especifican como argumentos de función y se
devuelve la nueva posición en el fichero. Independientemente de los
argumentos de función especificados, el puntero del fichero no puede
desplazarse de forma que exceda los l.mites del inicio o final del
fichero.
.Advertencia! Esta función permite el acceso de bajo nivel a
ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
requiere un conocimiento profundo del sistema operativo.
Ejemplos
. En este ejemplo se utiliza FSEEK() para determinar la longitud
de un fichero buscando desde el final del mismo. Seguidamente, el
puntero se restablece al inicio del fichero:
#include "Fileio.ch"
//
// Abrir el fichero en modo de sólo lectura
IF (nManejador := FOPEN("Temp.txt")) >= 0
//
// Obtener la longitud del fichero
nLongitud := FSEEK(nManejador, 0, FS_END)
//
// Restablecer la posición al comienzo del
// fichero
FSEEK(nManejador, 0)
FCLOSE(nManejador)
ELSE
? "Error de apertura de fichero:", FERROR()
ENDIF
. Esta pseudofunción sit.a el puntero del fichero en el último
byte de un fichero binario:
#define FinalFichero(nManejador);
(FSEEK(nManejador, 0, FS_END))
. Esta pseudofunción sit.a el puntero del fichero en el primer
byte de un fichero binario:
#define InicioFichero(nManejador);
(FSEEK(nManejador, 0))
. Esta pseudofunción informa de la posición actual del puntero
del fichero en un fichero binario especificado:
#define PosFichero(nManejador);
(FSEEK(nManejador, 0, FS_RELATIVE))
Ficheros: La biblioteca asociada es CLIPPER.LIB,
el fichero de cabecera asociado es Fileio.ch.
FWRITE()
Escribe en un fichero binario abierto
------------------------------------------------------------------------------
Sintaxis
FWRITE(<nManejador>, <cMemInter>, [<nBytes>]) --> nBytesEscritos
Argumentos
<nManejador> es el manejador de ficheros obtenido de FOPEN(),
FCREATE() o predefinido por el DOS.
<cMemInter> es la cadena de carácteres que debe escribirse en el
fichero especificado.
<nBytes> indica el número de bytes que debe escribirse, comenzando
en la posición del puntero de fichero actual. Si se omite, se escribe
todo el contenido de <cMemInter>.
Devuelve
FWRITE() devuelve el número de bytes escritos como un valor numérico
entero. Si el valor devuelto es igual a <nBytes>, la operación.ha
resultado satisfactoria. Si el valor de retorno es menor que <nBytes> o
es cero, es debido a que el disco est. lleno o se ha producido otro
error.
Descripción
FWRITE() es una función de fichero de bajo nivel que escribe datos en un
fichero binario abierto desde una memoria intermedia de cadena de
carácteres. Puede escribir todo el contenido de la memoria intermedia o
tan sólo una parte. La escritura comienza en la posición actual del
fichero y la función devuelve el número real de bytes escritos.
Si FWRITE() produce una condición de error, puede utilizar FERROR() para
determinar el error espec.fico.
.Advertencia! Esta función permite el acceso de bajo nivel a los
ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
requiere un profundo conocimiento del sistema operativo
Ejemplos
. En este ejemplo se copia el contenido de un fichero en otro:
#include "Fileio.ch"
#define BLOQUE_F 512
//
cMemInter := SPACE(BLOQUE_F)
nFichEnt := FOPEN("Temp.txt", FO_READ)
nFichSal := FCREATE("NuevFich.txt", FC_NORMAL)
lHecho := .F.
//
DO WHILE !lHecho
nBytesLec := FREAD(nFichEnt, @cMemInter, BLOQUE_F)
IF FWRITE(nFichSal, cMemInter, nBytesLec) < ;
nBytesLec
? "Fallo de escritura: ", FERROR()
lHecho := .T.
ELSE
lHecho := (nBytesLec == 0)
ENDIF
ENDDO
//
FCLOSE(nFichEnt)
FCLOSE(nFichSal)
Ficheros: La biblioteca asociada es CLIPPER.LIB.
GETENV()
Obtiene el contenido de una variable de entorno DOS
------------------------------------------------------------------------------
Sintaxis
GETENV(<cVariableEntorno>) --> cCadena
Argumentos
<cVariableEntorno> es el nombre de la variable de entorno del DOS.
Cuando se especifica este argumento, puede utilizarse cualquier
combinación de letras mayúsculas y minúsculas; GETENV() no es sensible a
las mayúsculas y minúsculas.
Devuelve
GETENV() devuelve el contenido de la variable de entorno del DOS
especificada como una cadena de carácteres. Si no se puede localizar la
variable, GETENV() devuelve una cadena nula ("").
Descripción
GETENV() es una función de entorno que le permite obtener información
del entorno DOS en un programa de aplicación. Normalmente, .sta es la
información de la configuración, incluyendo los nombres de vía que
proporcionan la situaci.n de los ficheros (base de datos, índice,
etiqueta o informes). Esta función es particularmente .til en entornos
de red.
Notas
. Valor de retorno vac.o: Si est. seguro de que existe una
variable de entorno y GETENV() devuelve siempre una cadena nula (""),
aseg.rese de que no existen espacios entre el nombre de variable de
entorno y el primer carácter de la cadena que se le ha asignado en el
mandato SET del DOS.
. Compatibilidad: En las versiones anteriores de CA-Clipper,
la función se llamaba GETE(). Esta forma abrevíada de GETENV() es
todavía operativa.
Ejemplos
. Este ejemplo obtiene el valor actual de PATH del DOS,
convirti.ndola en la vía actual de CA-Clipper:
cVia := GETENV("PATH")
SET PATH TO (cVia)
. Este ejemplo utiliza variables de entorno para configurar las
posiciónes espec.ficas de ficheros. Cuando se configura un sistema,
se definen variables de entorno que contienen la posición de varios
tipos de fichero as. como la variable de entorno CLIPPER (consulte el
capítulo Entorno de Ejecuci.n en la gu.a Programaci.n y Utilidades),
de forma an.loga a lo siguiente:
C>SET LOC_DBF=<vía de fichero de base de datos>
C>SET LOC_NTX=<vía de fichero de índice>
C>SET LOC_RPT=<vía de fichero de informe>
En la secci.n de configuración del programa de aplicación, asigne el
contenido de las variables de entorno a variables. Posteriormente,
cuando acceda a un fichero, haga preceder la referencia con la
variable de vía, del modo siguiente:
cDdfDirectorio := GETENV("LOC_DBF")
USE (cDdfDirectorio + "Facturas")
Ficheros: La biblioteca asociada es CLIPPER.LIB.
HARDCR()
Sustituye los retornos de carro autom.ticos de una cadena de carácteres por
retornos de carro forzados.
------------------------------------------------------------------------------
Sintaxis
HARDCR(<cCadena>) --> cCadenaConvertida
Argumentos
<cCadena> es la cadena de carácteres o campo memo que se va a
convertir.
Devuelve
HARDCR() devuelve una cadena de carácteres de hasta 65.535 (64K)
carácteres de longitud.
Descripción
HARDCR() es una función memo que sustituye todos los retornos de carro
autom.ticos (CHR(141)) por retornos de carro forzados (CHR(13)). Se
utiliza para mostrar con mandatos de consola cadenas de carácteres
largas y campos memo que contienen retornos de carro autom.tico. En
CA-Clipper los mandatos de consola (incluyendo REPORT y LABEL FORM) no
convierten autom.ticamente los retornos de carro autom.ticos en retornos
permanentes, por lo que es necesario hacer explícitamente la conversión.
MEMOEDIT() a.ade retornos de carro autom.ticos en los saltos de línea.
Notas
. HARDCR() en REPORT y LABEL FORM: Si se utiliza HARDCR() en
una expresión de contenido de REPORT FORM o LABEL FORM y no se
utiliza en otra parte, debe declararse EXTERNAL para asegurarse de
que est. enlazada.
Ejemplos
. Para mostrar un campo memo formateado con los saltos de línea
autom.ticos de MEMOEDIT():
USE Ventas NEW
? HARDCR(Ventas->Notas)
Ficheros: La biblioteca asociada es EXTEND.LIB.
HEADER()
Devuelve la longitud de la cabecera del fichero de base de datos actual
------------------------------------------------------------------------------
Sintaxis
HEADER() --> nBytes
Devuelve
HEADER() devuelve el número de bytes de la cabecera del fichero de base
de datos actual, en forma de número entero. Si no se est. utilizando
ningún fichero de base de datos, HEADER() devuelve cero.
Descripción
HEADER() es una función de base de datos que se utiliza con LASTREC(),
RECSIZE() y DISKSPACE() para crear procedimientos de copia de seguridad
de ficheros.
Por defecto, HEADER() act.a en el área de trabajo actualmente
seleccionada. Para que act.e en un área de trabajo no seleccionada debe
especificarse como parte de una expresión de alias (consulte el ejemplo
siguiente).
Ejemplos
. Este ejemplo determina el tama.o de la cabecera de Ventas.dbf:
USE Ventas NEW
? HEADER() // Resultado: 258
. Este ejemplo define una pseudofunción, TamaFich(), que utiliza
HEADER() con RECSIZE() y LASTREC() para calcular el tama.o en bytes
del fichero en base de datos actual:
#define TamaFich() ((RECSIZE() * LASTREC()) + ;
HEADER() + 1)
En adelante, puede utilizar TamaFich() igual que cualquier otra
función:
USE Ventas NEW
USE Cliente NEW
? TamaFich()
? Ventas->(TamaFich())
Ficheros: La biblioteca asociada es EXTEND.LIB.
I2BIN()
Convierte un valor numérico de CA-Clipper en un entero binario de 16 bits.
------------------------------------------------------------------------------
Sintaxis
I2BIN(<nEntero>) --> cEnteroBinario
Argumentos
<nEntero> es el número entero que se va a convertir. Los números
decimales se truncan.
Devuelve
I2BIN() devuelve una cadena de carácteres de 2 bytes que contiene un
entero binario de 16 bits.
Descripción
I2BIN() es una función de bajo nivel que convierte un número entero en
una cadena de carácteres formateada como un entero binario (byte menos
significativo primero). I2BIN() se utiliza con FWRITE() para convertir
un número de CA-Clipper a la forma binaria estándar. La inversa de
I2BIN() es BIN2I().
Ejemplos
. Este ejemplo abre un fichero de base de datos utilizando
funciónes de fichero de bajo nivel y escribe la fecha de la .ltima
actualizaci.n en los bytes 1-3:
#include "Fileio.ch"
//
nManejador = FOPEN("Ventas.dbf", FO_READWRITE)
//
// Convierte en un entero la fecha de la .ltima actualizaci.n
nAnno = I2BIN(90)
nMes = I2BIN(12)
nDia = I2BIN(15)
//
// Se.ala la fecha de la .ltima actualizaci.n
FSEEK(nManejador, 1, FS_SET)
//
// Escribe la fecha de la nueva actualizaci.n
// utilizando sólo el primer byte
FWRITE(nManejador, nAnno, 1)
FWRITE(nManejador, nMes, 1)
FWRITE(nManejador, nDia, 1)
FCLOSE(nManejador)
Ficheros: La biblioteca asociada es EXTEND.LIB,
el módulo fuente es SOURCE\SAMPLE\EXAMPLEA.ASM.
IF()
Retorna el resultado de una expresión en base a una condición.
------------------------------------------------------------------------------
Sintaxis
[I]IF(<lCondici.n>, <expVerdadera>, <expFalsa>) --> Valor
Argumentos
<lCondici.n> es la expresión l.gica que se va a evaluar.
<expVerdadera> es el valor de cualquier tipo de datos que se
devuelve si <lCondici.n> es verdadera (.T.).
<expFalsa> es el valor, de cualquier tipo de datos, que se devuelve
si <lCondici.n> es falsa (.F.). No es necesario que este argumento sea
del mismo tipo de datos que <expVerdadera>.
Devuelve
IF() devuelve el resultado de <expVerdadera> si <lCondici.n> resulta
verdadera (.T.) y de <expFalsa> si resulta falsa (.F.). El valor
devuelto es del tipo de datos de la expresión víaacute;lida.
Descripción
IF() es una función de conversión l.gica. Es una de las funciónes m.s
potentes y vers.tiles de CA-Clipper. Ofrece un mecanismo para evaluar
una condición dentro de una expresión. Con esta función puede convertir
una expresión l.gica en otro tipo de datos.
Ejemplos
. Este ejemplo convierte un valor de datos l.gico en un valor
numérico:
lPagado =.T.
? IF(lPagado, 1, 0) // Resultado: 1
. En este ejemplo se da formato a un campo l.gico dependiendo de
si ha vencido o no el per.odo de pago del cliente.
@ ROW() + 1, 25 SAY IF(lPagado, SPACE(10), ".A por ellos!")
. Si imprime formularios, puede imprimir un s.mbolo indicativo
en diferentes columnas dependiendo del valor de un campo l.gico:
@ ROW(), IF(EnHospital, 10, 12) SAY "X"
. Puede utilizar también la función IF() para obligar a LABEL
FORM a imprimir líneas en blanco. Introduzca la siguiente expresión
cuando cree la etiqueta con RL.EXE:
IF(EMPTY(Empresa), CHR(255), Empresa)
Ficheros: La biblioteca asociada es CLIPPER.LIB.
INDEXEXT()
Devuelve la extensión por defecto de los ficheros ííndice basada en el
controlador de base de datos actualmente enlazado
------------------------------------------------------------------------------
Sintaxis
INDEXEXT() --> cExtensi.n
Devuelve
A menos que se haya enlazado otro controlador de base de datos,
INDEXEXT() devuelve ".NTX", lo que indica que est. activo el controlador
por defecto de CA-Clipper. Si est. enlazado el controlador compatible
con dBASE III PLUS, la función devuelve "NDX".
Descripción
INDEXEXT() devuelve la extensión por defecto del fichero ííndice, en
función del controlador de base de datos actualmente enlazado.
Ejemplos
. En este ejemplo, INDEXEXT() crea una prueba de existencia del
fichero ííndice Cliente independiente del controlador de base de datos
enlazado al programa actual:
USE Cliente NEW
//
IF.NOT. FILE("Cliente" + INDEXEXT())
INDEX ON NombreCliente TO Cliente
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
INDEXKEY()
Devuelve la expresión clave del índice especificado
------------------------------------------------------------------------------
Sintaxis
INDEXKEY(<nOrden>) --> cExpClave
Argumentos
<nOrden> es la posición original del índice en la lista de ficheros
índice abierta por el último mandato USE...INDEX o SET INDEX TO en el
área de trabajo actual. Un valor cero expecifica el índice activo,
independientemente de su posición real en la lista.
Devuelve
INDEXKEY() devuelve la expresión clave del índice especificado como una
cadena de carácteres. Si no hay índice correspondiente o no se ha
abierto ningún fichero de base de datos, INDEXKEY() devuelve una cadena
nula.("").
Descripción
INDEXKEY() es una función de base de datos que determina la expresión
clave de un ííndice especificado en el área de trabajo actual y la
devuelve como una cadena de carácteres. Para evaluar la expresión clave,
especifique INDEXKEY() como una macroexpresión similar a la siguiente:
&(INDEXKEY(<nOrden>)).
INDEXKEY() tiene cierto número de aplicaciónes, pero dos en concreto son
importantes. Con esta función puede totalizar la base de datos a trav.s
de la expresión clave en el código fuente. El otro caso tiene lugar en
la función de usuario de DBEDIT(). Aqu. puede ser necesario decidir si
actualizar o no la pantalla después de que el usuario haya editado un
registro. Normalmente, sólo es necesario actualizar la pantalla si ha
cambiado la expresión clave del índice activo en el registro actual.
Ambos ejemplos se describen m.s abajo.
Por defecto, INDEXKEY() act.a en el área de trabajo actualmente
seleccionada. Puede hacer que act.e en un área de trabajo no
seleccionada especific.ndola con una expresión de alias (consulte el
ejemplo siguiente).
Ejemplos
. Este ejemplo accede a la expresión clave de los ííndices
abiertos en el área de trabajo actual:
#define ORD_NATURAL 0
#define ORD_NOMBRE 1
#define ORD_SERIE 2
//
USE Cliente INDEX Nombre, Serie NEW
SET ORDER TO ORD_SERIE
? INDEXKEY(ORD_NOMBRE) // Resultado: exp índice de nombres
? INDEXKEY(ORD_SERIE) // Resultado: exp índice en serie
? INDEXKEY(ORD_NATURAL) // Resultado: exp índice en serie
. Este ejemplo accede a la expresión clave del índice activo en
un área de trabajo no seleccionada:
USE Cliente INDEX Nombre, Serie NEW
USE Ventas INDEX Vendedor NEW
? INDEXKEY(0), Cliente->(INDEXKEY(0))
. Este ejemplo utiliza INDEXKEY() como parte de una expresión
TOTAL ON de clave. Observe que INDEXKEY() se especifica con una
macroexpresión para obligar a evaluar la expresión:
USE Ventas INDEX Vendedor NEW
TOTAL ON &(INDEXKEY(0)) FIELDS CantidadVentas;
TO ResumenVentas
. Este ejemplo utiliza INDEXKEY() para determinar si debe
actualizarse la pantalla de DBEDIT() después de que el usuario haya
editado el valor de campo actual. Normalmente, es necesario
actualizar la pantalla DBEDIT() si el usuario cambia un campo que es
parte de la clave del índice activo. EditarFichero() es una función
definida por el usuario llamada desde una función DBEDIT() de usuario
para editar el campo actual si el usuario ha pulsado una tecla de
edici.n.
#include "Dbedit.ch"
#define ORD_NATURAL 0
FUNCTION EditarFichero()
LOCAL Valíndice
// Guarda el valor y expresión clave actual
Valíndice = &(INDEXKEY(ORD_NATURAL))
.
. <código para obtener (GET) el valor de campo actual>
.
// Actualizar la pantalla si ha cambiado el
//valor clave
IF Valíndice != &(INDEXKEY(ORD_NATURAL))
nPeticion = DE_REFRESH
ELSE
nPeticion = DE_CONT
ENDIF
RETURN nPeticion
Ficheros: La biblioteca asociada es CLIPPER.LIB.
INDEXORD()
Devuelve la posición de orden del índice activo.
------------------------------------------------------------------------------
Sintaxis
INDEXORD() --> nOrden
Devuelve
INDEXORD() devuelve un valor numérico entero. El valor devuelto es igual
a la posición del índice activo en la lista de ficheros ííndice abiertos
del área de trabajo actual. Un valor cero indica que no hay índice
activo y que se est. accediendo a los registros en su orden natural. Si
no hay abierto ningún fichero de base de datos, INDEXORD() devuelve
también el valor cero.
Descripción
INDEXORD() es una función de base de datos que determina la posición del
índice activo en la lista de ficheros ííndice abiertos por el último
mandato USE...INDEX o SET INDEX TO en el área de trabajo actual. Suele
ser conveniente guardar el último índice de control para poder
restablecerlo m.s tarde.
Por defecto, INDEXORD() act.a en el área de trabajo actualmente abierta.
Para que opere en un área de trabajo no seleccionada, debe especificarla
como parte de una expresión de alias (consulte el ejemplo siguiente).
Ejemplos
. Este ejemplo utiliza INDEXORD() para guardar el orden actual.
Despu.s de cambiar a un nuevo orden, utiliza el valor guardado para
restablecer el orden original:
USE Cliente INDEX Nombre, Serie NEW
nOrden := INDEXORD() // Resultado: 1
SET ORDER TO 2
? INDEXORD() // Resultado: 2
SET ORDER TO nOrden
? INDEXORD() // Resultado: 1
. Este ejemplo utiliza una expresión de alias para determinar el
número de orden del índice activo en un área de trabajo no
seleccionada:
USE Ventas INDEX Vendedor, NumCliente NEW
USE Cliente INDEX Nombre, Serie NEW
? Ventas->(INDEXORD()) // Resultado: 1
Ficheros: La biblioteca asociada es CLIPPER.LIB.
INKEY()
Lee un carácter de la memoria intermedia del teclado
------------------------------------------------------------------------------
Sintaxis
INKEY([<nSegundos>]) --> nC.digoInkey
Argumentos
<nSegundos> Especifica el número de segundos que INKEY() espera a
que se pulse una tecla. Puede especificar valores en incrementos de
hasta una d.cima de segundo. Si se especifica cero, el programa se
detiene hasta que se pulse una tecla. Si se omite <nSegundos> INKEY() no
espera a que se pulse una tecla.
Devuelve
INKEY() devuelve un valor numérico comprendido entre -39 y 386, que
identifica la tecla le.da de la memoria intermedia del teclado. Si la
memoria intermedia est. vac.a INKEY() devuelve cero. INKEY() devuelve
valores para todas las combinaciónes de carácteres ASCII, funciónes,
Alt-función, Ctrl-función, Alt-letra y Ctrl-letra.
Descripción
INKEY() es una función de teclado que lee la tecla siguiente contenida
en la memoria intermedia del teclado y devuelve un valor que representa
esa tecla. Este valor se guarda también internamente y puede recuperarse
por medio de LASTKEY(). Si se especifica el argumento <nSegundos> y no
hay teclas pendientes en la memoria intermedia, la ejecución del
programa se detiene hasta que aparezca una tecla en la memoria del
teclado o haya transcurrido <nSegundos>. El tiempo que espera la función
INKEY() se basa en el reloj del sistema operativo y no en la velocidad
del microprocesador. Si <nSegundos> es cero, la ejecución del programa
se detiene hasta que haya alguna tecla en la memoria intermedia.
Recuerde que INKEY() no es un estado de espera, por lo que las teclas
establecidas mediante SET KEY no están activas.
INKEY() es similar a la función NEXTKEY(). A diferencia de INKEY(),
NEXTKEY() lee sin extraer la tecla de la memoria intermedia del teclado.
Esto es útil para comprobar la existencia de una tecla sin procesarla.
INKEY() es la primitiva principal del sistema de CA-Clipper para extraer
teclas de la memoria intermedia del teclado. Se utiliza para sondear el
teclado o hacer una pausa en la ejecución del programa hasta que se
pulse una tecla. Como ejemplo, puede utilizar INKEY() para terminar
mandatos con un ámbito de lectura como LIST, LABEL FORM y REPORT FORM
incluyendo una condición WHILE. Consulte el ejemplo siguiente.
Si desea una lista completa de los códigos INKEY() y constantes de
Inkey.ch, consulte la gu.a de Mensajes de Error y Apííndices.
Ejemplos
. Este ejemplo recoge una tecla del teclado y muestra el valor
de su carácter seguido por el valor de INKEY():
#include "Inkey.ch"
//
LOCAL nCodigoInkey := 0
DO WHILE LASTKEY() != K_ESC
? "Pulse una tecla: "
nCodigoInkey := INKEY(0)
?? "Car.cter:", CHR(nCodigoInkey),;
"C.digo INKEY():", LTRIM(STR(nCodigoInkey))
ENDDO
RETURN
. Este ejemplo utiliza INKEY() para sondear la pulsaci.n de una
tecla de interrupci.n durante un REPORT FORM. Si el usuario pulsa Esc
durante el proceso de impresión, el proceso REPORT FORM termina:
#include "Inkey.ch"
//
USE Ventas INDEX Vendedor NEW
REPORT FORM MONTHLY FOR MONTH(FechaVentas) = ;
MONTH(DATE());
WHILE INKEY() != K_ESC
Ficheros: La biblioteca asociada es CLIPPER.LIB,
el fichero de cabecera asociado es Inkey.ch.
INT()
Convierte un valor numérico en un número entero
------------------------------------------------------------------------------
Sintaxis
INT(<nExp>) --> nEntero
Argumentos
<nExp> es la expresión numérica que se va a convertir en entero.
Devuelve
INT() devuelve un valor numérico entero.
Descripción
INT() es una función numérica que convierte un valor numérico en un
entero truncando (sin redondear) todos los dígitos situados a la derecha
de la coma decimal. INT() es útil en operación.s en las que no es
necesaria la parte decimal de un número.
Ejemplos
. Estos ejemplos muestran los resultados de varias llamadas a la
función INT():
? INT(100.00) // Resultado: 100
? INT(.5) // Resultado: 0
? INT(-100.75) // Resultado: -100
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ISALPHA()
Determina si el carácter inicial de una cadena de carácteres es alfabético
------------------------------------------------------------------------------
Sintaxis
ISALPHA(<cCadena>) --> lBooleano
Argumentos
<cCadena> es la cadena de carácteres que se va a examinar.
Devuelve
ISALPHA() devuelve verdadero (.T.) si el primer carácter de <cCadena> es
alfabético; en caso contrario devuelve falso (.F.).
Descripción
ISALPHA() es una función de carácteres que determina si la cadena
especificada comienza con un carácter alfabético. Se consideran
carácteres alfabéticos todas las letras mayúsculas o minúsculas de la A
a la Z. ISALPHA() devuelve falso (.F.) si la cadena comienza con un
dígito o con cualquier otro carácter.
Ejemplos
. Estos ejemplos muestran varios resultados de ISALPHA():
? ISALPHA("AbcDe") // Resultado:.T.
? ISALPHA("aBcDE") // Resultado:.T.
? ISALPHA("1BCde") // Resultado:.F.
? ISALPHA(".FRED") // Resultado:.F.
Ficheros: La biblioteca asociada es EXTEND.LIB.
ISCOLOR()
Determina si el ordenador actual soporta color
------------------------------------------------------------------------------
Sintaxis
ISCOLOR() | ISCOLOUR() --> lBooleano
Devuelve
ISCOLOR() devuelve verdadero (.T.) si hay una tarjeta gr.fica de color
instalada; en caso contrario devuelve falso (.F.).
Descripción
ISCOLOR() es una función de pantalla que se puede utilizar para decidir
el tipo de atributos de pantalla (color o monocromo). Recuerde que
algunos adaptadores monocromos con capacidades gr.ficas devuelven
verdadero (.T.).
Ejemplos
. Este ejemplo instala variables de atributo de color durante la
ejecución:
IF ISCOLOR()
cBox = "BG+/B, W/N"
cSays = "BG/B, W/N"
cGets = "W/N, N/W"
ELSE
cBox = "W+"
cSays = "W/N, N+/W"
cGets = "W/N, N/W"
ENDIF
.
. <sentencias>
.
SETCOLOR(cSays)
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ISDIGIT()
Determina si el carácter inicial de una cadena de carácteres es un dígito
------------------------------------------------------------------------------
Sintaxis
ISDIGIT(<cCadena>) --> lBooleano
Argumentos
<cCadena> es la cadena de carácteres que se va a examinar.
Devuelve
ISDIGIT() devuelve verdadero (.T.) si el primer carácter de una cadena
es un dígito comprendido entre cero y nueve; en caso contrario devuelve
falso (.F.).
Descripción
ISDIGIT() es una función de carácteres que determina si el primer
carácter de una cadena es un dígito del cero al nueve. Si el primer
carácter de <cCadena> es de cualquier otro tipo, ISDIGIT() devuelve
falso (.F.).
ISDIGIT() es útil para determinar si la cadena actual es un número antes
de convertirla en un valor numérico por medio de la función VAL().
Ejemplos
. Estos ejemplos muestra diferentes resultados de ISDIGIT():
? ISDIGIT("AbcDe") // Resultado:.F.
? ISDIGIT("1abcd") // Resultado:.T.
? ISDIGIT(".12345") // Resultado:.F.
Ficheros: La biblioteca asociada es EXTEND.LIB.
ISLOWER()
Determina si el carácter inicial de una cadena de carácteres es una letra
minúscula
------------------------------------------------------------------------------
Sintaxis
ISLOWER(<cCadena>) --> lBooleano
Argumentos
<cCadena> es la cadena de carácteres que se va a examinar.
Devuelve
ISLOWER() devuelve verdadero (.T.) si el primer carácter de una cadena
es una letra minúscula; es caso contrario devuelve falso (.F.).
Descripción
ISLOWER() es una función de carácteres que determina si el primer
carácter de una cadena de carácteres es una letra minúscula. Es la
función inversa de ISUPPER(), que determina si el primer carácter es una
letra mayúscula.
ISLOWER() y ISUPPER() están relacionadas con las funciónes LOWER() y
UPPER(), que convierten las letras mayúsculas en minúsculas y viceversa.
Ejemplos
. Estos ejemplos muestran diferentes resultados de ISLOWER():
? ISLOWER("aBcDe") // Resultado:.T.
? ISLOWER("AbcDe") // Resultado:.F.
? ISLOWER("1abcd") // Resultado:.F.
? ISLOWER("abcd") // Resultado:.T.
Ficheros: La biblioteca asociada es CLIPPER.LIB.
ISPRINTER()
Determina si el puerto LPT1 est. preparado.
------------------------------------------------------------------------------
Sintaxis
ISPRINTER() --> lPreparado
Devuelve
ISPRINTER() devuelve verdadero (.T.) si el puerto LPT1 est. preparado;
en caso contrario devuelve falso (.F.).
Descripción
ISPRINTER() es una función de impresora que determina si el puerto
paralelo LPT1 est. en línea y preparado para imprimir. ISPRINTER() es
una función dependiente del hardware, por lo que sólo act.a en sistemas
cuyo BIOS es compatible con IBM.
Puede comprobar ISPRINTER() para asegurarse de que la impresora est.
lista antes de empezar a imprimir. No obstante, si se produce un error
durante la impresi.n, se genera un error de ejecución.
Ejemplos
. Este ejemplo comprueba si est. preparado el puerto paralelo,
realizando hasta 25 reintentos. Si el puerto paralelo est. preparado,
se inicia la operación.de impresión:
LOCAL nCuenta := 0, nVeces := 25, lPrep
//
DO WHILE nCuenta++ <= nVeces.AND. !(lPrep := ;
ISPRINTER())
ENDDO
//
IF lPrep
REPORT FORM Ventas TO PRINTER
ELSE
? "La impresora no est. preparada..."
BREAK
ENDIF
Ficheros: La biblioteca asociada es EXTEND.LIB,
el módulo fuente es SOURCE\SAMPLE\EXAMPLEA.ASM.
ISUPPER()
Determina si el carácter inicial de una cadena de carácteres es una letra
mayúscula
------------------------------------------------------------------------------
Sintaxis
ISUPPER(<cCadena>) --> lBooleano
Argumentos
<cCadena> es la cadena de carácteres que se examina.
Devuelve
ISUPPER() devuelve verdadero (.T.) si el primer carácter es una letra
mayúscula; en caso contrario devuelve falso (.F.).
Descripción
ISUPPER() es una función de carácteres que determina si el primer
carácter de una cadena es una letra mayúscula. Es la función inversa de
ISLOWER(). ISUPPER() e ISLOWER() están relacionadas con las funciónes
UPPER() y LOWER() que convierten letras minúsculas en mayúsculas y
viceversa.
Ejemplos
. Este ejemplo ilustra ISUPPER() aplicada a diferentes valores:
? ISUPPER("AbCdE") // Resultado:.T.
? ISUPPER("aBCdE") // Resultado:.F.
? ISUPPER("$abcd") // Resultado:.F.
? ISUPPER("8ABCD") // Resultado:.F.
Ficheros: La biblioteca asociada es CLIPPER.LIB.
L2BIN()
Convierte un valor numérico de CA-Clipper en un valor entero binario de 32
bits
------------------------------------------------------------------------------
Sintaxis
L2BIN(<nExp>) --> cEnteroBinario
Argumentos
<nExp>es el valor numérico que se va a convertir. Los números
decimales se truncan.
Devuelve
L2BIN() devuelve una cadena de carácteres de 4 bytes formateada como un
entero binario de 32 bits.
Descripción
L2BIN() es una función de bajo nivel que se utiliza con FWRITE() para
escribir valores numéricos de CA-Clipper en un fichero binario. Esta
función es similar a I2BIN(), que formatea un valor numérico de
CA-Clipper en un valor binario de 16 bits.
L2BIN() es la función inversa de BIN2L().
Ejemplos
. Este ejemplo crea un nuevo fichero binario y escribe una serie
de números en los ficheros utilizando L2BIN() para convertir el valor
numérico en un número binario de 32 bits:
#include "Fileio.ch"
//
LOCAL nNúmero, nManejador
nManejador := FCREATE("Fichero", FC_NORMAL)
FOR nNúmero := 1 TO 100
FWRITE(nManejador, L2BIN(nNúmero) + CHR(0))
NEXT
FCLOSE(nManejador)
Ficheros: La biblioteca asociada es EXTEND.LIB,
el módulo fuente es SOURCE\SAMPLE\EXAMPLEA.ASM.
LASTKEY()
Devuelve el valor INKEY() de la .ltima tecla extra.da de la memoria
intermedia del teclado
------------------------------------------------------------------------------
Sintaxis
LASTKEY() --> nC.digoInkey
Devuelve
LASTKEY() devuelve un número entre -39 y 386, que identifica el valor
INKEY() de la .ltima tecla extra.da de la memoria intermedia del
teclado.
Descripción
LASTKEY() es una función de teclado que informa del valor INKEY() de la
.ltima tecla recogida de la memoria intermedia del teclado por la
función INKEY() o por un estado de espera como ACCEPT, INPUT, READ,
WAIT, ACHOICE(), DBEDIT() o MEMOEDIT(). LASTKEY() conserva su valor
actual hasta que se recoge otra tecla de la memoria intermedia del
teclado.
LASTKEY() permite:
. Determinar la tecla que termina un READ.
. Determinar la tecla que provoca la salida del objeto GET
actual en una función definida por el usuario, invocada por una
cláusula VALID.
. Identificar una tecla de excepci.n en la función de usuario de
ACHOICE(), DBEDIT() o MEMOEDIT().
LASTKEY() se utiliza también con la función UPDATED() para determinar si
se ha modificado la memoria intermedia de alg.n objeto Get durante un
READ.
LASTKEY() se relaciona con NEXTKEY() y READKEY(). NEXTKEY() lee la tecla
actual pendiente en la memoria intermedia del teclado sin eliminarla de
la misma. Utilice NEXTKEY() en vez de INKEY() cuando desee consultar una
tecla.
Si desea una lista completa de los códigos de INKEY() y constantes de
INKEY.CH para cada tecla, consulte la gu.a Mensajes de Error y
Apííndices.
Ejemplos
. Este ejemplo muestra una aplicación t.pica de LASTKEY() para
comprobar la tecla con la que se sale de un READ. Si el usuario sale
con una tecla distinta de Esc y se ha modificado el objeto Get, se
actualiza el fichero especificado de base de datos.
#include "Inkey.ch"
//
USE Cliente NEW
MEMVAR->balance = Cliente->Balance
@ 10, 10 SAY "Balance Actual" GET MEMVAR->balance
READ
//
IF (LASTKEY() != K_ESC).AND. UPDATED()
REPLACE Cliente->Balance WITH MEMVAR->balance
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB,
el fichero de cabecera asociado es Inkey.ch.
LASTREC()
Determina el número de registros del fichero actual (.dbf)
------------------------------------------------------------------------------
Sintaxis
LASTREC() | RECCOUNT()* --> nRegistros
Devuelve
LASTREC() devuelve el número de registros f.sicos en el fichero actual
de base de datos, en forma de valor numérico entero. Los mandatos de
filtrado como SET FILTER o SET DELETED no tienen efecto sobre el valor
devuelto. LASTREC() devuelve cero si no hay ningún fichero de base de
datos utilizado en el área de trabajo actual.
Descripción
LASTREC() es una función de base de datos que determina el número de
registros f.sicos existentes en el fichero actual de base de datos.
LASTREC() es id.ntica a RECCOUNT(), que se incluye por razones de
compatibilidad.
Por defecto, LASTREC() act.a en el área de trabajo actualmente
seleccionada. Para que opere sobre un área de trabajo no seleccionada,
debe especificarse como parte de una expresión de alias (consulte el
ejemplo siguiente).
Ejemplos
. Este ejemplo muestra la relaci.n entre LASTREC(), RECCOUNT() y
COUNT:
USE Ventas NEW
? LASTREC(), RECCOUNT() // Resultado: 84 84
//
SET FILTER TO Vendedor = "1001"
COUNT TO nRegistros
? nRegistros, LASTREC() // Resultado: 14 84
. Este ejemplo utiliza una expresión de alias para acceder al
número de registros de un fichero de base de datos abierto en un .rea
de trabajo no seleccionada.
USE Ventas NEW
USE Cliente NEW
? LASTREC(), Ventas->(LASTREC())
Ficheros: La biblioteca asociada es CLIPPER.LIB.
LEFT()
Extrae una subcadena comenzando en el primer carácter de una cadena
------------------------------------------------------------------------------
Sintaxis
LEFT(<cCadena>, <nPosiciones>) --> cSubCadena
Argumentos
<cCadena> es la cadena de la que se extraen los carácteres. El
tama.o máximo de <cCadena> es de 65.553 (64K) bytes.
<nPosiciones> es el número de carácteres que se van a extraer.
Devuelve
LEFT() devuelve los <nPosiciones> carácteres m.s a la izquierda de
<cCadena>, como una cadena de carácteres. Si <nPosiciones> es cero o
negativo, LEFT() devuelve una cadena nula (""). Si <nPosiciones> es
mayor que la longitud de la cadena de carácteres, LEFT() devuelve toda
la cadena.
Descripción
LEFT() es una función de carácteres que devuelve una subcadena de la
cadena de carácteres especificada. Es id.ntica a
SUBSTR(<cCadena>,1,<nPosiciones>). LEFT() es similar a RIGHT(), que
devuelve una subcadena comenzando por el último carácter de la misma.
LEFT(), RIGHT() y SUBSTR() se utilizan con frecuencia con las funciónes
AT() y RAT() para localizar la primera y/o .ltima posición de una
subcadena antes de extraerla.
Ejemplos
. Este mandato extrae los tres primeros carácteres empezando por
la izquierda de la cadena:
? LEFT("ABCDEF", 3) // Resultado: ABC
. Este ejemplo extrae una subcadena comenzando por el principio
de otra cadena, hasta la primera coma:
LOCAL cNombre := "Jorge, Luis"
? LEFT(cNombre, AT(",", cNombre) - 1) // Resultado:
// Jorge
Ficheros: La biblioteca asociada es CLIPPER.LIB.
LEN()
Devuelve la longitud de una cadena de carácteres o el número de elementos de
una matriz
------------------------------------------------------------------------------
Sintaxis
LEN(<cCadena> | <aDestáno>) --> nPosiciones
Argumentos
<cCadena> es la cadena de carácteres que se va a contar.
<aDestáno> es la matriz que se va a contar.
Devuelve
LEN() devuelve la longitud de una cadena de carácteres o el número de
elementos en una matriz, como un número entero. Si la cadena de
carácteres es una cadena nula ("") o la matriz est. vac.a, LEN()
devuelve cero.
Descripción
LEN() es una función de carácteres y matrices que devuelve la longitud
de una cadena de carácteres o el número de elementos en una matriz. Con
una cadena de carácteres, cada byte se cuenta como uno, incluyendo un
byte nulo (CHR (0)). Por contra, una cadena nula ("") se cuenta como
cero.
Para una matriz, LEN() devuelve el número de elementos. Si la matriz es
multidimensiónal, las submatrices se cuentan como un elemento. Esto
quiere decir que el valor devuelto por LEN() para una matriz anidada o
multidimensiónal es simplemente la longitud de la primera dimensión.
Para determinar el número de elementos en otras dimensiónes, utilice
LEN() en las submatrices como se muestra en el ejemplo siguiente.
Recuerde que las matrices anidadas en CA-Clipper no necesitan tener
dimensiónes uniformes.
Ejemplos
. Estos ejemplos muestran la utilización de LEN() con varios
argumentos:
? LEN("cadena de carácteres") // Resultado: 20
? LEN("") // Resultado: 0
? LEN(CHR(0)) // Resultado: 1
//
LOCAL aPrueba[10]
? LEN(aPrueba) // Resultado: 10
. Este ejemplo crea una matriz bidimensiónal de forma literal y
devuelve el número de elementos en la submatriz contenida en el
primer elemento de la matriz original:
LOCAL aMatriz := { {1, 2}, {1, 2}, {1, 2} }
? LEN(aMatriz) // Resultado: 3
? LEN(aMatriz[1]) // Resultado: 2
. Este ejemplo se desplaza por una matriz multidimensiónal
utilizando LEN():
LOCAL aMatriz := { {1, 2}, {1, 2}, {1, 2} }
LOCAL nFilas, nCols, nPosFilas, nPosCols
//
nPosFilas = LEN(aMatriz)
FOR nFilas = 1 TO nPosFilas
nPosCols = LEN(aMatriz[nFilas])
FOR nCols = 1 TO nPosCols
? nFilas, nCols, aMatriz[nFilas][nCols]
NEXT
NEXT
. En este ejemplo, una función devuelve una matriz de valores
numéricos que describe las dimensiónes de una matriz multidimensiónal
anidada. La función supone que la matriz tiene dimensiónes uniformes:
FUNCTION Dimensiones( aMatriz )
LOCAL aDims := {}
DO WHILE ( VALTYPE(aMatriz) == "A" )
AADD( aDims, LEN(aMatriz) )
aMatriz := aMatriz[1]
ENDDO
RETURN (aDims)
Ficheros: La biblioteca asociada es CLIPPER.LIB.
LOG()
Calcula el logaritmo natural de un valor numérico
------------------------------------------------------------------------------
Sintaxis
LOG(<nExp>) --> nLogNatural
Argumentos
<nExp> es el valor numérico mayor que cero que desea convertir en su
logaritmo natural.
Devuelve
LOG() devuelve el logaritmo natural como un valor numérico. Si <nExp> es
menor o igual a cero, LOG() devuelve un error de desbordamiento numérico
(mostrado como una fila de asteriscos).
Descripción
LOG() es una función numérica que calcula el logaritmo natural de un
número. Es la inversa de EXP(). Losólogaritmos naturales tienen como
base el número e, que es igual a 2.7183 aproximadamente. La función
LOG() devuelve x en la siguiente ecuaci.n:
e**x = y
donde y es la expresión numérica utilizada como argumento de LOG() (es
decir, LOG(y) = x). Debido al redondeo matem.tico, los valores devueltos
por LOG() y EXP() pueden no corresponderse exactamente (es decir,
EXP(LOG(x)) puede no ser siempre igual a x).
Ejemplos
. Estos ejemplos muestran los resultados de diversos usos de
LOG():
? LOG(10) // Resultado: 2.30
? LOG(10 * 2) // Resultado: 3.00
? EXP(LOG(1)) // Resultado: 1.00
? LOG(2.71) // Resultado: 1.00
. Este ejemplo es una función definida por el usuario que
devuelve el logaritmo en base 10:
FUNCTION Log10( nNúmero )
IF nNúmero > 0
RETURN LOG(nNúmero)/LOG(10)
ELSE
RETURN NIL
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
LOWER()
Convierte en minúsculasólos carácteres en mayúsculas
------------------------------------------------------------------------------
Sintaxis
LOWER(<cCadena>) --> cCadenaMin.sc
Argumentos
<cCadena> es la cadena de carácteres que desea convertir en
minúsculas.
Devuelve
LOWER() devuelve una copia de <cCadena> con todos los carácteres
alfabéticos en letras minúsculas. Los restántes carácteres permanecen
inalterados en la cadena original.
Descripción
LOWER() es una función de carácteres que convierte cadenas en mayúsculas
y mixtas en cadenas en minúsculas. Está relacionada con UPPER() que
convierte cadenas en minúsculas y mixtas en cadenas en mayúsculas.
LOWER() está relacionada con las funciónes ISLOWER() e ISUPPER() que
determinan si una cadena comienza con un carácter en minúscula o
mayúscula.
LOWER() se utiliza normalmente para formatear una cadena de carácteres
para su visualización en pantalla. Puede utilizarse también para
normalizar cadenas en comparaciones que no diferencian mayúsculas y
minúsculas o para la indexación con INDEX.
Ejemplos
. Estos ejemplos muestran los resultados de diferentes usos de
LOWER():
? LOWER("CADENA") // Resultado: cadena
? LOWER("1234 CARACTERES = ") // Resultado: 1234 carácteres =
Ficheros: La biblioteca asociada es CLIPPER.LIB.
LTRIM()
Elimina los espacios en blanco iniciales de una cadena de carácteres
------------------------------------------------------------------------------
Sintaxis
LTRIM(<cCadena>) --> cCadenaRecortada
Argumentos
<cCadena> es la cadena de carácteres de la que desea eliminar los
espacios iniciales en blanco.
Devuelve
LTRIM() devuelve una copia de <cCadena> sin los espacios iniciales en
blanco. Si <cCadena> es una cadena nula ("") o est. formada por
espacios, LTRIM() devuelve una cadena nula ("").
Descripción
LTRIM() es una función de carácteres que formatea cadenas de carácteres
con espacios iniciales en blanco. Estas pueden ser, por ejemplo, números
que se convierten en una cadena de carácteres útilizando STR().
LTRIM() está relacionada con RTRIM(), que elimina los espacios en blanco
finales, y con ALLTRIM(), que elimina los espacios en blanco tanto
iniciales como finales. Las funciónes inversas de ALLTRIM(), LTRIM() y
RTRIM() son PADC(), PADR() y PADL() que centran, justifican a la derecha
o a la izquierda, respectivamente, la cadena de carácteres a.adiendo
carácteres de relleno.
Ejemplos
. Estos ejemplos muestran los resultados de diferentes usos de
la función LTRIM():
nNúmero = 18
? STR(nNúmero) // Resultado: 18
? LEN(STR(nNúmero)) // Resultado: 10
? LTRIM(STR(nNúmero)) // Resultado: 18
? LEN(LTRIM(STR(nNúmero))) // Resultado: 2
Ficheros: La biblioteca asociada es CLIPPER.LIB.
LUPDATE()
Devuelve la fecha de la .ltima modificaci.n de un fichero (.dbf)
------------------------------------------------------------------------------
Sintaxis
LUPDATE() --> fModificaci.n
Devuelve
LUPDATE() devuelve la fecha del último cambio realizado en el fichero de
base de datos abierto en al área de trabajo actual. Si no se est.
utilizando ningún fichero de base de datos, LUPDATE() devuelve una fecha
en blanco.
Descripción
LUPDATE() es una función de base de datos que determina la fecha en la
que modific. y cerr. mediante CLOSE por .ltima vez el fichero de base de
datos del área de trabajo actual. Por defecto, LUPDATE() act.a en el
área de trabajo actualmente seleccionada. Para que opere en un .rea de
trabajo no seleccionada, debe especificarse en una expresión de alias,
como se muestra en un ejemplo posterior.
Ejemplos
. Este ejemplo muestra que la fecha de modificaci.n de un
fichero de base de datos no cambia hasta que se cierra el fichero:
? DATE() // Resultado: 09/01/90
USE Ventas NEW
? LUPDATE() // Resultado: 08/31/90
//
APPEND BLANK
? LUPDATE() // Resultado: 08/31/90
CLOSE DATABASES
//
USE Ventas NEW
? LUPDATE() // Resultado: 09/01/90
. Este ejemplo utiliza una expresión de alias para acceder a un
fichero de base de datos abierto en un área de trabajo no
seleccionada:
USE Ventas NEW
USE Cliente NEW
? LUPDATE(), Ventas->(LUPDATE())
Ficheros: La biblioteca asociada es EXTEND.LIB.
