TIME()
Devuelve la hora del sistema
------------------------------------------------------------------------------
Sintaxis
TIME() --> cCadenaHora
Devuelve
TIME() devuelve la hora del sistema como una cadena de carácteres en el
formato hh:mm:ss. hh es la hora en formato de 24 horas, mm son los
minutos y ss son los segundos
Descripción
TIME() es una función horaria que muestra la hora del sistema en la
pantalla o la imprime en un informe. TIME() está relacionada con
SECONDS(), que devuelve un valor entero que representa el número de
segundos desde la media noche. Para cálculos horarios, suele utilizarse
SECONDS() en vez de TIME()
Ejemplos
. Estos ejemplos muestran el resultado de utilizar TIME() con
SUBSTR() para extraer los dígitos de hora, minutos y segundos:
? TIME() // Resultado: 10:37:17
? SUBSTR(TIME(), 1, 2) // Resultado: 10
? SUBSTR(TIME(), 4, 2) // Resultado: 37
? SUBSTR(TIME(), 7, 2) // Resultado: 17
Ficheros: La biblioteca asociada es CLIPPER.LIB.
TONE()
Hace sonar un tono en el altavoz, con la frecuencia y duraci.n especificadas
------------------------------------------------------------------------------
Sintaxis
TONE(<nFrecuencia>, <nDuraci.n>) --> NIL
Argumentos
<nFrecuencia> es un valor numérico que indica la frecuencia del tono
que va a sonar.
<nDuraci.n> es un número positivo que indica la duraci.n del tono
medida en incrementos de 1/18 de segundo. Por ejemplo, una <nDuraci.n>
de 18 representa un segundo.
En ambos argumentos, los valores decimales se truncan, sin redondear,
para dar la parte entera.
Devuelve
TONE() siempre devuelve NIL.
Descripción
TONE() es una función de sonido que sirve para indicar al usuario los
diferentes estados de un programa. Pueden ser estados de error,
condiciónes l.mite o el final de un proceso muy lento. Por ejemplo, un
estado de error podr.a generaráun cierto tono antes de alertar al
usuario con un mensaje o un panel de diálogo interactivo. Una condición
l.mite podr.a indicar que el usuario est. intentando desplazar el cursor
m.s all. de la posición superior o inferior de una columna de un objeto
TBrowse.
Un proceso por lotes podr.a indicar el momento de terminaci.n con un
sonido, para alertar al usuario en caso de que .ste se haya alejado de
la pantalla.
TONE() trabaja generando tonos con una frecuencia y duraci.n
especificadas. La duraci.n se mide en incrementos de 1/18 de segundo. La
frecuencia se mide en hertzios (ciclos por segundo). Las frecuencias por
debajo de 20 Hz son inaudibles. La tabla siguiente muestra las
frecuencias de las notas musicales estándar.
Nota: TONE() sólo opera en ordenadores personales totalmente
compatibles .
Tabla de Notas Musicales
------------------------------------------------------------------------
Nota Frecuencia Nota Frecuencia
------------------------------------------------------------------------
C 130,80 C medio 261,70
C# 138,60 C# 277,20
D 146,80 D 293,70
D# 155,60 D# 311,10
E 164,80 E 329,60
F 174,60 F 349,20
F# 185,00 F# 370,00
G 196,00 G 392,00
G# 207,70 G# 415,30
A 220,00 A 440,00
A# 233,10 A# 466,20
B 246,90 B 493,90
C 523,30
------------------------------------------------------------------------
Ejemplos
. Este ejemplo es una función que indica con un tono cuando ha
terminado un proceso por lotes:
FUNCTION BipTerminacion
TONE(300, 1)
TONE(100, 1)
TONE(300, 1)
TONE(100, 1)
RETURN NIL
. Este ejemplo es una secuencia de tonos que indican que se han
pulsado teclas no víaacute;lidas o que se han alcanzado condiciónes l.mite:
FUNCTION BipError
TONE(100, 3)
RETURN NIL
Ficheros: La biblioteca asociada es EXTEND.LIB,
el módulo fuente es SOURCE\SAMPLE\EXAMPLEA.ASM.
TRANSFORM()
Convierte cualquier valor en una cadena de carácteres formateada
------------------------------------------------------------------------------
Sintaxis
TRANSFORM(<exp>, <cPatrónFormatoSay>) --> cCadenaFormato
Argumentos
<exp> es el valor que se va a formatear. Puede ser una expresión de
cualquier tipo de datos víaacute;lido en CA-Clipper excepto matrices, bloques
de código y NIL.
<cPatrónFormatoSay> es una cadena de carácteres que describe el
formato del valor devuelto.
Devuelve
TRANSFORM() convierte <exp> en una cadena de carácteres formateada seg.n
lo definido en<cPatrónFormatoSay>.
Descripción
TRANSFORM() es una función de conversión que formatea valores de
carácteres, fechas, lógicos y numéricos de acuerdo a una cadena de
formato especificada compuesta por una combinación de funciónes de
formato y cadenas de plantilla.
TRANSFORM() formatea los datos para su salida por pantalla o por
impresora de la misma manera que la cláusula PICTURE del mandato
@...SAY.
. Cadena de función: Cadena que especifica las reglas de
formato aplicadas al valor devuelto por TRANSFORM() en su conjunto,
en vez de a las posiciónes de carácter individuales en <exp>. Est.
formada por el carácter @ seguido de uno o m.s carácteres
adicionales, cada uno de los cuales tiene un significado determinado
(consulte la tabla siguiente). Si se indica una cadena de función, el
carácter @ debe ser el primero a la izquierda de la cadena de
formato, y la cadena de función no debe contener espacios.
Puede especificarse una cadena de función sola o acompañada de una
cadena de plantilla. Si se utilizan ambas, la cadena de función debe
preceder a la cadena de plantilla y las dos deben estar separadas por
un espacio.
funciónes TRANSFORM()
---------------------------------------------------------------------
función Acción
---------------------------------------------------------------------
B Muestra números justificados a la izquierda
C Muestra RC después de los números positivos
D Muestra las fechas en el formato especificado por SET DATE
E Muestra la fecha en formato británico
R Inserta carácteres que no aparecen en la plantilla
X Muestra DB después de los números negativos
Z Muestra los ceros como espacios en blanco
( Sitúa los números negativos entre paréntesis
! Convierte en mayúsculasólos carácteres alfabéticos
---------------------------------------------------------------------
. Cadena de plantilla: La cadena de plantilla especifica las
reglas de formato carácter a carácter. La cadena de plantilla est.
formada por una serie de carácteres, algunos de los cuales tienen
significados especiales (consulte la tabla siguiente). Cada posición
de la cadena de plantilla corresponde a una posición en el valor del
argumento <exp>. Esta plantilla se utiliza con TRANSFORM(), por lo
que puede servir para insertar carácteres tales como comas, signos de
d.lar y paréntesis.
Los carácteres de la cadena de plantilla que no tengan significados
asignados se copian literalmente en el valor devuelto. Si se utiliza
la función de imagen @R, estos carácteres se insertan entre los
carácteres del valor devuelto; en caso contrario sustituyen a los
carácteres correspondientes de dicho valor. Puede especificarse una
cadena de plantilla sola o acompañada de una cadena de función. Si se
utilizan ambas, la cadena de función debe ir antes que la cadena de
plantilla y ambas cadenas deben estar separadas por un espacio.
Plantillas TRANSFORM()
---------------------------------------------------------------------
Plantilla Acción
---------------------------------------------------------------------
A,N,X,9,# Muestra dígitos de cualquier tipo de datos
L Muestra los valores lógicos como "T" o "F"
Y Muestra los valores lógicos como "S" o "N"
! Convierte en mayúscula un carácter alfabético
$ Muestra un signo de d.lar en cada espacio inicial en
blanco de un valor numérico
* Muestra un asterisco en cada espacio inicial en blanco
de un valor numérico
. Especifica una posición de punto decimal
, Especifica una posición de coma
---------------------------------------------------------------------
Ejemplos
. Este ejemplo asigna un formato monetario a un número
utilizando una plantilla:
? TRANSFORM(123456, "$999,999") // Resultado: $123,456
. Este ejemplo formatea una cadena de carácteres útilizando una
función:
? TRANSFORM("en mayúsculas", "@!") // Resultado: EN MAYUSCULAS
Ficheros: La biblioteca asociada es CLIPPER.LIB.
TYPE()
Determina el tipo de una expresión
------------------------------------------------------------------------------
Sintaxis
TYPE(<cExp>) --> cTipo
Argumentos
<cExp> es la expresión de carácteres cuyo tipo se va a determinar.
<cExp> puede ser un campo, con o sin alias, una variable pública o
privada o una expresión de cualquier tipo.
Devuelve
TYPE() devuelve uno de los siguientes carácteres:
Valores Devueltos por TYPE()
------------------------------------------------------------------------
Devuelve Significado
------------------------------------------------------------------------
A Matriz
B Bloque de C.digo
C Car.cter
D Fecha
L L.gico
M Memo
N numérico
O Objeto
U NIL, local o estática
UE Error de sintaxis
UI Error indeterminado
------------------------------------------------------------------------
Descripción
TYPE() es una función del sistema que devuelve el tipo de la expresión
especificada. Puede comprobar la validez de la expresión mientras esta
utilice funciónes CLIPPER.LIB y no haga referencia a variablesólocales o
estáticas, funciónes definidas por el usuario o funciónes predefinidas
contenidas en EXTEND.LIB.
TYPE() es similar a VALTYPE() , pero utiliza el operador de macro (&)
para determinar el tipo del argumento. Esto impide utilizar TYPE() para
determinar el tipo de variablesólocales o estáticas. VALTYPE(), por
contra, permite evaluar una expresión y determina el tipo de datos del
valor devuelto. Permite determinar el tipo de funciónes definidas por el
usuario y de variablesólocales y estáticas.
Notas
. Referencias a matrices: Las referencias a matrices
públicas y privadas devuelven "A". Las referencias a elementos de
matrices devuelven el tipo del elemento.
. IF(): Para devolver el tipo de datos de una expresión
IF(), TYPE() eval.a la condición y luego devuelve el tipo de la vía
especificada. Si la expresión IF() o la vía evaluada no son víaacute;lidos,
TYPE() devuelve "UE".
. Comprobaci.n de parámetros: TYPE() sólo puede comprobar la
validez de los parámetros recibidos con la sentencia PARAMETERS Al
verificar un parámetro declarado como parte de una declaración
FUNCTION o PROCEDURE, devuelve siempre "U.", porque los parámetros
locales no tienen un s.mbolo en la tabla de s.mbolos. Para determinar
si se ha saltado un argumento o dejado al final de la lista de
argumentos, compare el parámetro con NIL o utilice la función
VALTYPE().
. funciónes definidas por el usuario y contenidas en
EXTEND.LIB Si en una expresión se hace una referencia a una función
que no se encuentra en CLIPPER.LIB (una función definida por el
usuario o EXTEND.LIB ), TYPE() devuelve "UI." Si la función definida
por el usuario no ha sido enlazada al programa actual, TYPE()
devuelve "U.".
Ejemplos
. Estos ejemplos muestran diversos resultados de la utilización
de TYPE():
? TYPE('SUBSTR("Hola, .qu. tal?", 4, 5)') // Resultado: C
? TYPE("UDF()") // Resultado: UI
? TYPE('IF(.T., "verdadero", 12)') // Resultado: C
. Este ejemplo muestra dos m.todos de comprobar la existencia y
tipo de los parámetros declarados:
FUNCTION ParamPrueba
PARAMETERS cParam1, nParam2
IF cParam1 = NIL
? "No se ha pasado el primer parámetro"
cParam1 := "Valor por defecto"
ENDIF
//
IF TYPE(nParam2) == "U"
? "No se ha pasado el segundo parámetro"
ENDIF
.
. <sentencias>
.
RETURN NIL
Ficheros: La biblioteca asociada es CLIPPER.LIB.
UPDATED()
Determina si ha cambiado un objeto GET durante un mandato READ
------------------------------------------------------------------------------
Sintaxis
UPDATED() --> lCambio
Devuelve
UPDATED() devuelve verdadero (.T.) si se han a.adido o modificado datos
en un GET; en caso contrario devuelve falso (.F.).
Descripción
UPDATED() determina si se han introducido satisfactoriamente los
carácteres en el objeto GET desde el teclado utilizando el READ m.s
reciente. Cada vez que se ejecuta un READ, UPDATED() toma el valor falso
(.F.). Cada vez que se accede a un objeto GET desde el teclado,
UPDATED() toma el valor verdadero (.T.) después de que el usuario sale
del objeto GET. Si el usuario pulsa Esc antes de salir del primer objeto
GET editado, UPDATED() sigue siendo falso (.F.). Cuando UPDATED() toma
el valor verdadero (.T.), mantiene este valor, hasta que se ejecuta el
siguiente READ.
En un procedimiento SET KEY o VALID puede cambiar la variable del GET
actual utilizando el mandato KEYBOARD o asign.ndole un nuevo valor con
cualquiera de los operadores de asignación. Cambiar el valor de la
variable con KEYBOARD tiene el mismo efecto que si el usuario hubiera
introducido el cambio directamente desde el teclado, y UPDATED()
devuelve el valor correspondiente. No obstante, como UPDATED() refleja
sólo los cambios realizados desde el teclado, una asignación de la
variable del GET no afecta a UPDATED().
Ejemplos
. Este ejemplo asigna valores de campos de Clientes.dbf a
variables y las edita. Si el usuario cambia cualquiera de estos
valores, las variables de campo para el registro actual se actualizan
con los nuevos valores:
USE Cliente NEW
CLEAR
MEMVAR->Cliente = Cliente->Cliente
MEMVAR->Direccion = Cliente->Direccion
@ 1, 1 SAY "Nombre:" GET MEMVAR->Cliente
@ 2, 1 SAY "Direccion:" GET MEMVAR->Direccion
READ
//
IF UPDATED()
Cliente->Cliente := MEMVAR->Cliente
Cliente->Direccion := MEMVAR->Direccion
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
UPPER()
Convierte todas las minúsculas en mayúsculas
------------------------------------------------------------------------------
Sintaxis
UPPER(<cCadena>) --> cCadenaMay.s
Argumentos
<cCadena> es la cadena de carácteres que se va a convertir.
Devuelve
UPPER() devuelve una copia de <cCadena> con todos los carácteres
alfabéticos transformados en mayúsculas. Los restántes carácteres
permanecen inalterados como en la cadena original.
Descripción
UPPER() es una función de carácteres que convierte cadenas en minúsculas
y mixtas en cadenas en mayúsculas. Está relacionada con LOWER() que
convierte cadenas en mayúsculas y mixtas en cadenas en minúsculas.
UPPER() está relacionada también con las funciónes ISUPPER() y ISLOWER()
que determinan si una cadena comienza con una letra minúscula o
mayúscula.
UPPER() se utiliza normalmente para formatear cadenas de carácteres con
fines de visualización. También puede utilizarse para homogeneizar
cadenas en comparaciones que no diferencian mayúsculas y minúsculas o
para ordenación con INDEX.
Ejemplos
. Este ejemplo muestra el resultado de UPPER():
? UPPER("una cadena") // Resultado: UNA CADENA
? UPPER("123 carac = <>") // Resultado: 123 CARAC = <>
. Este ejemplo utiliza UPPER() como parte de una condición
independiente de mayúsculas y minúsculas:
USE Cliente INDEX NombreCliente NEW
LIST NombreCliente FOR "KATE" $ UPPER(Cliente)
. UPPER() es útil también para crear expresiónes clave de
ííndices, independientes de mayúsculas y minúsculas:
USE Cliente NEW
INDEX ON UPPER(último) TO últimoCliente
. A continúa.ión, puede utilizar esta expresión para buscar
Clientes:
MEMVAR->último = SPACE(15)
@ 10, 10 GET MEMVAR->último
READ
SEEK UPPER(MEMVAR->último)
Ficheros: La biblioteca asociada es CLIPPER.LIB.
USED()
Determina si se est. utilizando un fichero de base de datos
------------------------------------------------------------------------------
Sintaxis
USED() --> lFichAbierto
Devuelve
USED() devuelve verdadero (.T.) si existe alg.n fichero de base de datos
abierto; en caso contrario devuelve falso (.F.)
Descripción
USED() es una función de base de datos que determina si existe alg.n
fichero de base de datos abierto o en un área de trabajo determinada.
Por defecto, USED() act.a en el área de trabajo seleccionada
actualmente. Si desea que act.e en un área de trabajo no seleccionada,
debe especificarse como parte de una expresión de alias.
Ejemplos
. Este ejemplo determina si se est. utilizando un fichero de
base de datos en el área de trabajo actual:
USE Cliente NEW
? USED() // Resultado: .T.
CLOSE
? USED() // Resultado: .F.
Ficheros: La biblioteca asociada es CLIPPER.LIB.
VAL()
Convierte un valor de carácteres en un valor numérico
------------------------------------------------------------------------------
Sintaxis
VAL(<cnúmero>) --> nNúmero
Argumentos
<cnúmero> es la expresión de carácteres que se va a convertir.
Devuelve
VAL() devuelve <cnúmero> convertido en un valor numérico, incluyendo
dígitos decimales.
Descripción
VAL() es una función de conversión que convierte una cadena de
carácteres que contiene dígitos numéricos en un valor numérico. Al
ejecutar VAL(), eval.a <cnúmero> hasta una segunda coma decimal, el
primer carácter no numérico o el final de la expresión. Los espacios en
blanco iniciales se ignoran. Si se ha establecido SET FIXED ON, VAL()
devuelve el número de lugares decimales especificado por SET DECIMALS,
redondeando <cnúmero> si se especifica con m.s dígitos que el valor
DECIMALS actual. Igual que las otras funciónes de redondeo, los dígitos
comprendidos entre cero y cuatro se redondean hacia abajo y los dígitos
entre cinco y nueve se redondean hacia arriba. Si se ha establecido SET
FIXED OFF, VAL() devuelve el número de lugares decimales especificado
entre <cnúmero>.
VAL() es la opuesta de STR() y TRANSFORM() que convierten valores
numéricos en cadenas de carácteres.
Ejemplos
. Estos ejemplos muestran la utilización de VAL() con SET FIXED
ON y SET DECIMALS TO 2:
SET DECIMALS TO 2
SET FIXED ON
//
? VAL("12,1234") // Resultado: 12,12
? VAL("12,1256") // Resultado: 12,13
? VAL("12A12") // Resultado: 12
? VAL("A1212") // Resultado: 0
? VAL(SPACE(0)) // Resultado: 0
? VAL(SPACE(1)) // Resultado: 0
? VAL(" 12,12") // Resultado: 12,12
? VAL("12 ,12") // Resultado: 12,00
Ficheros: La biblioteca asociada es CLIPPER.LIB.
VALTYPE()
Determina el tipo de datos devuelto por una expresión
------------------------------------------------------------------------------
Sintaxis
VALTYPE(<exp>) --> cTipo
Argumentos
<exp> es una expresión de cualquier tipo.
Devuelve
VALTYPE() devuelve un carácter sencillo que representa el tipo de datos
devuelto por <Exp>. VALTYPE() devuelve uno de los siguientes carácteres:
Valores Devueltos por VALTYPE()
------------------------------------------------------------------------
Devuelve Significado
------------------------------------------------------------------------
A Matriz
B Bloque de código
C Car.cter
D Fecha
L L.gico
M Memo
N numérico
O Objeto
U NIL
------------------------------------------------------------------------
Descripción
VALTYPE() es una función del sistema que toma un argumento, lo eval.a y
devuelve una cadena de carácteres que describe el tipo de datos del
valor devuelto. Es similar a TYPE() pero difiere en que eval.a realmente
el argumento especificado y determina el tipo del valor devuelto. Por
esta raz.n, permite determinar el tipo de las variablesólocales y
estáticas, funciónes definidas por el usuario y funciónes de la
biblioteca EXTEND.LIB. TYPE(), por el contrario, utiliza el operador de
macro (&) para evaluar el tipo del argumento. Observe que si el
argumento no existe se producirá un error ("error no definido"), a
diferencia de TYPE que devuelve "U".
Ejemplos
. Estos ejemplos muestran los valores de retorno para varios
tipos de datos:
? VALTYPE(1) // Resultado: N
? VALTYPE("GOOB") // Resultado: C
? VALTYPE(NIL) // Resultado: U
? VALTYPE(matriz) // Resultado: A
? VALTYPE(bloque) // Resultado: B
Ficheros: La biblioteca asociada es CLIPPER.LIB.
VERSION()
Devuelve la versi.n de CA-Clipper
------------------------------------------------------------------------------
Sintaxis
VERSION() --> cVersi.n
Devuelve
VERSION() devuelve el número de versi.n de la biblioteca EXTEND.LIB,
como un valor de carácteres.
Descripción
VERSION() es una función de entorno que devuelve el número de versi.n de
la biblioteca EXTEND.LIB de CA-Clipper.
Ficheros: La biblioteca asociada es EXTEND.LIB.
WORD()*
Convierte los parámetros numéricos del mandato CALL de doble precisión a
enteros sencillos
------------------------------------------------------------------------------
Sintaxis
WORD(<nNúmero>) --> NIL
Argumentos
<nNúmero> es el valor numérico que se va a convertir en entero,
especificado en el rango de m.s/menos 32.767, inclusive.
Devuelve
Utilizado como un argumento del mandato CALL WORD() devuelve un número
entero. En cualquier otro contexto, devuelve NIL.
Descripción
WORD() es una función de conversión que convierte los parámetros
numéricos del mandato CALL de doble precisión a enteros. WORD() es una
función de compatibilidad, por lo que su utilización no es recomendable.
Tanto el mandato CALL como la función WORD() se anulan por los programas
del Sistema Extendido. Si desea más información, consulte el capítulo
Utilizaci.n del Sistema Extendido en el Manual de Consulta T.cnica.
Ejemplos
. Este ejemplo utiliza WORD() como argumento del mandato CALL:
CALL Cproc WITH WORD(30000), "Un texto"
Ficheros: La biblioteca asociada es CLIPPER.LIB.
YEAR()
Convierte un valor de fecha en un a.o en formato numérico
------------------------------------------------------------------------------
Sintaxis
YEAR(<fFecha>) --> nA.o
Argumentos
<fFecha> es el valor de fecha que se va a convertir.
Devuelve
YEAR() devuelve el a.o contenido en el valor de fecha especificado,
insertando las cifras de siglo para dar un valor numérico de cuarto
dígitos. El valor que devuelve no depende del formato actual de
SET DATE o SET CENTURY. Si se especifica una fecha nula, (CTOD(""))
devuelve cero.
Descripción
YEAR() es una función de conversión que convierte un valor de fecha en
un a.o en formato numérico. Se utiliza para cálculos en informes
peri.dicos o para mostrar fechas con formato.
YEAR() forma parte de un grupo de funciónes que devuelven los
componentes de un valor de fecha en formato numérico. Este grupo incluye
DAY() y MONTH() que devuelven el d.a y el mes, respectivamente, como
valores numéricos.
Ejemplos
. Estos ejemplos muestran la utilización de YEAR() utilizando la
fecha del sistema:
? DATE() // Resultado: 09/20/90
? YEAR(DATE()) // Resultado: 1990
? YEAR(DATE()) + 11 // Resultado: 2001
. Este ejemplo crea una función definida por el usuario que
utiliza YEAR() para dar formato a un valor de fecha como mes, d.a,
a.o:
? Mdy(DATE()) // Resultado: 20 de Septiembre de 1990
FUNCTION Mdy( fFecha )
RETURN (LTRIM(STR(DAY(fFecha))) + "de" + cMonth(fFecha) +" "+;
STR(YEAR(fFecha))
Ficheros: La biblioteca asociada es CLIPPER.LIB.
