31 agosto 2007

Trabajando con archivos de texto y binarios (IV)

En el artículo anterior vimos como movernos por un archivo binario utilizando la propiedad Position de la clase TFileStream. Ahora vamos a ver lo mismo utilizando AssignFile.

RECORRIENDO UN ARCHIVO BINARIO EN MODO LECTURA

Si utilizamos AssignFile para leer un archivo en vez de TFileStream podemos mover el puntero en cualquier dirección utilizando el procedimiento Seek:

procedure Seek( var F; N: Longint );

Este procedimiento toma como primer parámetro el puntero al archivo (F: File of Byte) y como segundo parámetro la posición donde queremos movernos, siendo cero la primera posición. Para irse al final del archivo se hace:

Seek( F, FileSize(F) )

Vamos a abrir el archivo prueba.dat de 100 KB creado anteriormente y nos vamos a ir a la posición 50 para leer 10 bytes volcando la información en un campo memo en formato hexadecimal:

var F: file of byte;
i: Integer;
Buffer: array[0..9] of Byte;
begin
AssignFile( F, ExtractFilePath( Application.ExeName ) + 'prueba.dat' );
Reset( F );
Seek( F, 50 );
BlockRead( F, Buffer, 10 );

for i := 0 to 9 do
Memo.Text := Memo.Text + IntToHex( Buffer[i], 2 ) + ' ';

CloseFile( F );
end;

El resultado sería:

32 33 34 35 36 37 38 39 3A 3B

El único inconveniente que tiene la función Seek es que sólo funciona en modo lectura (Reset). No se puede utilizar en modo escritura (Rewrite) para irse al final del archivo y seguir añadiendo datos.

Si no sabemos donde estamos se puede utilizar la función FilePos para averiguarlo:

ShowMessage( 'posición: ' + IntToStr( FilePos( F ) ) );


LEYENDO LAS PROPIEDADES DE UN ARCHIVO

Veamos de que funciones dispone Delphi para leer los atributos de un archivo (fecha, modo de acceso. etc.):

function FileAge( const FileName: string ): Integer;

Esta función devuelve la fecha y hora de última modificación de un archivo en formato TTimeStamp. Para pasar de formato TTimeStamp a formato TDateTime utilizamos la función FileDateToDateTime. Por ejemplo:

FileDateToDateTime( FileAge( 'prueba.txt' ) ) -> devuelve la fecha y hora de modificación del archivo prueba.txt

También disponemos de una función para obtener los atributos de un archivo:

function FileGetAttr( const FileName: string ): Integer;

Devuelve un valor entero conteniendo los posibles atributos de un archivo (puede tener varios a la vez). Por ejemplo, para averiguar si el archivo esta oculto se haría lo siguiente:

var
iAtributos: Integer;
begin
if ( iAtributos and faHidden <> 0 ) and ( iAtributos and faArchive <> 0 ) then
...
end;

Esta función no sólo comprueba archivos, sino también directorios y unidades de disco. Todos los posibles valores se encuentran en binario activando el bit correspondiente. Los valores posibles son:

Constante Valor Tipo de archivo
-------------------------------------------------------------------------------------------
faReadOnly 1 Sólo lectura
faHidden 2 Oculto
faSysFile 4 Archivo del sistema
faVolumeID 8 Unidad de disco
faDirectory 16 Directorio
faArchive 32 Archivo
faSymLink 64 Enlace simbólico
faAnyFile 71 Cualquier archivo

Otra función interesante es FileSize la cual devuelve en bytes el tamaño de un archivo. El único inconveniente es que hay que abrir el archivo para averiguarlo:

var
F: File of byte;
begin
AssignFile( F, 'c:\prueba.txt' );
Reset( F );
ShowMessage( IntToStr( FileSize( F ) ) + ' bytes' );
CloseFile( F );
end;


MODIFICANDO LAS PROPIEDADES DE UN ARCHIVO

Las función para modificar las propiedad de un archivo es:

function FileSetAttr( const FileName: string; Attr: Integer ): Integer;

Si se pudo modificar el atributo del archivo devuelve un 0 o en caso de error el código del mismo. Por ejemplo para hacer un archivo de sólo lectura y oculto:

FileSetAttr( 'c:\prueba.txt', faReadOnly or faHidden );

En el próximo artículo terminaremos de ver las funciones más importates para el manejo de archivos.

Pruebas realizadas en Delphi 7.

