Datum & Zeit mit PHP

System-Daten, Rechnen mit Datum & Zeit

Auf dieser Seite finden sie einige Funktionen, die PHP zum Thema 'Datum und Zeit' bietet. Algorithmen zur Umrechnung finden sie auf der Seite IT-Datenformate für Datum & Zeit
PHP PHP Hypertext Processor
Modul Date Funktionen und Konstanten des PHP-Moduls Date
time() UNIX-Timestamp der aktuellen Systemzeit
mktime() Erzeugung eines UNIX-Timestamps aus den Bestandteilen
getdate() Aufspaltung eines UNIX-Timestamps in die Bestandteile
strftime() Bequeme Formatierung von Datum und Zeit
date() Bequeme Formatierung von Datum und Zeit
microtime() Genaue Zeitmessung
Datei-Zeiten Erzeugung, letzte Änderung. letzter Zugriff
Modul Calendar Die Funktionen des PHP-Moduls Calendar
Zeit-Zone Wichtige Einstellung für PHP Zeit-Funktionen
● Sonne Aufgang, Untergang und Tageslänge für jeden Ort der Welt
Verwandte Themen Datum & Zeit (Standards),   Entwicklung mit C/C++, Javascript, Perl, SQL, VBA,   Betriebssysteme Linux, Windows (Konsole + Cygwin)

PHP-Modul   Date
Fast alle hier vorgestellten Funktionen sind im PHP-Modul Date enthalten. Dieses Modul ist in jeder Standard PHP-Version enthalten, hat sich jedoch rasch entwickelt. Neuere Versionen bieten wesentlich mehr praktisch nutzbare Funktionen.

● Setzen sie in Webseiten, die zum späteren Upload bestimmt sind, nur solche Funktionen ein, die von der PHP-Version ihres Providers unterstützt werden.

● Am eigenen Webserver kann das Angebot dieses Moduls natürlich voll ausgeschöpft werden. 		Live-PHP: Version 5.3.3-7+squeeze9
Die meisten dieser globalen Konstanten sind ab PHP Version>=5.1.1 definiert.
Jene Konstanten, deren Name mit DATE_ beginnt, dienen zur Steuerung bestimmter standardisierter Datum & Zeit-Strings.
Jene Konstanten, deren Name mit SUNFUNCS_ beginnt, dienen zur Steuerung der → Sonnen-Aufgangs- und Untergangs-Funktionen. 		Live-PHP: Ausgewählte Konstanten des Moduls Date
Die rechts gezeigten Variablen der PHP → Konfigurations-Datei php.ini steuern die lokale Zeitzone sowie die → Sonnen-Aufgangs- und Untergangs-Funktionen.
♦ Details zur PHP-Konfiguration
get_cfg_var('date.default_latitude') =
get_cfg_var('date.default_longitude') =
get_cfg_var('date.sunrise_zenith') =
get_cfg_var('date.sunset_zenith') =
get_cfg_var('date.timezone') = Austria/Vienna

Funktion time() liefert einen UNIX-Timestamp der aktuellen Systemzeit

► Ein UNIX-Timestamp entspricht der
Anzahl Sekunden seit 1970-01-01 Weltzeit UTC
► Timestamps eignen sich ausgezeichnet zum Rechnen mit Datum und Zeit.
► Zur Ausgabe wird ein Timestamp in einen Text (String) umgewandelt, z.B. mit ↓ PHP-Funktion strftime()
► PHP verwendet die Systemzeit des Server-PC.
► Ein UNIX-Timestamp ist weltweit eindeutig. Die Angabe erfolgt in Weltzeit UTC, daher spielen Zeitzonen, Sommerzeit etc. keine Rolle.
► Im Jahr 2038 (derzeitige Grenze für 32-Bit-PC) wird es nur mehr (mindestens) 64-Bit-PC geben. Heutige 32 Bit reichen zwar nur für 68 Jahre UNIX-Timestamp, 64 Bit dagegen für beruhigende 292 Milliarden Jahre . .
$uts = time();
print "UNIX-Timestamp = $uts";
Live-Daten des Webservers:
UNIX-Timestamp = 1337521999

