Datum & Zeit: Spalten und Zusammensetzen
|
Datum & Zeit - Intern
Alle Kalkulations-Programme und VBA verwalten Datum und Zeit intern
als Gleitkomma-Zahlen im
→ Format Y1900.
Live-Y1900: JETZT()=?
•
Eine Y1900-Zahl entspricht - abgesehen von einem notorischen M$-Fehler - der Anzahl
der Tage seit 1900-01-01.
•
Die Zeit entspricht dem Nachkomma-Anzeil, d.h. jede Stunde = 1/24 = 0.04167
•
Alle Kalkulations-Programme bieten Standard-Funktionen, um aus einem Y1900-Datum
die Bestandteile (Jahr, Monat, Tag, Stunde, Minute, Sekunde) zu berechnen und
umgekehrt daraus ein Datum zusammenzusetzen.
•
Sowohl Kalkulations-Programme als auch VBA geben ungefragt die Zeit der lokalen
Zeitzone an und bieten derzeit leider keine Funktionen zur Umwandlung in die
Weltzeit UTC oder in eine andere Zeitzone.
♦
Details zu Datum und Zeit,
Y1900,
Unix-Timestamp,
Zeitzonen, Datum & Zeit
Server (NTP),
auf Linux,
auf Windows
|
Datum & Zeit - String
Die Anzeige einer beliebigen Zahl in einem Kalkulations-Programm wird durch das Format gesteuert.
Das
→ Standard ISO-8601 Format ist als einziges international eindeutig und wird von
LibreOffice und OpenOffice angeboten. Auf MS-Excel muss man je nach Version ein
Benutzer-definiertes Format angeben:
JJJJ-MM-TT hh:mm:ss
Das Live-Ergebnis der Funktion =JETZT(),
nach ISO-Standard formatiert:
YYYY-MM-TT hh:mm:ss
Ein Standard ISO_String ist besonders leicht zu verarbeiten: Alle Bestandteile haben eine
fixe Länge und befinden sich an fixen Positionen.
Visual Basic (VBA): Umwandlung eines Y1900-Datums in einen (ISO)-formatierten String:
iso = Format(Now(), "yyyy-mm-dd HH:MM:SS")
|
Im Beispiel rechts wird das aktuelle Datum + Zeit angezeigt
und in die Bestandteile gespalten.
•
Die Zellen A1 und A2 enthalten sie gleiche
Funktion, sind jedoch unterschiedlich formatiert (A1 nach
ISO-Standard, A2 als Standard-Zahl)
•
Die Standard-Funktionen in Spalte B liefern das gleiche Ergebnis
wie die VBA-Formeln in Spalte C (rechts werden in blauer Schrift
die Daten angezeigt).
|
| | A | B | C | Daten |
|---|
| 1 | =JETZT() | * |
|---|
| 2 | =JETZT() | * |
|---|
| 3 | Jahr | =JAHR($A$1) | =datim_split($A$1;0) | * |
|---|
| 4 | Monat | =MONAT($A$1) | =datim_split($A$1;1) | * |
|---|
| 5 | Tag | =TAG($A$1) | =datim_split($A$1;2) | * |
|---|
| 6 | Stunde | =STUNDE($A$1) | =datim_split($A$1;3) | * |
|---|
| 7 | Minute | =MINUTE($A$1) | =datim_split($A$1;4) | * |
|---|
| 8 | Sekunde | =SEKUNDE($A$1) | =datim_split($A$1;5) | * |
|---|
|
Spaltung eines Standard-Datum-Strings:
Diese Funktion hat nur geringen praktischen Wert, da man die gleichen Daten
mit den Standard Kalkulations-Formeln erhält.
•
Die Funktion erwartet 2 Argumente:
y1900...Eine Y1900 Gleitkomma-Zahl
index...Ganze Zahl 0...5 zur Auswahl der
gewünschten Elements.
•
Aus dem Datum y1900 wird mit der Standard
VBA-Funktion Format() ein ISO-String erzeugt.
•
Der String iso wird an seinem Leerzeichen in das
Array isoa mit den 2 Elementen Datum und Zeit gespalten.
•
Wenn index<3 wird ein Datum-Bestandteil gesucht.
Das Element isoa(0) wird in 3 Teile gespalten und je
nach index Jahr, Monat oder Tag zurückgegeben.
•
Wenn index>=3 wird ein Zeit-Bestandteil gesucht.
Das Element isoa(1) wird in 3 Teile gespalten und je
nach index Stunde, Minute oder Sekunde zurückgegeben.
|
Visual Basic
(VBA) Funktion zur Aufspaltung eines
ISO-8601 Strings.
Function datim_split( _
Optional y1900 As Double = -1, _
Optional index As Integer = 0) As Integer
Dim idt As Integer
Dim iso, isoa() As String
If y1900 < 0 Then y1900 = Now()
If index < 0 Or index > 5 Then index = 0
iso = Format(y1900, "yyyy-mm-dd HH:MM:SS")
isoa = Split(iso, " ")
If index < 3 Then
isoa = Split(isoa(0), "-")
idt = isoa(index)
isoa = Split(isoa(1), ":")
idt = isoa(index - 3
End If
datim_split = idt
End Function
|
Im Beispiel rechts werden alle 6 Datum+Zeit Elemente als Bereich
an die beiden Funktionen übergeben.
•
Funktion datim_join_y1900() gibt eine Y1900-Zahl zurück,
die man als Datum und/oder Zeit formatieren und mit der man rechnen kann.
•
Funktion datim_join_iso() gibt einen Standard-String zurück.
|
| | A | B | C |
|---|
| 1 | **** | ** | ** |
|---|
| 2 | 00 | 00 | 00 |
|---|
| 3 | =datim_join_y1900(A1:C2) | * |
|---|
| 4 | =datim_join_iso(A1:C2) | YYYY-MO-DD HH:MI:SS |
|---|
|
Berechnung von Y1900 aus den Bestandteilen
Die Funktion datim_join_y1900() erwartet einen
Bereich datim_range von maximal 6 Zellen als Argument.
•
Der Bereich wird zeilenweise verarbeitet, d.h. die Teile können sich in einer
Zeile oder in einer Spalte oder in einem rechteckigen Bereich befinden,
sie müssen lediglich hierarchisch Jahr -> Sekunde angeordnet sein.
Wenn der Bereich kleiner ist, dann werden Standardwerte verwendet.
•
In das Array idt der Datum+Zeit Elemente werden
Standardwerte eingetragen.
•
Danach werden die Zellen des Bereichs datim_range in einer
Schleife durchlaufen. Zulässige Daten werden in das Array idt
übernommen, unzulässige durch die aktuellen Daten ersetzt.
•
Zuletzt wird das Ergebnis in der Gleitkomma-Variablen y1900
berechnet und zurückgegeben.
|
Visual Basic (VBA) Funktion
zur Berechnung einer Y1900 Gleitkomma-Zahl aus den Bestandteilen von Datum und Zeit.
Function datim_join_y1900(datim_range As Range) As Double
Dim d, i, imax, idt(5) As Integer
Dim y1900 As Double
idt(0) = Year(Now())
idt(1) = 1
idt(2) = 1
For i = 3 To 5
idt(i) = 0
Next
imax = datim_range.Count - 1
If imax > 5 Then imax = 5
For i = 0 To imax
d = Int(datim_range(i + 1).Value)
Select Case i
Case 0
If d < 1900 Then d = Year(Now())
Case 1
If d < 1 Or d > 12 Then d = Month(Now())
Case 2
If d < 1 Or d > 31 Then d = Day(Now())
Case 3
If d < 0 Or d > 23 Then d = Hour(Now())
Case 4
If d < 0 Or d > 59 Then d = Minute(Now())
Case 5
If d < 0 Or d > 59 Then d = Second(Now())
End Select
idt(i) = d
Next
y1900 = DateSerial(idt(0), idt(1), idt(2))
y1900 = y1900 + TimeSerial(idt(3), idt(4), idt(5))
datim_join_y1900 = y1900
End Function
|
Erzeugung eines ISO-Strings aus den Elementen
Die Funktion datim_join_iso() erwartet einen
Bereich datim_range von maximal 6 Zellen als Argument.
• Der Bereich wird zeilenweise verarbeitet, so wie
bei Funktion datim_join_y1900() im Absatz ↑ oberhalb.
•
In das Array idt der Datum+Zeit Elemente werden
Standardwerte eingetragen.
•
Danach werden die Zellen des Bereichs datim_range in einer
Schleife durchlaufen. Hier wurde auf eine Korrektur unzulässiger Daten verzichtet.
•
Da ein ISO-String 3 verschiedene Trennzeichen verwendet, wird der
Ausgabe-String iso nicht mit Funktion Join()
sondern schrittweise aus den Elementen von Array idt aufgebaut.
|
Visual Basic (VBA) Funktion
zur Erzeugung eines ISO-8601 Strings aus den Bestandteilen von Datum und Zeit.
Function datim_join_iso(datim_range As Range) As String
Dim d, i, imax, idt(5) As Integer
Dim iso As String
idt(0) = Year(Now())
idt(1) = 1
idt(2) = 1
For i = 3 To 5
idt(i) = 0
Next
imax = datim_range.Count - 1
If imax > 5 Then imax = 5
For i = 0 To imax
d = Int(datim_range(i + 1).Value)
idt(i) = d
Next
iso = Right("0000" & CStr(idt(0)), 4)
For i = 1 To 5
Select Case i
Case Is < 3
iso = iso & "-"
Case 4
iso = iso & " "
Case Else
iso = iso & ":"
End Select
iso = iso & Right("00" & CStr(idt(i)), 2
Next
datim_join_iso = iso
End Function
|
VBA
Die gezeigte VBA-Funktion arbeitet allerdings wesentlich einfacher und übersichtlicher.