30 agosto 2007

Trabajando con archivos de texto y binarios (III)

Vamos a ver las distintas maneras que tenemos de manejar archivos binarios.

CREANDO UN ARCHIVO BINARIO

El crear un archivo binario utilizando AssignFile no es muy diferente de crear un archivo de texto:

procedure TFPrincipal.CrearArchivoBinario;
var
F: File of byte;
i: Integer;
begin
AssignFile( F, ExtractFilePath( Application.ExeName ) + 'prueba.dat' );
Rewrite( F );

for i := 1 to 10 do
Write( F, i );

CloseFile( F );
end;

Como se puede apreciar, la variable F representa un puntero a un tipo de archivo de bytes. Después utilizamos la función Write para ir guardando byte a byte dentro del archivo.

Cuando los archivos binarios son pequeños no hay problema pero cuando son grandes la lentitud puede ser insoportable (parece como si se hubiera colgado el programa). Cuando ocurre esto entonces hay que crear un buffer temporal para ir guardando los bytes en bloques de 1 Kb, 10 Kb, 20 Kb, etc. Hoy en día todo lo que entra y sale de un disco duro para por la memoria caché del mismo (a parte de la memoria virtual de Windows).

Vamos a ver un ejemplo de como crear un archivo binario grande (100 Kb) utilizando un buffer. Vamos a guardar en el archivo bytes consecutivos (0, 1, 2, .. 255, 0, 1, 2, ...):

procedure TFPrincipal.CrearArchivoBinarioConBuffer;
var
F: File of byte;
i, j: Integer;
b: Byte;
Buffer: array[1..1024] of byte;
begin
AssignFile( F, ExtractFilePath( Application.ExeName ) + 'prueba.dat' );
Rewrite( F );

b := 0;
// Guardamos 100 veces el buffer de 1 KB (100 KB)
for j := 1 to 100 do
begin
for i := 1 to 1024 do
begin
Buffer[i] := b;
Inc( b );
end;

BlockWrite( F, Buffer, 1024 );
end;

CloseFile( F );
end;

Hemos creado un buffer de 1024 bytes para guardar la información mediante el procedimiento BlockWrite que toma como primer parámetro el puntero F, como segundo parámetro el buffer del cual va a guardar la información y como tercer parámetro la longitud del buffer. Cuando más grande sea nuestro buffer menos accesos a disco se necesita y más suelto va nuestro programa.

Ahora veremos como hacer lo mismo utilizando la clase TFileStream.

CREANDO UN ARCHIVO BINARIO CON LA CLASE TFILESTREAM

El parecido con la rutina anterior es casi idéntico salvo que hemos sustituido un fichero de tipo File of byte por la clase TFileStream. El método Write toma como parámetros el buffer y su longitud:

procedure TFPrincipal.CrearStreamBinario;
var F: TFileStream;
Buffer: array[0..1023] of byte;
i, j: Integer;
b: Byte;
begin
F := TFileStream.Create( ExtractFilePath( Application.ExeName ) + 'prueba.dat', fmCreate );

b := 0;
// Guardamos 100 veces el buffer de 1 KB (100 KB)
for j := 1 to 100 do
begin
for i := 0 to 1023 do
begin
Buffer[i] := b;
Inc( b );
end;

F.Write( Buffer, 1024 );
end;

F.Free;
end;

MODIFICANDO UN ARCHIVO BINARIO

En un archivo que no sea de tipo TextFile no se puede utilizar el procedimiento Append para añadir datos al final del mismo. Usando AssignFile se pueden utilizar dos métodos:

- Leer la información de todo el archivo en un buffer, añadir información al final del mismo y posteriormente guardarlo todo sobrescribiendo el archivo con Rewrite.

- Otro método sería crear una copia del archivo y añadirle datos al final del mismo. Luego habría que borrar el original y sustituirlo por este nuevo.

Ambos métodos no los voy a mostrar ya que sería algo primitivo en los tiempos que estamos. Para ello nada mejor que la clase TFileStream para tratamiento de archivos binarios.

MODIFICANDO UN ARCHIVO BINARIO UTILIZANDO LA CLASE TFILESTREAM

Añadir datos a un archivo binario utilizando la clase TFileStream es tan fácil como irse al final del archivo y ponerse a escribir. De hecho sólo hemos añadido una línea de código al archivo anterior y hemos cambiado el método de apertura:

procedure TFPrincipal.AnadirStreamBinario;
var F: TFileStream;
Buffer: array[0..1023] of byte;
i, j: Integer;
b: Byte;
begin
F := TFileStream.Create( ExtractFilePath( Application.ExeName ) + 'prueba.dat', fmOpenWrite );
F.Position := F.Size;

b := 0;
// Guardamos 100 veces el buffer de 1 KB (100 KB)
for j := 1 to 100 do
begin
for i := 0 to 1023 do
begin
Buffer[i] := b;
Inc( b );
end;

F.Write( Buffer, 1024 );
end;

F.Free;
end;


LEYENDO UN ARCHIVO BINARIO

Para la lectura de un archivo binario también utilizaremos un buffer para acelerar el proceso:

procedure TFPrincipal.CargarStreamBinario;
var F: TFileStream;
Buffer: array[0..1023] of byte;
begin
F := TFileStream.Create( ExtractFilePath( Application.ExeName ) + 'prueba.dat', fmOpenRead );

// ¿No ha llegado al final de archivo?
while F.Position < F.Size do
begin
// Leemos un bloque de 1024 bytes
F.Read( Buffer, 1024 );
// ya tenemos un bloque de información en el buffer
// podemos hacer lo que queramos con el antes de cargar el siguiente bloque
end;

F.Free;
end;

¿Cómo sabemos cuando se termina el archivo? Lo sabemos por la variable Position que se va moviendo automáticamente a través del método Read. Cuando llegue al final (F.Size) cerramos el archivo.

Con esto llegamos a la conclusión de que para el manejo de archivos de texto lo ideal es utilizar AssignFile, StringList o campos Memo, pero para archivos binarios TFileStream cumple mejor su función.

En el próximo artículo seguiremos viendo más cosas sobre el tratamiento de archivos.

Pruebas realizadas en Delphi 7.

29 agosto 2007

Trabajando con archivos de texto y binarios (II)

Vamos a ver otra manera de manejar ficheros de texto utilizando algunas clases que lleva Delphi para hacer nuestra labor mucho más fácil.

Para ello utilizaremos la clase TFileStream que hereda de la clase TStream para manejar flujos de datos, en este caso archivos. Una de las ventanas de utilizar FileStream en vez de los clásicos métodos de pascal tales como Rewrite, WriteLn, etc. es que controla automáticamente los buffer en disco según el tamaño de los mismos en Windows.

CREANDO UN ARCHIVO DE TEXTO USANDO LA CLASE TFILESTREAM

La clase TFileStream proporciona un método rápido y flexible para el manejo de archivos. Veamos como crear un archivo detexto:

procedure TFormulario.CrearArchivoStream;
var
F: TFileStream;
s: String;
begin
F := TFileStream.Create( ExtractFilePath( Application.ExeName ) + 'prueba.txt', fmCreate );
s := 'Añadiendo información al archivo de texto.' + #13 + #10;
F.Write( s[1], Length( s ) );
F.Free;
end;

El constructor Create de la clase TFileStream toma como primer parámetro la ruta del archivo y como segundo parámetro el tipo de acceso. Los tipos de acceso son:

fmCreate -> Crea un nuevo archivo. Si el archivo ya existe lo sobrescribe.
fmOpenRead -> Abre el archivo en modo de solo lectura.
fmOpenWrite -> Abre el archivo en modo de escritura.
fmOpenReadWrite -> Abre el archivo en modo lectura/escritura.

Después se graba la información mediante el método Write el cual lee el contenido de un buffer (puede ser texto o binario) pasando como segundo parámetro su longitud (Length). Finalmente liberamos la clase con Free y el mismo objeto cierra automáticamente el archivo.

Le hemos pasado como primer parámetro s[1] porque es la dirección de memoria donde comienza la variable s (los string empiezan por 1). Al final de la cadena le hemos metido cambién los caracteres de retorno de carro para que pase a la siguiente línea, ya que un objeto FileStream lo trata todo como texto continuo.

Cuando la cantidad de información a mover es muy grande, éste metodo es mucho más rápido que utilizar el clasico Rewrite, WriteLn, etc. (a menos claro que creemos nuestro buffer).


AÑADIENDO TEXTO A UN ARCHIVO CON FILESTREAM

Para añadir líneas a nuestro archivo creado anteriormente abrimos el archivo en modo fmOpenWrite, nos vamos al final del archivo utilizando la propiedad Position y añadimos el texto:

procedure TFPrincipal.AnadirArchivoStream;
var
F: TFileStream;
s: String;
begin
F := TFileStream.Create( ExtractFilePath( Application.ExeName ) + 'prueba.txt', fmOpenWrite );
F.Position := F.Size;
s := 'Añadiendo información al archivo de texto.' + #13 + #10;
F.Write( s[1], Length( s ) );
F.Free;
end;

Si no se hubiese utilizado la propiedad Position habría machadado la información introducida anteriormente. Podemos movernos a nuestro antojo con la propiedad Position para guardar información en un fichero en cualquier sitio. Para irse al principio de un archivo sólo hay que hacer:

F.Position := 0;

LEYENDO LOS DATOS MEDIANTE FILESTREAM

El siguiente procedimiento lee el contenido del archivo en modo fmOpenRead en la variable s que hace de buffer y posteriormente lo manda al memo:

procedure TFPrincipal.CargarArchivoStream;
var
F: TFileStream;
s: String;
begin
F := TFileStream.Create( ExtractFilePath( Application.ExeName ) + 'prueba.txt', fmOpenRead );
SetLength( s, F.Size ); // *** Me faltaba esto, gracias por la corrección ***
F.Read( s[1], F.Size );
Memo.Text := s;
F.Free;
end;

Aunque en este caso no tenemos la flexibilidad que nos aportaban las funciones ReadLn y WriteLn para archivos de texto.

BLOQUEANDO EL ARCHIVO A OTROS USUARIOS

Una de las cualidades de las que goza el objeto FileStream es la de bloquear el acceso a otros usuarios mientras estamos trabajando con un archivo. La protección se realiza cuando se abre el archivo. Por ejemplo, si queremos abrir el archivo en modo lectura exclusivamente para nosotros hacemos:

F := TFileStream.Create( ExtractFilePath( Application.ExeName ) + 'prueba.txt', fmReadOnly or fmShareExclusive );

Mediante el operador OR mezclamos las opciones de apertura con las opciones de bloqueo. Las posibles opciones de bloqueo son:

fmShareCompat -> Permite compatibilizar la apertura con otro usuario o programa
fmShareExclusive -> Sólo nosotros tenemos derecho acceso de lectura/escritura mientras este abierto
fmShareDenyWrite -> Bloqueamos el archivo para que nadie pueda escribir salvo nosotros
fmShareDenyRead -> Bloqueamos el archivo para que nadie pueda leerlo salvo nosotros
fmShareDenyNone -> Permite la lectura/escritura por parte de otros usuarios.

También se podrían manipular archivos de texto facilmente mediante objetos TStringList como vimos con anterioridad. Yo personalmente utilizo TStringList, objetos Memo o RitchEdit ya que permiten una manipulación del texto en memoria bastante flexible antes de guardarla en disco.

En el próximo artículo veremos el tratamiento de archivos binarios.

Pruebas realizadas en Delphi 7.

28 agosto 2007

Trabajando con archivos de texto y binarios (I)

Voy a mostrar a continuación las distintas maneras que tenemos para crear, editar o eliminar archivos de texto o binarios. También aprenderemos a movermos por los directorios y por dentro de los archivos obteniendo la información del sistema cuando sea necesario.

CREANDO UN ARCHIVO DE TEXTO

Los pasos para crear un archivo son los siguientes:

1º Se crea una variable de tipo TextFile, la cual es un puntero a un archivo de texto.

2º Se utiliza la función AssignFile para asignar el puntero F al archivo de texto.

3º A continuación abrimos el archivo en modo escritura mediante el procedimiento Rewrite.

4º Escrimimos en el archivo mediante la función WriteLn.

5º Cerramos el archivo creado con el procedimiento CloseFile.

Vamos a crear un procedimiento para crear el archivo prueba.txt al lado de nuestro programa:

procedure TFormulario.CrearArchivoTexto;
var
F: TextFile;
begin
AssignFile( F, ExtractFilePath( Application.ExeName ) + 'prueba.txt' );
Rewrite( F );
WriteLn( F, 'Esto es el contenido del archivo de texto.' );
CloseFile( F );
end;

MODIFICANDO UN ARCHIVO DE TEXTO

Cuando se utiliza la función Rewrite no comprueba si el archivo ya existía anteriormente, lo que puede provocar que elimine la información anterior. Para prevenir esto lo que hacemos es preguntar si ya existe el archivo y si es así entonces añadimos al contenido del archivo mediante el procedimiento Append:

procedure TFormulario.AnadirArchivoTexto;
var
F: TextFile;
sArchivo: string;
begin
sArchivo := ExtractFilePath( Application.ExeName ) + 'prueba.txt';
AssignFile( F, sArchivo );

if FileExists( sArchivo ) then
Append( F )
else
Rewrite( F );

WriteLn( F, 'Añadiendo información al archivo de texto.' );
CloseFile( F );
end;

ABRIENDO UN ARCHIVO DE TEXTO

Vamos a abrir el archivo de texto en modo lectura para volcar su contenido en un campo memo del formulario. Para ello abrimos el archivo con el procedimiento Reset y leemos cada línea de texto mediante ReadLn:

procedure TFormulario.CargarArchivoTexto;
var F: TextFile;
sLinea: String;
begin
AssignFile( F, ExtractFilePath( Application.ExeName ) + 'prueba.txt' );
Reset( F );

while not Eof( F ) do
begin
ReadLn( F, sLinea );
Memo.Lines.Add( sLinea );
end;

CloseFile( F );
end;

El procedimiento ReadLn obliga a leer la línea de texto dentro de una variable. Después incrementa automáticamente el puntero F hasta la siguiente línea de texto, siendo la función Eof la que nos dice si ha llegado al final del archivo. Aunque en este caso lo más fácil sería utilizar la propiedad LoadFromFile del objeto memo:

Memo.Lines.LoadFromFile( ExtractFilePath( Application.ExeName ) + 'prueba.txt' );

ELIMINANDO UN ARCHIVO

La eliminación de un archivo se hace con la función DeleteFile la cual está dentro de la unidad SysUtils:

procedure TFormulario.EliminarArchivoTexto;
var sArchivo: String;
begin
sArchivo := ExtractFilePath( Application.ExeName ) + 'prueba.txt';
if FileExists( sArchivo ) then
DeleteFile( sArchivo );
end;

Todas estas funciones (Rewrite, Append, etc.) vienen del lenguaje estándar de Pascal, ya que en Delphi hay maneras mucho más sencillas de realizar estas tareas, como veremos más adelante.

Pruebas ralizadas en Delphi 7.

27 agosto 2007

Funciones y procedimientos para fecha y hora (y III)

Sigamos con las funciones para el tratamiento de TTime, TDate y TDateTime:

function IsLeapYear( Year: Word ): Boolean;

Esta función nos dice si un año es bisiesto. Por ejemplo:

IsLeapYear( 2004 ) devuelve True
IsLeapYear( 2006 ) devuelve False
IsLeapYear( 2007 ) devuelve False
IsLeapYear( 2008 ) devuelve True
IsLeapYear( 2009 ) devuelve False

function MonthOfTheYear( const AValue: TDateTime ): Word;

Devuelve el número de mes de un año a partir de un valor TDateTime (evita el tener que utilizar DecodeTime). Por ejemplo:

MonthOfTheYear( StrToDate( '20/01/2007' ) ) devuelve 1
MonthOfTheYear( StrToDate( '27/08/2007' ) ) devuelve 8
MonthOfTheYear( StrToDate( '31/12/2007' ) ) devuelve 12


function Now: TDateTime;

Esta función dos devuelve la fecha y hora actual del sistema (reloj de Windows). Por ejemplo:

Now devuelve 27/08/2007 10:05:01


function RecodeDate( const AValue: TDateTime; const AYear, AMonth, ADay: Word ): TDateTime;

Esta función modifica la fecha de un valor TDateTime sin afectar a la hora. Por ejemplo:

var
dt: TDateTime;
begin
dt := StrToDateTime( '27/08/2007 15:21:43' );
ShowMessage( 'Fecha y hora antes de modificar: ' + DateTimeToStr( dt ) );
dt := RecodeDate( dt, 2005, 7, 26 );
ShowMessage( 'Fecha y hora después de modificadar: ' + DateTimeToStr( dt ) );
end;

Al ejecutarlo muestra:

Fecha y hora antes de modificar: 27/08/2007 15:21:43
Fecha y hora después de modificar: 26/07/2005 15:21:43


function RecodeTime( const AValue: TDateTime; const AHour, AMinute, ASecond, AMilliSecond: Word ): TDateTime;

Modifica la hora de un valor TDateTime sin afectar a la fecha. Por ejemplo:

var
dt: TDateTime;
begin
dt := StrToDateTime( '27/08/2007 15:21:43' );
ShowMessage( 'Fecha y hora antes de modificar: ' + DateTimeToStr( dt ) );
dt := RecodeTime( dt, 16, 33, 14, 0 );
ShowMessage( 'Fecha y hora después de modificar: ' + DateTimeToStr( dt ) );
end;

El resultado sería:

Fecha y hora antes de modificar: 27/08/2007 15:21:43
Fecha y hora después de modificar: 27/08/2007 16:33:14


procedure ReplaceDate( var DateTime: TDateTime; const NewDate: TDateTime );

Este procedimiento modifica la fecha de una variable TDateTime sin afectar a la hora. Por ejemplo:

var
dt: TDateTime;
begin
dt := StrToDateTime( '27/08/2007 18:15:31' );
ShowMessage( 'Fecha y hora antes de modificar: ' + DateTimeToStr( dt ) );
ReplaceDate( dt, StrToDate( '01/09/2007' ) );
ShowMessage( 'Fecha y hora después de modificar: ' + DateTimeToStr( dt ) );
end;

El resultado sería:

Fecha y hora antes de modificar: 27/08/2007 18:15:31
Fecha y hora después de modificar: 01/09/2007 18:15:31


procedure ReplaceTime( var DateTime: TDateTime; const NewTime: TDateTime );

Modifica la hora de una variable TDateTime sin afectar a la fecha. Por ejemplo:

var
dt: TDateTime;
begin
dt := StrToDateTime( '27/08/2007 19:33:22' );
ShowMessage( 'Fecha y hora antes de modificar: ' + DateTimeToStr( dt ) );
ReplaceTime( dt, StrToTime( '14:21:05' ) );
ShowMessage( 'Fecha y hora después de modificar: ' + DateTimeToStr( dt ) );
end;

El resultado sería:

Fecha y hora antes de modificar: 27/08/2007 19:33:22
Fecha y hora después de modificar: 27/08/2007 14:21:05


function Time: TDateTime;
function GetTime: TDateTime;


Estas dos funciones devuelven la hora actual en formato TDateTime. Por ejemplo:

ShowMessage( 'Time devuelve ' + TimeToStr( Time ) );
ShowMessage( 'GetTime devuelve ' + TimeToStr( GetTime ) );
ShowMessage( 'Time devuelve ' + DateTimeToStr( Time ) );
ShowMessage( 'GetTime devuelve ' + DateTimeToStr( GetTime ) );

Al ejecutarlo muestra:

Time devuelve 10:36:10
GetTime devuelve 10:36:10
Time devuelve 30/12/1899 10:36:10
GetTime devuelve 30/12/1899 10:36:10

Si os fijais bien cuando mostramos la hora en formato TDateTime vemos que la fecha esta nula (30/12/1899). Mucho cuidado con eso si no quereis que el usuario se quede con cara de flipado, sobre todo al guardar o cargar el valor de un campo de la base de datos.

function Tomorrow: TDateTime;

Nos devuelve la fecha de mañana. Por ejemplo:

ShowMessage( 'DateToStr( Tomorrow ) devuelve ' + DateToStr( Tomorrow ) );
ShowMessage( 'DateToStr( Tomorrow ) devuelve ' + DateTimeToStr( Tomorrow ) );
ShowMessage( 'DateToStr( Tomorrow ) devuelve ' + TimeToStr( Tomorrow ) );

Nos mostraría:

DateToStr( Tomorrow ) devuelve 28/08/2007
DateToStr( Tomorrow ) devuelve 28/08/2007
DateToStr( Tomorrow ) devuelve 0:00:00

Como vemos en el ejemplo sólo nos da el día de mañana, pero no la hora (0:00:00).

function Yesterday: TDateTime;

Nos devuelve el día de ayer en formato TDateTime. Por ejemplo:

DateToStr( Yesterday ) devuelve 26/08/2007

Las siguientes funciones ya las hemos visto anteriormente:

function DateToStr( Date: TDateTime ): string; overload;
function TimeToStr( Time: TDateTime ): string; overload;
function DateTimeToStr( DateTime: TDateTime ): string; overload;
function StrToDate( const S: string ): TDateTime; overload;
function StrToTime( const S: string ): TDateTime; overload;
function StrToDateTime( const S: string ): TDateTime; overload;


Pruebas realizadas en Delphi 7.

Publicidad