das entspricht
2012-05-20 15:53:19   Weltzeit UTC   bzw.
2012-05-20 15:53:19   Lokalzeit CEST

Funktion mktime() liefert einen UNIX-Timestamp aus den Bestandteilen

Mit der PHP POSIX-Funktion mktime() wird ein UNIX-Timestamp aus den einzelnen Bestandteilen in Server-Lokalzeit zusammengesetzt.
Achtung auf die unsystematische Reihenfolge nach US-Vorliebe !
mktime($hour,$min,$sec,$mon,$day,$year)
Stunden (0..23)->$hour
Minuten (0..59)->$min
Sekunden (0..59)->$sec
Monat (1..12)->$mon
Tag (1..31)->$day
Jahr (1970..3000)->$year
SoZeit (-1,0,1)->$dls
Einige Versionen akzeptierten auch ein zusätzliches Argument $dls für die Sommerzeit: Das ist bei einem korrekt eingestellten Server nicht notwendig und sollte entfallen. 		Beispiel: Timestamp von heute 00:00:00, Differenz in Sekunden seit Mitternacht und vergangener Tages-Teil in %.
$uts00 = mktime(0,0,0,5,20,2012);
$dif = $uts - $uts00;
$tag_teil = ($dif/864).' %';

Live-Daten des Webservers:
$uts00 = 1337464800
$dif = 57199
$tag_teil = %
 Aktueller Tages-Anteil
▲ UNIX-Timestamps eignen sich besonders gut zur Berechnung von Datum- und Zeit-Differenzen.
• Achtung: Es gibt Hinweise, dass je nach Betriebssystem eventuell abweichende Regeln für die Reihenfolge der mktime()-Argumente gelten - überprüfen sie die Funktion ! 		Das Kreis-Diagramm ist ein kleines Beispiel für die Möglichkeiten, mit PHP dynamische → Live-Grafik herzustellen.

Funktion getdate() zur Aufspaltung eines UNIX-Timestamps

Mit der PHP-Funktion getdate() wird ein UNIX-Timestamp in die einzelnen Bestandteile in Server-Lokalzeit zerlegt. Ohne Angabe eines Timestamps wird die aktuelle Systemzeit verwendet.
$uts = time();
$ga = getdate($uts);
Die Funktion liefert ein Array (hier $ga ) mit ganzzahligen Elementen.
Dabei wird Lokalzeit verwendet. Um Weltzeit zu berechnen, kann man z.B. den Zeitzonen-Unterschied aus Funktion date() verwenden.
Live-Daten des Webservers:
$ga['year'] = 2012
$ga['mon']  = 5
$ga['mday'] = 20
$ga['hours'] = 15
$ga['minutes'] = 53
$ga['seconds'] = 19
Weniger brauchbar sind diese Daten:
▼ Die Namen von Monat und Wochentag sind US-kulturspezifisch.
▼ Die Wochentags-Nummer (wday, 0..6 ab Sonnteg) entspricht nicht der → ISO-Norm sondern dem lokalen Gebrauch in den USA: Der Wert für Sonntag ist unterschiedlich.
▼ Der Tag des Jahres (yday, 0..365) entspricht nicht der → ISO-Norm. Immerhin erhält man den ISO-Tag durch einfache Addition von +1.
$ga['month'] = May
$ga['weekday'] = Sunday
$ga['wday'] = 0
ISO-dow = 7
$ga['yday'] =140
ISO-doy = 141

Funktion strftime() für die Formatierung von Datum und Zeit

Die Standard POSIX-Funktion strftime() dient in PHP, Perl und den meisten anderen modernen Programmiersprachen zur Erzeugung von Strings (Text) aus Datum und Zeit.

