Datumsberechnungen wirken harmlos, bis die Abfrage die Datensätze von heute nicht findet, die Kalenderwoche zum Jahreswechsel danebenliegt oder die Summe der Arbeitszeiten plötzlich 07:59 statt 08:00 lautet. Alle drei Fälle haben dieselbe Ursache: Access speichert Datum und Uhrzeit anders, als die angezeigte Darstellung vermuten lässt. Dieser Beitrag zeigt, was dabei schiefgehen kann, und liefert die Funktionen, die Ihnen die üblichen Fallen abnehmen.<\/b><\/p>\nWie Access Datum und Zeit speichert<\/h2>\n
Ein Wert des Datentyps Date<\/b> ist intern eine Fließkommazahl vom Typ Double<\/b>. Für die in heutigen Anwendungen üblichen Datumswerte ab dem 30. Dezember 1899 zählt der Ganzzahlanteil die Tage seit diesem Ausgangsdatum, der Nachkommaanteil gibt die Tageszeit als Bruchteil eines Tages an. Listing 1 macht das sichtbar.<\/p>\n Die Ausgabe im Direktbereich:<\/p>\n Der 5. April 2026 ist also der Tag Nummer 46117, zwölf Uhr mittags entspricht einem halben Tag, sechs Uhr morgens einem Viertel. Aus dieser Darstellung folgen unmittelbar zwei nützliche Rechenregeln: Ein Tag mehr heißt schlicht + 1<\/b>, und die Differenz zweier Datumswerte, multipliziert mit 24, ergibt die Stundenzahl dazwischen. Beachten Sie die Datumsliterale im Code. Zwischen den Rautezeichen erwartet VBA das amerikanische Format mit Monat vor Tag. Schreiben Sie #5.4.2026#<\/b>, wandelt der Editor das stillschweigend in #5\/4\/2026#<\/b> um – und das ist der 4. Mai, nicht der 5. April.<\/p>\n Genau hier liegt die häufigste Fehlerquelle überhaupt. Ein Feld vom Typ Datum\/Uhrzeit, das mit Now<\/b> gefüllt wurde, enthält eben auch die Uhrzeit. Die Prozedur in Listing 2 führt vor, was das für einen Vergleich bedeutet.<\/p>\n Hier ist die Ausgabe dieser Prozedur:<\/p>\n Der erste Vergleich scheitert, weil 46117,4008 nun einmal nicht 46117 ist. Für aktuelle, positive Datumswerte schneiden sowohl Int<\/b> als auch DateValue<\/b> den Zeitanteil ab; DateValue<\/b> drückt die fachliche Absicht deutlicher aus. In einer Abfrage sollten Sie allerdings keine der beiden Funktionen auf das Feld anwenden, weil Access dann für jeden Datensatz rechnen muss und den Index nicht mehr nutzen kann. Formulieren Sie stattdessen einen Bereich, wie ihn foglendes Listing zeigt:<\/p>\n Die obere Grenze steht bewusst auf kleiner als der Folgetag<\/b> und nicht auf Between<\/b>. Ein Between #2026-04-05# And #2026-04-06#<\/b> würde die Datensätze vom 6. April um Punkt Mitternacht mit einschließen, weil Between<\/b> an beiden Enden einschließend arbeitet.<\/p>\n Setzen Sie eine solche Bedingung per VBA zusammen, brauchen Sie das Datum als Zeichenkette. Ein schlichtes Verketten mit dem Datumswert ist problematisch, weil VBA dabei gewöhnlich ein von den Regionaleinstellungen abhängiges Datumsformat erzeugt und Access den 5. April dann als 4. Mai liest. Die Funktion SqlDatum<\/b> aus Listing 2 nimmt Ihnen die Umwandlung ab.<\/p>\n Listing 1: SqlDatum liefert ein Datum in der von Access erwarteten Schreibweise<\/span><\/b><\/p>\n Die Funktion erzeugt das ISO-Format mit Jahr, Monat und Tag, das Access unabhängig von den Ländereinstellungen richtig auswertet. Die umgekehrten Schrägstriche im Formatausdruck sorgen dafür, dass Raute, Bindestrich und Doppelpunkt als Zeichen ausgegeben und nicht als Formatanweisung gedeutet werden. Beim Doppelpunkt ist das zwingend, denn ohne Maskierung setzt VBA dort das landestypische Zeitzeichen ein.<\/p>\n Die Prüfung mit IsDate<\/b> weist ungeeignete Werte bereits in der Hilfsfunktion mit einer verständlichen Fehlermeldung zurück. Ohne sie liefe eine versehentlich übergebene Zeichenkette entweder in einen Fehler bei CDate<\/b> oder in einen SQL-Ausdruck, dessen Ursache sich später nur mühsam zurückverfolgen lässt.<\/p>\n Ein Null<\/b>-Wert wird zum SQL-Schlüsselwort Null<\/b>. Das ist bei Wertzuweisungen verwendbar, etwa in einer Aktualisierungsabfrage. In Vergleichsbedingungen muss ein Nullwert dagegen mit Is Null<\/b> beziehungsweise Is Not Null<\/b> geprüft werden – ein WHERE Lieferdatum = Null<\/b> liefert grundsätzlich keine Treffer.<\/p>\n Damit lässt sich der Tagesbereich aus der obigen Abfrage sauber zusammensetzen:<\/p>\n Noch robuster sind parametrisierte Abfragen. Dabei übergibt DAO den Datumswert typisiert, sodass weder das regionale Format noch die Schreibweise des Datumsliterals eine Rolle spielt. Folgendes Listing zeigt, wie das aussieht:<\/p>\n Der leere Name im Aufruf von CreateQueryDef<\/b> erzeugt eine temporäre Abfrage, die nicht im Navigationsbereich erscheint. Die beiden Parameter werden mit DateTime<\/b> deklariert und anschließend als echte Datumswerte zugewiesen – eine Zeichenkette entsteht dabei an keiner Stelle.<\/p>\n Die eingebaute Funktion DatePart<\/b> kennt das Intervall ww<\/b> und liefert damit eine Kalenderwoche. Übergeben Sie zusätzlich die Parameter vbMonday<\/b> und vbFirstFourDays<\/b>, entspricht die Wochennummer der Zählung nach ISO 8601. Beide Angaben sind Pflicht: Ohne sie beginnt die Woche am Sonntag und die erste Woche des Jahres mit dem 1. Januar – das ist die amerikanische Zählung und für deutsche Auswertungen unbrauchbar.<\/p>\n Was DatePart<\/b> dagegen nicht liefert, ist das Wochenjahr. Und genau daran scheitern Auswertungen, wie Listing 6 zeigt.<\/p>\n Hier ist das Ergebnis der Prozedur:<\/p>\n Beide Angaben sind falsch. Der 31. Dezember 2007 gehört zur Woche 1 des Jahres 2008<\/b>, der 1. Januar 2021 zur Woche 53 des Jahres 2020<\/b>. Die Wochennummern stimmen also – nur das Jahr passt nicht dazu, weil Year<\/b> das Kalenderjahr liefert und nicht das Wochenjahr. Ein Jahr 2021 mit einer Woche 53 gibt es überhaupt nicht.<\/p>\n In der Praxis fällt das erst auf, wenn eine Auswertung über den Jahreswechsel läuft. Eine Gruppierung nach Jahr und Woche erzeugt dann Gruppen, die es nicht gibt, und verteilt die Datensätze einer einzigen Woche auf zwei Zeilen.<\/p>\n Die Norm löst das über eine einfache Regel: Eine Woche gehört zu dem Jahr, in dem ihr Donnerstag liegt. Damit lassen sich Wochennummer und Wochenjahr aus derselben Rechnung ableiten. Die Funktion IsoKalenderwoche<\/b> aus Listing 3 übernimmt den ersten Teil.<\/p>\n Listing 2: IsoKalenderwoche liefert die Wochennummer nach ISO 8601<\/span><\/b><\/p>\n Die Funktion ermittelt zuerst den Donnerstag der Woche, in der das übergebene Datum liegt. Weekday<\/b> mit dem Parameter vbMonday<\/b> liefert für Montag die 1, für Sonntag die 7; die Rechnung Datum minus Wochentag plus 4<\/b> landet damit immer auf dem Donnerstag. Der Aufruf von DateValue<\/b> entfernt einen etwaigen Zeitanteil, der für die Kalenderwoche ohne Bedeutung ist. Anschließend ermittelt sie die Position dieses Donnerstags innerhalb des Jahres, teilt durch sieben und addiert eins.<\/p>\n Das Wochenjahr fällt dabei nebenbei ab: Es ist schlicht das Jahr des Donnerstags. Die Funktion IsoKalenderjahr<\/b> aus Listing 4 gibt es zurück.<\/p>\n Listing 3: IsoKalenderjahr liefert das Jahr, zu dem die Woche gehört<\/span><\/b><\/p>\n Für die beiden Problemfälle von oben sieht das nun so aus:<\/p>\n Die Ergebnisse lauten nun:<\/p>\n Wenn Sie nach Kalenderwochen gruppieren, verwenden Sie immer beide Funktionen zusammen. Eine Auswertung, die nur nach der Wochennummer gruppiert, wirft die Woche 53 aus 2015 und die Woche 53 aus 2020 in denselben Topf.<\/p>\n Auch hier führt die naheliegende Lösung in die Irre. DateDiff<\/b> mit dem Intervall yyyy<\/b> zählt die Jahreswechsel zwischen zwei Datumsangaben, nicht die erreichten Geburtstage. Für eine am 15. Juni 1980 geborene Person liefert es am 14. Juni 2026 bereits 46 statt 45. Die Funktion Alter<\/b> aus Listing 5 korrigiert das.<\/p>\n Listing 4: Alter berechnet das vollendete Lebensalter zu einem Stichtag<\/span><\/b><\/p>\n Die Funktion nimmt zunächst die Differenz der Jahreszahlen und zieht eine Eins ab, falls der Geburtstag im Stichjahr noch bevorsteht. Ein Geburtsdatum nach dem Stichtag weist sie mit einem Fehler zurück, weil ein negatives Alter kein sinnvolles Ergebnis wäre.<\/p>\n Der Stichtag ist optional; bleibt er leer, enthält datStichtag<\/b> den Wert 0, und die Funktion setzt das heutige Datum ein. Diese verbreitete Konstruktion hat einen kleinen Haken: Der 30. Dezember 1899 besitzt ebenfalls den internen Wert 0 und lässt sich deshalb nicht als Stichtag übergeben. Für Geschäftsanwendungen ist das ohne Belang; wollen Sie ganz sichergehen, deklarieren Sie den Parameter als Variant<\/b> und prüfen ihn mit IsMissing<\/b>.<\/p>\n Der Schaltjahrfall ist bereits erledigt, ohne dass es dafür eine eigene Zeile bräuchte. Für einen am 29. Februar Geborenen erzeugt DateSerial<\/b> in einem Nicht-Schaltjahr den 1. März, weil die Funktion ungültige Tageswerte in den Folgemonat weiterrechnet. Damit wird das höhere Lebensalter in einem Nicht-Schaltjahr ab dem 1. März zurückgegeben. Das entspricht der gesetzlichen Fristberechnung nach Paragraf 188 Absatz 3 BGB, nach der das vorherige Lebensjahr mit Ablauf des 28. Februar endet.<\/p>\n Hier sind die Ergebnisse dieser Aufrufe:<\/p>\n Den ersten Tag eines Monats liefert DateSerial<\/b> unmittelbar. Für den letzten gibt es einen Kniff, den Listing 6 in den beiden Funktionen MonatsErster<\/b> und MonatsLetzter<\/b> ausnutzt.<\/p>\n Listing 5: MonatsErster und MonatsLetzter ermitteln die Monatsgrenzen<\/span><\/b><\/p>\n MonatsLetzter<\/b> übergibt an DateSerial<\/b> den Folgemonat und als Tag die Null. Da DateSerial<\/b> Werte außerhalb des gültigen Bereichs weiterrechnet, ist der nullte Tag des Folgemonats genau der letzte Tag des gewünschten Monats. Der Kniff kümmert sich damit ganz nebenbei um unterschiedlich lange Monate und um Schaltjahre. Auch der Dezember ist kein Sonderfall: Der dreizehnte Monat eines Jahres ist der Januar des Folgejahres. Anbei einige Beispielaufrufe:<\/p>\n Diese liefern die folgenden Ergebnisse:<\/p>\n Nach demselben Muster arbeiten die drei Funktionen für das Quartal in Listing 7:<\/p>\n Listing 6: Quartal, QuartalsErster und QuartalsLetzter für Quartalsauswertungen<\/span><\/b><\/p>\n Hier sind die Ergebnisse der Beispielaufrufe:<\/p>\n Beim Rechnen mit ganzen Monaten lauert eine Falle, die man kennen sollte: DateAdd<\/b> ist nicht umkehrbar. Der Aufruf DateAdd(„m“, 1, #1\/31\/2026#)<\/b> liefert den 28. Februar, weil es keinen 31. Februar gibt. Ein anschließendes DateAdd(„m“, -1, …)<\/b> führt dann auf den 28. Januar und nicht zurück auf den Ausgangswert. Bei Ratenplänen und Fälligkeiten ist es deshalb sicherer, immer vom ursprünglichen Datum aus zu rechnen statt schrittweise weiterzuzählen.<\/p>\n Eine Schicht von 22:00 bis 06:00 ergibt bei schlichter Subtraktion einen negativen Wert. Die Funktion Zeitspanne<\/b> aus Listing 8 fängt das ab, indem sie dem Endzeitpunkt einen Tag hinzufügt, wenn er vor dem Beginn liegt. Die Funktion demonstrieren die folgenden Aufrufe:<\/p>\n Listing 7: Zeitspanne liefert die Stunden zwischen zwei Uhrzeiten<\/span><\/b><\/p>\n Hier die Resultate:<\/p>\n Die Funktion setzt voraus, dass eine Schicht kürzer als 24 Stunden ist – für Arbeitszeiten eine unproblematische Annahme. Sind die Datumswerte vollständig, also mit Tag und Uhrzeit gespeichert, brauchen Sie die Korrektur nicht und können unmittelbar subtrahieren. Vollständige Datumswerte beseitigen allerdings nur die Unklarheit beim Überschreiten von Mitternacht.<\/p>\n Eine Einschränkung gehört allerdings dazu: Die Funktion rechnet mit reinen Uhrzeiten und kennt weder Datum noch Zeitzone. In Nächten mit einer Zeitumstellung kann die tatsächlich vergangene Zeit deshalb um eine Stunde abweichen – eine Schicht von 22:00 bis 06:00 dauert dann sieben oder neun Stunden, die Funktion meldet aber weiterhin acht. Das gilt genauso für vollständige Datumswerte, solange es sich um lokale Zeitangaben handelt. Soll die tatsächlich vergangene Zeit bestimmt werden, führt der zuverlässigste Weg über UTC-Werte, weil dort keine Zeitumstellung dazwischenkommt.<\/p>\n Beim Ausgeben summierter Zeiten enttäuscht Format<\/b> mit dem Ausdruck „hh:nn“<\/b>: Sobald die Summe 24 Stunden überschreitet, beginnt die Anzeige wieder bei null, weil ein Datumswert einen Tag weiterzählt. Für Wochen- oder Monatssummen brauchen Sie deshalb eine eigene Formatierung, wie sie die Funktion StundenFormat<\/b> in Listing 9 vornimmt.<\/p>\n Listing 8: StundenFormat gibt auch Summen über 24 Stunden korrekt aus<\/span><\/b><\/p>\n Die Funktion rechnet bewusst über die Gesamtzahl der Minuten. Der Zuschlag von 0,5 vor dem Abschneiden mit Fix<\/b> rundet kaufmännisch – anders als Public Sub <\/span>DatumAlsZahl()\r\n Debug.Print<\/span> CDbl(#4\/5\/2026#)\r\n Debug.Print<\/span> CDbl(#4\/5\/2026 12:00:00 PM#)\r\n Debug.Print<\/span> CDbl(#4\/5\/2026 6:00:00 AM#)\r\n Debug.Print<\/span> CDbl(#12\/30\/1899#)\r\nEnd Sub<\/span><\/pre>\n46117\r\n46117,5\r\n46117,25\r\n0<\/pre>\n
Der versteckte Zeitanteil<\/h2>\n
Public Sub <\/span>ZeitanteilFalle()\r\n Dim <\/span>datGespeichert As Date<\/span>\r\n datGespeichert = #4\/5\/2026 9:37:12 AM#\r\n Debug.Print<\/span> datGespeichert = #4\/5\/2026#\r\n Debug.Print<\/span> Int(datGespeichert) = #4\/5\/2026#\r\n Debug.Print<\/span> DateValue(datGespeichert) = #4\/5\/2026#\r\nEnd Sub<\/span><\/pre>\nFalsch\r\nWahr\r\nWahr<\/pre>\n
SELECT *\r\nFROM tblAuftraege\r\nWHERE Erfasst >= #2026-04-05#\r\n AND Erfasst < #2026-04-06#<\/pre>\n
Datumsangaben in SQL-Ausdrücke einbauen<\/h2>\n
Public Function <\/span>SqlDatum(ByVal varDatum As Variant<\/span>, Optional<\/span> ByVal blnMitZeit As Boolean<\/span> = False<\/span>) As String<\/span>\r\n If <\/span>IsNull(varDatum) Then<\/span>\r\n SqlDatum = \"Null\"\r\n Else<\/span>If Not<\/span> IsDate(varDatum) Then\r\n Err.Raise 13, \"SqlDatum\", \"Der übergebene Wert ist kein gültiges Datum.\"\r\n Else<\/span>If blnMitZeit Then\r\n SqlDatum = Format$(CDate(varDatum), \"\\#yyyy\\-mm\\-dd hh\\:nn\\:ss\\#\")\r\n Else<\/span>\r\n SqlDatum = Format$(CDate(varDatum), \"\\#yyyy\\-mm\\-dd\\#\")\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nDebug.Print<\/span> SqlDatum(#4\/5\/2026#)\r\nDebug.Print<\/span> SqlDatum(#4\/5\/2026 9:37:12 AM#, True<\/span>)\r\nDebug.Print<\/span> SqlDatum(Null)\r\n#2026-04-05#\r\n#2026-04-05 09:37:12#\r\nNull<\/pre>\nPublic Sub <\/span>Tagesbereich()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>datTag As Date<\/span>\r\n \r\n datTag = #4\/5\/2026#\r\n strSQL = \"SELECT * FROM tblAuftraege WHERE Erfasst >= \" _\r\n & SqlDatum(datTag) & \" AND Erfasst < \" _\r\n & SqlDatum(datTag + 1) \r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(strSQL, dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Debug.Print<\/span> rst.Fields(0), rst.Fields(1)\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>TagesbereichParametrisiert()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>datTag As Date<\/span>\r\n \r\n datTag = #4\/5\/2026#\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> qdf = db.CreateQueryDef(\"\", _\r\n \"PARAMETERS pVon DateTime, pBis DateTime; \" & _\r\n \"SELECT * FROM tblAuftraege \" & _\r\n \"WHERE Erfasst >= pVon AND Erfasst < pBis\")\r\n \r\n qdf.Parameters(\"pVon\") = datTag\r\n qdf.Parameters(\"pBis\") = DateAdd(\"d\", 1, datTag)\r\n \r\n Set<\/span> rst = qdf.OpenRecordset\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Debug.Print<\/span> rst.Fields(0), rst.Fields(1)\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nDie Kalenderwoche nach ISO 8601<\/h2>\n
Public Sub <\/span>KalenderwocheFalle()\r\n Debug.Print<\/span> Year(#12\/31\/2007#) & \"-KW\" _\r\n & DatePart(\"ww\", #12\/31\/2007#, _\r\n vbMonday, vbFirstFourDays)\r\n Debug.Print<\/span> Year(#1\/1\/2021#) & \"-KW\" _\r\n & DatePart(\"ww\", #1\/1\/2021#, _\r\n vbMonday, vbFirstFourDays)\r\nEnd Sub<\/span><\/pre>\n2007-KW1\r\n2021-KW53<\/pre>\n
Public Function <\/span>IsoKalenderwoche(ByVal datDatum As Date<\/span>) As Long<\/span>\r\n Dim <\/span>datDonnerstag As Date<\/span>\r\n ' Donnerstag derselben Woche ermitteln\r\n datDonnerstag = DateValue(datDatum) - Weekday(datDatum, vbMonday) + 4\r\n IsoKalenderwoche = Int((datDonnerstag - DateSerial(Year(datDonnerstag), 1, 1)) \/ 7) + 1\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>IsoKalenderjahr(ByVal datDatum As Date<\/span>) As Long<\/span>\r\n IsoKalenderjahr = Year(DateValue(datDatum) - Weekday(datDatum, vbMonday) + 4)\r\nEnd Function<\/span><\/pre>\nDebug.Print<\/span> IsoKalenderjahr(#12\/31\/2007#) & \"-KW\" _\r\n & IsoKalenderwoche(#12\/31\/2007#)\r\nDebug.Print<\/span> IsoKalenderjahr(#1\/1\/2021#) & \"-KW\" _\r\n & IsoKalenderwoche(#1\/1\/2021#)\r\nDebug.Print<\/span> IsoKalenderjahr(#1\/3\/2016#) & \"-KW\" _\r\n & IsoKalenderwoche(#1\/3\/2016#)<\/pre>\n2008-KW1\r\n2020-KW53\r\n2015-KW53<\/pre>\n
Das Alter berechnen<\/h2>\n
Public Function <\/span>Alter(ByVal datGeburt As Date<\/span>, Optional<\/span> ByVal datStichtag As Date<\/span>) As Long<\/span>\r\n Dim <\/span>datGeburtstag As Date<\/span>\r\n If <\/span>datStichtag = 0 Then<\/span> datStichtag = Date\r\n If <\/span>datGeburt > datStichtag Then<\/span>\r\n Err.Raise 5, \"Alter\", \"Das Geburtsdatum liegt nach dem Stichtag.\"\r\n End If<\/span>\r\n Alter = DateDiff(\"yyyy\", datGeburt, datStichtag)\r\n ' Geburtstag im Stichjahr\r\n datGeburtstag = DateSerial(Year(datStichtag), Month(datGeburt), Day(datGeburt))\r\n If <\/span>datGeburtstag > datStichtag Then<\/span>\r\n Alter = Alter - 1\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nDebug.Print<\/span> Alter(#6\/15\/1980#, #6\/14\/2026#)\r\nDebug.Print<\/span> Alter(#6\/15\/1980#, #6\/15\/2026#)\r\nDebug.Print<\/span> Alter(#2\/29\/2000#, #2\/28\/2026#)\r\nDebug.Print<\/span> Alter(#2\/29\/2000#, #3\/1\/2026#)<\/pre>\n45\r\n46\r\n25\r\n26<\/pre>\n
Monats- und Quartalsgrenzen<\/h2>\n
Public Function <\/span>MonatsErster(ByVal datDatum As Date<\/span>) As Date<\/span>\r\n MonatsErster = DateSerial(Year(datDatum), Month(datDatum), 1)\r\nEnd Function<\/span>\r\nPublic Function <\/span>MonatsLetzter(ByVal datDatum As Date<\/span>) As Date<\/span>\r\n MonatsLetzter = DateSerial(Year(datDatum), Month(datDatum) + 1, 0)\r\nEnd Function<\/span><\/pre>\nDebug.Print<\/span> MonatsLetzter(#4\/5\/2026#)\r\nDebug.Print<\/span> MonatsLetzter(#2\/5\/2026#)\r\nDebug.Print<\/span> MonatsLetzter(#2\/5\/2024#)\r\nDebug.Print<\/span> MonatsLetzter(#12\/5\/2026#)<\/pre>\n30.04.2026\r\n28.02.2026\r\n29.02.2024\r\n31.12.2026<\/pre>\n
Public Function <\/span>Quartal(ByVal datDatum As Date<\/span>) As Long<\/span>\r\n Quartal = Int((Month(datDatum) - 1) \/ 3) + 1\r\nEnd Function<\/span>\r\nPublic Function <\/span>QuartalsErster(ByVal datDatum As Date<\/span>) As Date<\/span>\r\n QuartalsErster = DateSerial(Year(datDatum), (Quartal(datDatum) - 1) * 3 + 1, 1)\r\nEnd Function<\/span>\r\nPublic Function <\/span>QuartalsLetzter(ByVal datDatum As Date<\/span>) As Date<\/span>\r\n QuartalsLetzter = DateSerial(Year(datDatum), Quartal(datDatum) * 3 + 1, 0)\r\nEnd Function<\/span><\/pre>\nDebug.Print<\/span> Quartal(#4\/5\/2026#)\r\nDebug.Print<\/span> QuartalsErster(#4\/5\/2026#)\r\nDebug.Print<\/span> QuartalsLetzter(#4\/5\/2026#)<\/pre>\n2\r\n01.04.2026\r\n30.06.2026<\/pre>\n
Zeitspannen über Mitternacht<\/h2>\n
Public Function <\/span>Zeitspanne(ByVal datVon As Date<\/span>, ByVal datBis As Date<\/span>) As Double<\/span>\r\n If <\/span>datBis < datVon Then<\/span> datBis = datBis + 1\r\n Zeitspanne = (datBis - datVon) * 24\r\nEnd Function<\/span><\/pre>\nDebug.Print<\/span> Zeitspanne(#10:00:00 PM#, #6:00:00 AM#)\r\nDebug.Print<\/span> Zeitspanne(#8:00:00 AM#, #4:30:00 PM#)<\/pre>\n8\r\n8,5<\/pre>\n
Stunden jenseits von 24 ausgeben<\/h2>\n
Public Function <\/span>StundenFormat(ByVal dblStunden As Double<\/span>) As String<\/span>\r\n Dim <\/span>lngGesamtminuten As Long<\/span>\r\n Dim <\/span>lngStunden As Long<\/span>\r\n Dim <\/span>lngMinuten As Long<\/span>\r\n If <\/span>dblStunden < 0 Then<\/span>\r\n Err.Raise 5, \"StundenFormat\", \"Negative Zeitspannen werden nicht unterstützt.\"\r\n End If<\/span>\r\n ' Kaufmaennisch auf volle Minuten runden\r\n lngGesamtminuten = Fix(dblStunden * 60 + 0.5)\r\n lngStunden = lngGesamtminuten \\ 60\r\n lngMinuten = lngGesamtminuten Mod<\/span> 60\r\n StundenFormat = Format$(lngStunden, \"00\") & \":\" & Format$(lngMinuten, \"00\")\r\nEnd Function<\/span><\/pre>\nDebug.Print<\/span> StundenFormat(7.5)\r\nDebug.Print<\/span> StundenFormat(41.25)\r\nDebug.Print<\/span> StundenFormat(0.75)\r\n07:30\r\n41:15\r\n00:45<\/pre>\n