Am 2013-11-08 21:35, schrieb John Landmesser:
> i'm searching a pascal datetime function that simulates an Excel function:
"DateDif"
> Excel for example knows the function DateDif that returns the number of
Years, month and days between Date1 and date2.
> Date1 := 21.12.2012
> Date2 := 01.01.2013
> Result would be: 0 years, 0 moths, 11 days
I have written my own function because I wanted to
store dates in YYYY.MM.DD.MM.SS format and didn't
like any conversions back and forth between other
formats like TDateTime etc.
Find attached a time-diff routine based on some types (also included).
Maybe it is of help for you.
(Comments and function names are partly in german so you may need to change
them).
type ZeitTyp = record
Jahr : word;
Monat,
Tag,
Stunde,
Minute,
Sekunde : byte;
milliSek : word;
end;
EinAusTyp = (Aus,Ein);
ZeitmessTyp = array[EinAusTyp] of ZeitTyp;
ZeitDiffTyp = record
Negativ : boolean; // sozusagen als Vorzeichen
Tage,
Stunde,
Minute,
Sekunde,
milliSek : LongInt;
end;
//-------------------------------------------------------------------------------
function Schaltjahr(const Jahr : LongInt) : boolean;
// Wird true, wenn JAHR ein Schaltjahr ist
begin { Schaltjahr }
if ( (Jahr mod 4)=0 ) and
( (Jahr mod 100)<>0 ) or
( (Jahr mod 400)=0 ) then
Result := true
else
Result := false;
end; { of --Schaltjahr--------------}
//-------------------------------------------------------------------------------
function TimeDiffBase(var Time : ZeitmessTyp; out Fehler : boolean) : ZeitDiffTyp;
// Gibt die Zeitdifferenz der Zeiten TIME[EIN] minus TIME[AUS] zurück
var EinN,
AusN,
Wahl : EinAusTyp;
AnzahlTage : array[EinAusTyp] of LongInt;
iAnfang,
i,
Diff : LongInt;
begin { TimeDiffBase }
fillchar(Result,sizeof(Result),#0);
Fehler := false;
EinN := Ein;
AusN := Aus;
Result.Negativ := false;
Diff := LongInt(Time[Aus].Jahr)-Time[Ein].Jahr;
if Diff<0 then Result.Negativ := true { <-- Jahresdifferenz }
else
begin
if Diff=0 then
begin
Diff := LongInt(Time[Aus].Monat)-Time[Ein].Monat;
if Diff<0 then Result.Negativ := true { <-- Monatsdifferenz }
else
begin
if Diff=0 then
begin
Diff := LongInt(Time[Aus].Tag)-Time[Ein].Tag;
if Diff<0 then Result.Negativ := true { <-- Tagesdifferenz }
else
begin
if Diff=0 then
begin
Diff := LongInt(Time[Aus].Stunde)-Time[Ein].Stunde;
if Diff<0 then Result.Negativ := true { <-- Stundendifferenz }
else
begin
if Diff=0 then
begin
Diff := LongInt(Time[Aus].Minute)-Time[Ein].Minute;
if Diff<0 then Result.Negativ := true { <-- Minutendifferenz }
else
begin
if Diff=0 then
begin
Diff := LongInt(Time[Aus].Sekunde)-Time[Ein].Sekunde;
if Diff<0 then Result.Negativ := true { <-- Sekundendifferenz }
else
begin
if Diff=0 then
begin
Diff := LongInt(Time[Aus].MilliSek)-Time[Ein].MilliSek;
if Diff<0 then { <-- Millisekundendifferenz }
Result.Negativ := true;
end;
end;
end;
end;
end;
end;
end;
end;
end;
end;
end;
end;
if Result.Negativ then
begin
EinN := Aus;
AusN := Ein;
end;
Result.Stunde := LongInt(Time[AusN].Stunde)-Time[EinN].Stunde;
Result.Minute := LongInt(Time[AusN].Minute)-Time[EinN].Minute;
Result.Sekunde := LongInt(Time[AusN].Sekunde)-Time[EinN].Sekunde;
Result.millisek := LongInt(Time[AusN].milliSek)-Time[EinN].milliSek;
if (Time[EinN].Jahr<>Time[AusN].Jahr) or
(Time[EinN].Monat<>Time[AusN].Monat) or
(Time[EinN].Tag<>Time[AusN].Tag) then
begin { <-- Anzahl vergangener Tage in TAGE aufsummieren }
fillchar(AnzahlTage,sizeof(AnzahlTage),0);
if Time[EinN].Jahr<Time[AusN].Jahr then
iAnfang := Time[EinN].Jahr
else
iAnfang := Time[AusN].Jahr;
for Wahl := Low(Wahl) to High(Wahl) do
begin
for i := iAnfang to Time[Wahl].Jahr-1 do { <-- Tage aller vollen Jahre aufsummieren }
begin
if Schaltjahr(i) then
inc(AnzahlTage[Wahl],366)
else
inc(AnzahlTage[Wahl],365);
end;
for i := 1 to Time[Wahl].Monat-1 do { <-- Tage aller vollen Monate aufsummieren }
begin
case i of
2 : begin
if Schaltjahr(Time[Wahl].Jahr) then
inc(AnzahlTage[Wahl],29)
else
inc(AnzahlTage[Wahl],28);
end;
1,3,5,7,8,10,12 :
inc(AnzahlTage[Wahl],31);
else inc(AnzahlTage[Wahl],30);
end; { of case }
end;
inc(AnzahlTage[Wahl],Time[Wahl].Tag-1); { <-- Anzahl voller Tage }
end;
Result.Tage := AnzahlTage[AusN]-AnzahlTage[EinN];
if Result.Tage<0 then
begin
Fehler := true;
exit;
end;
end;
with Result do
begin
if millisek<0 then begin dec(Sekunde); inc(millisek,1000); end;
if Sekunde<0 then begin dec(Minute); inc(Sekunde,60); end;
if Minute<0 then begin dec(Stunde); inc(Minute,60); end;
if Stunde<0 then begin dec(Tage); inc(Stunde,24); end;
end;
end; { of --TimeDiffBase----------------}
--
_______________________________________________
Lazarus mailing list
[email protected]
http://lists.lazarus.freepascal.org/mailman/listinfo/lazarus