Als Beispiel die Erzeugung eines Strings nach dem → ISO-8601-Standard für Datum und Zeit.
# $s = '%Y-%m-%d %X';
$s = '%Y-%m-%d %H:%M:%S';
$iso = strftime($s,time());
print "ISO-8601 = $iso";
Live-Daten des Webservers:
ISO-8601 = 2012-05-20 15:53:19"
► Die Funktion verwendet als Argumente einen Format-String und einen Timestamp, sie liefert einen String.

► Der Format-String besteht aus beliebigen Zeichen (die so wiedergegeben werden wie eingesetzt) und Platzhaltern.
Die Platzhalter werden durch die passenden Datum- und Zeit-Daten ersetzt. 		► Die einfachen und wichtigen Platzhalter werden immer unterstützt (sichere Variante).
▼ Die komplexen, sprach- und kulturabhängigen Platzhalter werden je nach System und Version unterschiedlich oder gar nicht unterstützt.

► Funktion strftime() liefert die Lokalzeit des Servers - Wenn die Zeitzone korrekt eingestellt wurde.
Liste der Platzhalter: (ohne Gewähr, mit Live-Wert)
■ Datum:
► Jahrhundert
%C - Jahrhundert, 2 Stellen (00..99) - 20
(nach korrekter Rechnung ist das allerdings das 21. Jahrhundert)
► Jahr
%Y - Jahr, 4 Stellen - 2012
%y - Jahr, 2 Stellen - 12
► Monat
%m - Monat (01..12) - 05
%h - US-Monat, 3 Zeichen - May
%B - US-Monatsname, var.Zeichen - May
► Tag des Monats
%d - Tag des Monats (01..31) - 20
%e - Tag des Monats ( 1..31) - 20
► ISO-Tag des Jahres (doy)
%j - Tag des Jahres (001..366) - 141
► Tag der Woche (dow)
%u - ISO-Tag der Woche (1=Mo..7=So) - 7
%w - US-Tag der Woche (0=So..6=Sa) - 0
%a - US-Wochentag, 3 Zeichen - Sun
%A - US-Wochentag, var.Zeichen - Sunday
► Kalenderwoche (Woche des Jahres, KW, woy)
%V - ISO-KW (01..53). Ab Montag - 20
%W - KW (00..53). Ab Montag - 20
%U - US-KW (01..54). Ab Sonntag - 21
♦ Details zur Kalenderwoche 		■ Zeit:
► Stunde
%H - Stunde (00..23) - 15
%I - US-Stunde (01..12) - 03
%p - US-Halbtag (AM,PM) - PM
► Minute
%M - Minute (00..59) - 53
► Sekunde
%S - Sekunde (00..59) - 19
► Zeitzone
%Z - Zeitzone - CEST

■ Zusammengesetzte Strings
%D - US-Datum - 05/20/12
%x - US-Datum - 05/20/12
%T - Zeit (hh:mi:ss) - 15:53:19
%X - Zeit (hh:mi:ss) - 15:53:19
%R - Zeit (H:M) - 15:53
%r - US-Zeit - 03:53:19 PM
%c - US-Datum und Zeit:
Sun May 20 15:53:19 2012

■ Sonderzeichen
%% - Prozent- Zeichen %
%n - neue Zeile
%t - Tabulator

Funktion date() für die Formatierung von Datum und Zeit

Die Funktion date() liefert die gleichen Angaben wie strftime(), mit etwas unterschiedlicher Syntax (Grammatik). Ohne Angabe des Timestamps wird die aktuelle System-Zeit verwendet.

Als Beispiel die Erzeugung eines Strings nach dem → ISO-8601-Standard für Datum und Zeit.
Funktion date() liefert die Lokalzeit - Richtig, wenn die Zeitzone korrekt eingestellt ist.
$s = 'Y-m-d H:i:s';
$iso = date($s,time());
print "ISO-8601 = $iso";
Live-Daten des Webservers:
ISO-8601 = 2012-05-20 15:53:19
Zeitzone und Differenz zwischen UTC und Lokalzeit:
In Mitteleuropa gilt die CET (Central European Time, MEZ) bzw. im Sommer die CEST, in Osteuropa die EET, in Westeuropa die WET (identisch mit der Weltzeit UTC).

♣ date('Z') liefert den Abstand der (Server)-Zeitzone in Sekunden als ganze Zahl und eignet sich daher am besten zum Rechnen.
print 'date(O) = '.date('O');   // +-hhmi
print 'date(T) = '.date('T');   // string
print 'date(Z) = '.date('Z');   // sec
Live-Daten:
date('O') = +0200
date('T') = CEST
date('Z') = 7200

Zeitzone für Javascript:

Auf manchen Windows-Systemen und für manche Browser wird die Zeitzone falsch berechnet. Im lokalen Netzwerk (wo Server und alle Client-PC die gleiche Zeitzone haben) übergibt man daher den Abstand zur Weltzeit UTC von PHP an eine Javascript-Variable (hier an tzos).
♦ Details zu Datum & Zeit in Javascript
<script type="text/javascript">
var tzos=<?php print date('Z'); ?>;
// ...
</script>
Javascript erhält nicht das PHP-Programm sondern die fertige Programm-Zeile:
var tzos=7200;

Spezial-Formate

Ab PHP >=5.1 sind einige Konstanten zur Formatierung verfügbar. Darunter sind einige praktische Konstanten zur Formatierung z.B. von Cookies oder → RSS-Angaben.
Details im Original PHP-Manual unter Funktion date() 		Die allgeimeine Form lautet
print date(DATE_*,$uts);
Der * wird durch eine der zulässigen Konstanten ersetzt. Wenn man das 2. Argument (Timestamp) weglässt, wird die aktuelle Zeit des Servers verwendet. Nachfolgend einige dieser aktuellen Beispiele:
date(DATE_ATOM) = 2012-05-20T15:53:19+02:00
date(DATE_COOKIE) = Sunday, 20-May-12 15:53:19 CEST
date(DATE_ISO8601) = 2012-05-20T15:53:19+0200
date(DATE_RFC1036) = Sun, 20 May 12 15:53:19 +0200
date(DATE_RFC1123) = Sun, 20 May 2012 15:53:19 +0200
date(DATE_RFC2822) = Sun, 20 May 2012 15:53:19 +0200
date(DATE_RFC3339) = 2012-05-20T15:53:19+02:00
date(DATE_RFC822) = Sun, 20 May 12 15:53:19 +0200
date(DATE_RFC850) = Sunday, 20-May-12 15:53:19 CEST
date(DATE_RSS) = Sun, 20 May 2012 15:53:19 +0200
date(DATE_W3C) = 2012-05-20T15:53:19+02:00

Genaue Zeitmessung mit Funktion microtime()

Manchmal ist es notwendig, Zeiten genauer als auf  1 sec zu messen. In solchen Fällen geht es meistens um eine Differenz von Zeitpunkten.
► PHP-Funktion microtime() liefert einen String von 2 Elementen, durch Leerzeichen getrennt:
Sekundenbruchteil seit der letzten vollen Sekunde
UNIX-Timestamp in Sekunden Weltzeit (UTC) seit 1970-01-01
Die beiden Teile des Strings werden mit Hilfe von Funktion preg_split() in die Elemente eines Array (hier $mt1a ) getrennt.
$mt1 = microtime();
$mt1a = preg_split('/ /',$mt1);
Live-Daten an dieser Stelle der Webseite
$mt1 = "0.37634000 1337521999"
$mt1a[0] = 0.37634000   Sekundenbruchteil
$mt1a[1] = 1337521999   ganze Sekunden
▶ Unterscheiden sie zwischen der Zeit-Messung mit PHP oder Javascript !

PHP misst die Zeit am Server, d.h. für die Ausführung des PHP Script-Programms.
Server-Zeit ist teuer und muss sparsam eingesetzt werden. 		Javascript misst die Zeit an (ihrem) Client-PC, d.h. für den Aufbau der Webseite aus dem von Server+PHP gelieferten HTML Quelltext.
Client-PCs sind selten ausgelastet. Wenn es möglich ist, Programm-Teile vom Server auf die Clients zu verlagern, wird der Server-Zugriff für alle Clients schneller !
Beispiel:
Die Zeit zum Aufbau dieser Webseite (bis hierher) am Server wird durch 2xiges Messen mit microtime() ermittelt: Am Anfang der Seite $mt0 und an dieser Stelle $mt2
Die Differenz ergibt den Zeitaufwand, hier berechnet in Millisekunden (ms).

Es ist kein Zufall, dass die Funktion microtime() ihre Daten in 2 getrennten Variablen liefert: Eine einzige Variable wäre nicht genau genug.
Der 2. Teil (UNIX-Timestamp in sec) bleibt innerhalb eines Programms (= einer Webseite) meistens gleich.
Messung am Seiten-Anfang:
$mt0 = microtime();
Messung an dieser Stelle:
$mt2 = microtime();
Berechnung der Differenz:
$mt0a = preg_split('/ /',$mt0);
$mt2a = preg_split('/ /',$mt2);
$dt = $mt2a[1]-$mt0a[1]+$mt2a[0]-$mt0a[0];
$dt *= 1000;
Live-Daten:
$mt0 = "0.36209900 1337521999"
$mt2 = "0.37639100 1337521999"
$dt = 14.292 ms
Entwicklung:
Die Messung kleiner Zeit-Differenzen ist für EntwicklerInnen wichtig: So kann man Live die Zeit zur Ausführung von Programmen messen und z.B. verschiedene Algorithmen miteinander vergleichen.
Test-Programme werden zur Messung in einer Schleife mehrmals (z.B. 1000mal) ausgeführt.
Die gemessene Zeit durch die Anzahl der Schleifen-Durchgänge dividiert. So wird das Ergebnis unabhängig von zufälligen Schwankungen der Prozessor-Last.

Datei - Informationen
Zur Live-Demonstration wird die Datei datum_zeit.dat verwendet.
► Falls sie nicht existiert, wird sie von dieser Webseite neu erzeugt.
► In jedem Fall wird zur Änderung eine Text-Zeile (mit dem aktuellen Datum) an die Datei angehängt. Die erste Text-Zeile enthält daher das Erstellungsdatum, jede weitere Zeile ein Änderungsdatum.
► Am Ende dieser Webseite (s.u.) wird bei jedem Aufruf eine weitere Zeile (das aktuelle Datum) als Änderung hinzugefügt.
$path = 'test/datum_zeit.dat';
Datei datum_zeit.dat existiert
Inhalt der Test-Datei:
2012-05-20 09:33:12
2012-05-20 09:33:12
2012-05-20 09:35:33
2012-05-20 10:03:39
2012-05-20 10:06:47
2012-05-20 10:07:23
2012-05-20 10:10:54
2012-05-20 12:25:52
2012-05-20 13:41:43

► Für jedes Verzeichnis (Ordner) und jede Datei werden vom Dateisystem einige Datum & Zeit - Daten geführt, üblicherweise Erstellungszeit ( creation ), letzte Änderung ( modification ) und letzte Verwendung ( access ). Allerdings scheint es schwierig, die Erstellungszeit zu erhalten. Die 3 nachfolgend gezeigten PHP-Funktionen verwenden als Argument den Datei-Pfad, weitere 2 Funktionen verwenden ein Datei-Handle.

fileatime()

PHP-Funktion fileatime() liefert einen UNIX-Timestamp des letzten Zugriffs auf eine Datei. Mit ↑ Funktion strftime() wird der Timestamp zu einem ISO-String decodiert. Der dabei verwendete Format-String $fmt wird auch bei allen weiteren Beispielen dieses Kapitels eingesetzt.
$at = fileatime($path);
clearstatcache();
$fmt = '%Y-%m-%d %T';
$as = strftime($fmt,$at);
Live--PHP:
$at = 1337521999
$as = 2012-05-20 15:53:19

filectime()

PHP-Funktion filectime() liefert einen UNIX-Timestamp der letzten Änderung einer Datei.
$ct = filectime($path);
clearstatcache();
$cs = strftime($fmt,$ct);
Live--PHP:
$ct = 1337514103
$cs = 2012-05-20 13:41:43

filemtime()

PHP-Funktion filemtime() liefert einen UNIX-Timestamp der letzten Änderung einer Datei.
$mt = filemtime($path);
clearstatcache();
$ms = strftime($fmt,$mt);
Live--PHP:
$mt = 1337514103
$ms = 2012-05-20 13:41:43

stat()

Die PHP-Funktionen stat(), fstat() liefern die gleichen Arrays zur Datei-Information.
stat() verwendet einen Datei-Pfad (String) als Argument, fstat() verwendet ein file-handle, wie es von Funktion fopen() zurückgeggeben wird.
$sta = stat($path);
foreach($sta as $nam=>$val) {
print "$nam = $val <br />\n";
}
clearstatcache();
Live--PHP:
dev = 65040
ino = 776494924
mode = 33188
nlink = 1
uid = 3354
gid = 1012
rdev = 0
size = 180
atime = 1337521999
mtime = 1337514103
ctime = 1337514103
blksize = 4096
blocks = 8
PHP-Funktion clearstatcache() gibt die Resourcen wieder frei, welche durch Anfragen wie die hier gezeigten benötigt wurden.
clearstatcache();
Änderung der Test-Datei:
Zur Demonstration wird eine Zeile mit dem aktuellen Datum hinzugefügt. Bei Erreichen einer eingestellten maximalen Länge wird die Datei gelöscht.

♦ Details zum Thema Dateien und PHP.
filesize($path) = 180 byte
Neuer Eintrag = 2012-05-20 15:53:19

Zeit-Zone
PHP kann verschiedene Methoden verwenden, um die gewünschten Daten aus einer Zeitzonen-Datei auszuwählen. Die Einstellung der Zeitzone kontrolliert man am besten mit PHP:
print 'tz='.getenv('TZ');
print 'dtz='.ini_get('date.timezone');
 Die meisten Datum & Zeit-Funktionen ergeben eine Warnung, wenn diese Daten nicht bekannt sind.
So provoziert man eine Warnung :
set_cfg_var('error_reporting','2047');
set_cfg_var('display_errors',1);
$iso = strftime('%Y-%m-%d %H:%M:%S',time());
print "iso=$iso";
Wenn die Zeitzone unbekannt ist, erfolgt eine Warnung.
Dann sollten sie eine der beschriebenen Maßnahmen setzen.

Zeit-Zonen-Daten

Alle hier vorgestellten Methoden erwarten als Daten einen String, bestehend aus Zone/Stadt, z.B. "Europe/Berlin" oder "Europe/Vienna" oder "Europe/Zurich" 		► Jedes Linux-System enthält eine umfangreiche Zeitzonen-Datei.
Die Namen der Zonen finden sie im Linux-Verzeichnis
/usr/share/zoneinfo
Die Namen der Städte finden sie im Verzeichnis der jeweiligen Zone.
► Auf Windows enthält PHP seine eigene Zeitzonen-Datei (Zulässige Werte im PHP-Manual / Anhang)
► Das PECL-Modul timezonedb sollten sie (nur) dann installieren, wenn sie eine alte PHP-Version verwenden, und trotzdem eine aktuelle Zeitzonen-Datei brauchen.

PHP-Konfiguration

Diese Methode ist am eigenen Linux-Apache-PHP-Server zu bevorzugen.
Die Konfigurations-Datei befindet sich normalerweise hier:
/etc/php5/apache2/php.ini
Suchen sie das Modul [Date] und aktivieren bzw. ändern sie die Eintragung
date.timezone="Europe/Vienna"
Nach Neustart des Apache-Servers kontrollieren sie mit PHP
print 'tz='.ini_get('date.timezone');
Tragen sie in php.ini optional nach der Zeitzone auch die Orts-Koordinaten ein, z.B. für Wien
date.default_latitude=48.208
date.default_longitude=16.373
In diesem Fall erhalten sie z.B. die Daten für Sonnen-Aufgang und Untergang mit den PHP-Funktionen
$sunr = date_sunrise(time());
$suns = date_sunset(time());
print "sunrise = $sunr, sunset = $suns";
♦ Details zu den PHP Sonnen-Funktionenund zur PHP-Konfiguration

Umgebungs-Variable TZ

Diese Methode wird am eigenen Linux-Server angewendet, am besten zusätzlich zur PHP-Konfiguration.
Um diese Variable beim Linux-Systemstart automatisch zu exportieren, erstellen sie eine Datei
/etc/profile.locale
und tragen z.B. diese Zeile ein
export TZ="Europe/Vienna"
Nach System-Neustart öffnen sie eine Shell-Konsole und überprüfen die Liste der exportierten Umgebungs-Variablen mit Befehl
# export
Auf Windows ist es sinnvoll, eine Umgebungs-Variable TZ neu zu erstellen und den gewünschten Wert genauso wie auf Linux einzutragen.
Eine Liste der von PHP unterstützten Zonen finden sie im Anhang (Appendix) des Original PHP-Manuals.
♦ Details zur Verwaltung von Windows Umgebungs-Variablen.

Kontrolle mit PHP:
print 'tz='.getenv('TZ');

Live-Konfiguration

Auf den Server ihres Providers haben sie keinen Einfluss. Sie können jedoch die Konfigurations-Variable Live mit PHP ändern (Beispiel rechts).
Die Wirkung reicht allerdings nur bis zum Datei-Ende. Diese Methode muss daher auf jeder Seite angewendet werden, welche Datum & Zeit-Funktionen verwendet.
ini_set('date.timezone','Europe/Vienna');
print 'tz='.ini_get('date.timezone');

PHP-Funktion date_default_timezone_set()

Diese Funktion ist ab PHP-Version>=5 verfügbar. Sie setzt die Zeitzone auf den angegebenen Wert.
Auch die Wirkung dieser Funktion reicht nur bis zum Datei-Ende.
if(function_exists('date_default_timezone_set')) {
date_default_timezone_set('Europe/Vienna');
print 'tz='.date_default_timezone_get();
}
Meldungen abschalten
Diese Methode behebt nicht die Ursache, sondern nur die Wirkung des Problems. Sie wird nur zur Vollständigkeit angeführt.
set_cfg_var('error_reporting','0');
set_cfg_var('display_errors',0);
Anschliessend werden keine Meldungen mehr angezeigt.
♦ Details zur PHP-Umgebung. ♦ Details zum Thema PHP & Fehlermeldungen und Warnungen.

Warte-Zeit
Normalerweise versucht man, den Ablauf eines Programms möglichst zu beschleunigen. In seltenen Fällen soll ein Programm während der Ausführung warten: Dazu kann man die Funktion sleep() verwenden.
Die Funktion sleep() unterbricht die Ausführung des Programms für die angegebene Anzahl von Sekunden. Beispiel:
sleep(10);
wartet 10 Sekunden lang und führt danach alle folgenden Anweisungen aus.
Die maximale Wartezeit ist durch die PHP → Konfigurations-Variable max_execution_time begrenzt.
Spätestens nach Ablauf dieser Zeit wird jedes PHP Programm 'gewaltsam' beendet. 		An den Client wird die bis dahin erzeugte Ausgabe gesendet - in diesem Fall meist eine nur teilweise fertiggestellte Webseite.

Zum Inhaltsverzeichnis Homepage von PS-Trainer   >   Entwicklung   >   PHP   >   Datum & Zeit   |   Datum & Zeit - Standards
Letzte Änderung dieser Seite: 2011-12-01 09:16:19