Archiv für die Kategorie „PHP“
PHP: Einfacher Foto-Upload / Foto-Upload-Script
Hier demonstrieren wir euch kurz und knapp, wie man einen einfachen Upload für Benutzer-Fotos bewerkstelligt.
So könnte das Upload-Formular (HTML) aussehen:
<form name="foto" method="post" action="upload.php" enctype="multipart/form-data"> <p> <b>Foto-Upload:</b><br /> <input type="file" name="pict" /> <input type="submit" name="button" value="Hochladen" /> </p> </form>
Und so sieht das einfache und eher funktioniell aufgebaute PHP-Script (upload.php) für den Foto-Upload aus:
$user['id'] = 1; // Die Id-Nummer des gerade eingeloggten Benutzers
$uploaddir = "uploads/userpics/"; // Der Ordner in den die hochgeladenen Bilder gespeichert werden sollen
// Prüfen ob Bild hochgeladen
if (isset($_FILES['pict']['tmp_name'])) {
// Prüfen ob es sich um ein Bild handelt
if ($size=getimagesize($_FILES['pict']['tmp_name'])) {
$fileends = explode(".",$_FILES['pict']['name']);
$fileend = $fileends[count($fileends) - 1];
$filepath = $uploaddir.$user['id']."_".time().".".$fileend;
if(!move_uploaded_file($_FILES['pict']['tmp_name'],$filepath)){
die ("Die hochgeladene Datei konnte nicht in den Upload-Order verschoben werden!");
} else {
// Altes Foto löschen
if (isset($user['foto']) AND $user['foto'] != "" AND file_exists($user['foto'])) {
unlink ($user['foto']);
}
// Datenbank aktualisieren
mysql_query("UPDATE users SET foto = '".$filepath."' WHERE id = '".$user['id']."';");
$user['foto'] = $filepath;
}
} else {
die ("Bei der hochgeladenen Datei handelt es sich nicht um eine Bild-Datei");
}
} else {
die ("Es wurde keine Datei zum Upload ausgewählt, oder der Upload ist gescheitert!");
}
echo "Das ausgewählte Foto wurde erfolgreich hochgeladen und gespeichert.";
Zu Beachten: Bei diesem Script wird die Benutzer-Datenbank aktualisiert.
Die dazu nötige Datenbank-Tabelle hat den Namen “users” mit mindestens den Feldern “id” und “foto”.
PHP: Berechnung des Alters, bzw. Jahre zwischen zwei Datumsangaben
Mit folgender Funktion kann das Alter einer Person anhand seines Geburtsdatums berechnet werden:
function alter($d_or_timestamp="", $m="", $y=""){
if ($d_or_timestamp > 31) {
$d = date("d", $d_or_timestamp);
$m = date("m", $d_or_timestamp);
$y = date("Y", $d_or_timestamp);
} else { $d = $d_or_timestamp; }
if ($d == "" OR $d == 0) { $d = date("d", time()); }
if ($m == "" OR $m == 0) { $m = date("m", time()); }
if ($y == "") { $y = 0; }
$jahre = date("Y", time()) - $y;
if ($m > date("m", time())) { $jahre--; }
elseif ($m == date("m", time()) AND $d > date("d", time())) { $jahre--; }
return $jahre;
}
Mit dieser Funktion kann die Anzahl Jahre zwischen zwei Datumsangaben berechnet werden:
function jahre($d1_or_timestamp1, $m1_or_timestamp2="", $y1="", $d2="", $m2="", $y2=""){
if ($m1_or_timestamp2 == "") { $m1_or_timestamp2 = time(); }
if ($d1_or_timestamp1 > 31) {
$d1 = date("d", $d1_or_timestamp1);
$m1 = date("m", $d1_or_timestamp1);
$y1 = date("Y", $d1_or_timestamp1);
} else {
$d1 = $d1_or_timestamp1;
$m1 = $m1_or_timestamp2;
}
if ($m1_or_timestamp2 > 12) {
$d2 = date("d", $m1_or_timestamp2);
$m2 = date("m", $m1_or_timestamp2);
$y2 = date("Y", $m1_or_timestamp2);
}
if ($d1 == "" OR $d1 == 0) { $d1 = 1; }
if ($m1 == "" OR $m1 == 0) { $m1 = 1; }
if ($y1 == "") { $y1 = 0; }
if ($d2 == "" OR $d2 == 0) { $d2 = date("d", time()); }
if ($m2 == "" OR $m2 == 0) { $m2 = date("m", time()); }
if ($y2 == "" OR $y2 == 0) { $y2 = date("Y", time()); }
$jahre = $y2 - $y1;
if ($m1 > $m2) { $jahre--; }
elseif ($m1 == $m2 AND $d1 > $d2) { $jahre--; }
return $jahre;
}
PHP :: Sessions ($_SESSION)
Die Sessions unter PHP (zu Deutsch: Sitzungen) sind eindeutige Identifikations-Schlüssel.
Wenn ein Benutzer auf einer Webseite einloggt, so werden seine Logindaten mit den in der Datenbank gespeicherten Daten abgeglichen. Sind die Daten stimmig, so wird dem Benutzer zum Beispiel seine Profilseite angezeigt. Doch wenn dieser nun einen Klick auf irgendeinen Link macht, wäre er wieder ausgeloggt. Das liegt daran, dass PHP eigentlich nicht weiß, dass der Nutzer sich zuvor eingeloggt hatte.
Natürlich könnte man während des Logins die aktuelle IP-Adresse des Nutzers in der Datenbank hinterlegen und bei jedem Seitenaufruf einfach prüfen, ob der Nutzer die gleiche IP-Adresse hat, aber in einem Internet-Kaffee wäre zum Beispiel jeder Sitzplatz plötzlich eingeloggt, da alle die selbe IP-Adresse verwenden.
Es ist also besser jedem Nutzer eine Sitzungs-ID zu verpassen, diese wird von seinem Browser automatisch mit an PHP übergeben und man kann somit auch mehrere verschiedene Nutzer unter ein und der selben IP-Adresse managen. Zudem haben Session’s den Vorteil, dass man zeitgleich Daten übergeben kann, etwa den Benutzernamen oder auch die Gültigkeitsdauer.
Wie erstellt man eine Sitzung?
Das erstellen einer Sitzung ist ganz einfach:
<?php
session_start();
?>
Nun kann man auch Daten in die Sitzung hineinschreiben:
<?php
session_start();
$_SESSION['benutzername'] = "Max Mustermann";
?>
Nach einem klick des Benutzers auf irgendeinen internen Link auf der Webseite, können die Daten wieder gelesen werden:
<?php
session_start();
echo $_SESSION['benutzername'];
?>
Um den Wert wieder aus der Session zu entfernen:
<?php
session_start();
unset($_SESSION['benutzername']);
?>
Man kann allerdings auch (bei Logout zum Beispiel) die ganze Session (Sitzung) zerstören:
<?php
session_destroy();
?>
Tipp: Wenn man die Session-ID abfragen möchte, also um sie etwa in die Datenbank zu speichern, so geht das mit:
<?php
session_start();
$sid = session_id(); // Die Session-ID wird nun in die Variable $sid geschrieben..
?>
Weitere Informationen zu Cookies, Sessions, ID’s oder zu Login-Scripten findet ihr Links in der Kategorie “PHP”.
Klasse: nützliche Kalenderfunktionen
Sie möchten einen Kalender mit Hilfe von PHP erstellen und ausgeben? Dabei ist es oft notwendig allerhand “Fakten” aus einem Datum, einem Monat oder einem Jahr zusammen zu tragen und weiter zu verarbeiten.
Da PHP vor allem auf Englische Datumsangaben optimiert wurde, muss man auf ein paar integrierte Funktionen verzichten. Etwa Wochentagsnamen oder Monatsnamen werden von PHP in englischer Sprache zurückgegeben.
Um diese Problematik zu vereinfachen, haben wir eine Klasse erstellt, in der wir viele oft benötigte Funktionen unter gebracht haben:
class kalender {
function getMonatName($m){
$monate = array("", "Januar", "Februar", "März", "April", "Mai", "Juni",
"Juli", "August", "September", "Oktober", "November", "Dezember");
return $monate[$m];
}
function getWochentagName($w){
$wochentage = array("Sonntag", "Montag", "Dienstag", "Mittwoch",
"Donnerstag", "Freitag", "Samstag");
return $wochentage[$w];
}
function getMonatserster($m, $y){
return mktime(0,0,0,$m,1, $y);
}
function getMonatsletzer($m, $y){
return date("t", $this->getMonatserster($m, $y));
}
function getJetztStamp(){
return time();
}
function getTagZahl($stamp){
return date("d", $stamp);
}
function getMonatZahl($stamp){
return date("m", $stamp);
}
function getJahr($stamp){
return date("Y", $stamp);
}
function getIstSommerzeit($stamp){
return date("I", $stamp);
}
function getZeitzone($stamp){
return date("O", $stamp);
}
function getJahrestag($stamp){
return date("z", $stamp)+1;
}
function getWoche($stamp){
return date("W", $stamp);
}
function getIstSchaltjahr($stamp){
return date("L", $stamp);
}
function getWochentagZahl($stamp){
return date("w", $stamp);
}
function formatDatum($stamp){
return date("d.m.Y", $stamp);
}
function getTagStartStamp($d, $m, $y){
return mktime(0,0,0,$m,$d,$y);
}
function getTagEndeStamp($d, $m, $y){
return mktime(23,59,59,$m,$d,$y);
}
}
Klasse: gesetzliche und kirchliche Feiertage bestimmen
Immer wenn man als Programmierer vor der Aufgabe steht einen “kleinen” Kalender zu Programmieren, denkt man im ersten Gedanken: “Das ist doch einfach!” ABER!!! Wenn man erst einmal angefangen hat, merkt man schnell, wie umfangreich ein solcher Kalender sein kann. Sollen dann noch Feiertage im Kalender eingeschrieben werden, geht der Spaß so richtig los.
Viele Feiertage berechnen sich an Ostern und Ostern wiederum am Mond..
Ist doch einfach, oder? … Nein – Scherz bei Seite:
Wem das zu Aufwändig ist, der kann hier auf unsere Klasse zurückgreifen, denn damit bekommt man die Feiertage förmlich auf dem silbernen Tablett gereicht. Einfach das Jahr an die jeweilige Funktion übergeben und diese liefert den passenden TimeStamp des Feiertages.
class feiertage{
public function ToArray($stamp){
$jahr = date("Y", $stamp);
$ret = array();
$c = 0;
if ($stamp == $this->ostersonntag($jahr)) { $ret[$c]['name'] = "Ostersonntag"; $c++; }
if ($stamp == $this->rosenmontag($jahr)) { $ret[$c]['name'] = "Rosenmontag"; $c++; }
if ($stamp == $this->fastnacht($jahr)) { $ret[$c]['name'] = "Fastnacht"; $c++; }
if ($stamp == $this->aschermittwoch($jahr)) { $ret[$c]['name'] = "Aschermittwoch"; $c++; }
if ($stamp == $this->palmsonntag($jahr)) { $ret[$c]['name'] = "Palmsonntag"; $c++; }
if ($stamp == $this->gruendonnerstag($jahr)) { $ret[$c]['name'] = "Gründonnerstag"; $c++; }
if ($stamp == $this->karfreitag($jahr)) { $ret[$c]['name'] = "Karfreitag"; $c++; }
if ($stamp == $this->karsamstag($jahr)) { $ret[$c]['name'] = "Karsamstag"; $c++; }
if ($stamp == $this->ostermontag($jahr)) { $ret[$c]['name'] = "Ostermontag"; $c++; }
if ($stamp == $this->christihimmelfahrt($jahr)) { $ret[$c]['name'] = "Christi Himmelfahrt"; $c++; }
if ($stamp == $this->pfingstsonntag($jahr)) { $ret[$c]['name'] = "Pfingstsonntag"; $c++; }
if ($stamp == $this->pfingstmontag($jahr)) { $ret[$c]['name'] = "Pfingstmontag"; $c++; }
if ($stamp == $this->fronleichnam($jahr)) { $ret[$c]['name'] = "Fronleichnam"; $c++; }
if ($stamp == $this->neujahr($jahr)) { $ret[$c]['name'] = "Neujahr"; $c++; }
if ($stamp == $this->hldreikoenige($jahr)) { $ret[$c]['name'] = "Heilige Drei Könige"; $c++; }
if ($stamp == $this->berchtoldstag($jahr)) { $ret[$c]['name'] = "Berchtoldstag"; $c++; }
if ($stamp == $this->valentinstag($jahr)) { $ret[$c]['name'] = "Valentinstag"; $c++; }
if ($stamp == $this->frauentag($jahr)) { $ret[$c]['name'] = "Frauentag"; $c++; }
if ($stamp == $this->josephstag($jahr)) { $ret[$c]['name'] = "Josephstag"; $c++; }
if ($stamp == $this->sommerzeit($jahr)) { $ret[$c]['name'] = "Sommerzeit"; $c++; }
if ($stamp == $this->winterzeit($jahr)) { $ret[$c]['name'] = "Winterzeit"; $c++; }
if ($stamp == $this->maifeiertag($jahr)) { $ret[$c]['name'] = "Maifeiertag"; $c++; }
if ($stamp == $this->muttertag($jahr)) { $ret[$c]['name'] = "Muttertag"; $c++; }
if ($stamp == $this->siebenschlaefer($jahr)) { $ret[$c]['name'] = "Siebenschläfer"; $c++; }
if ($stamp == $this->peterundpaul($jahr)) { $ret[$c]['name'] = "Peter und Paul"; $c++; }
if ($stamp == $this->bundesfeier($jahr)) { $ret[$c]['name'] = "Bundesfeier"; $c++; }
if ($stamp == $this->friedensfest($jahr)) { $ret[$c]['name'] = "Friedensfest"; $c++; }
if ($stamp == $this->mariaehimmelfahrt($jahr)) { $ret[$c]['name'] = "Mariä Himmelfahrt"; $c++; }
if ($stamp == $this->tagderdeutscheneinheit($jahr)) { $ret[$c]['name'] = "Tag der deutschen Einheit"; $c++; }
if ($stamp == $this->nationalfeiertag($jahr)) { $ret[$c]['name'] = "Nationalfeiertag"; $c++; }
if ($stamp == $this->weltspartag($jahr)) { $ret[$c]['name'] = "Weltspartag"; $c++; }
if ($stamp == $this->reformationstag($jahr)) { $ret[$c]['name'] = "Reformationstag"; $c++; }
if ($stamp == $this->halloween($jahr)) { $ret[$c]['name'] = "Halloween"; $c++; }
if ($stamp == $this->allerheiligen($jahr)) { $ret[$c]['name'] = "Allerheiligen"; $c++; }
if ($stamp == $this->allerseelen($jahr)) { $ret[$c]['name'] = "Allerseelen"; $c++; }
if ($stamp == $this->martinstag($jahr)) { $ret[$c]['name'] = "Martinstag"; $c++; }
if ($stamp == $this->fastnachtsbeginn($jahr)) { $ret[$c]['name'] = "Fastnachtsbeginn"; $c++; }
if ($stamp == $this->volkstrauertag($jahr)) { $ret[$c]['name'] = "Volkstrauertag"; $c++; }
if ($stamp == $this->bussundbettag($jahr)) { $ret[$c]['name'] = "Buß und Bettag"; $c++; }
if ($stamp == $this->totensonntag($jahr)) { $ret[$c]['name'] = "Totensonntag"; $c++; }
if ($stamp == $this->ersteradvent($jahr)) { $ret[$c]['name'] = "1. Advent"; $c++; }
if ($stamp == $this->zweiteradvent($jahr)) { $ret[$c]['name'] = "2. Advent"; $c++; }
if ($stamp == $this->nikolaustag($jahr)) { $ret[$c]['name'] = "Nikolaustag"; $c++; }
if ($stamp == $this->mariaeempfaengnis($jahr)) { $ret[$c]['name'] = "Mariä Empfängnis"; $c++; }
if ($stamp == $this->dritteradvent($jahr)) { $ret[$c]['name'] = "3. Advent"; $c++; }
if ($stamp == $this->vierteradvent($jahr)) { $ret[$c]['name'] = "4. Advent"; $c++; }
if ($stamp == $this->heiligabend($jahr)) { $ret[$c]['name'] = "Heilig Abend"; $c++; }
if ($stamp == $this->ersterweihnachtstag($jahr)) { $ret[$c]['name'] = "1. Weihnachtsfeiertag"; $c++; }
if ($stamp == $this->zweiterweihnachtstag($jahr)) { $ret[$c]['name'] = "2. Weihnachtsfeiertag"; $c++; }
if ($stamp == $this->silvester($jahr)) { $ret[$c]['name'] = "Silvester"; $c++; }
return $ret;
}
function eastern($year){
$X = $year;
$K = floor ( $X / 100 );
$M = 15 + floor ( ( ( 3 * $K ) + 3 ) / 4 ) -
floor ( ( ( 8 * $K ) + 13 ) / 25 );
$S = 2 - floor ( ( ( 3 * $K ) + 3 ) / 4 );
$A = $X % 19;
$D = ( 19 * $A + $M ) % 30;
$R = floor ( $D / 29 ) + ( floor ( $D / 28 ) -
floor ( $D / 29 ) ) * floor ( $A / 11 );
$OG = 21 + $D - $R;
$SZ = 7 - ( ( $X + floor ( $X / 4 ) + $S ) % 7 );
$OE = 7 - ( ( $OG - $SZ ) %7 );
$OS = $OG + $OE;
return $OS;
}
function ostersonntag($year){
return mktime(0,0,0,3,$this->eastern($year),$year);
}
function rosenmontag($year){
return mktime(0,0,0,3,$this->eastern($year)-48,$year);
}
function fastnacht($year){
return mktime(0,0,0,3,$this->eastern($year)-47,$year);
}
function aschermittwoch($year){
return mktime(0,0,0,3,$this->eastern($year)-46,$year);
}
function palmsonntag($year){
return mktime(0,0,0,3,$this->eastern($year)-7,$year);
}
function gruendonnerstag($year){
return mktime(0,0,0,3,$this->eastern($year)-3,$year);
}
function karfreitag($year){
return mktime(0,0,0,3,$this->eastern($year)-2,$year);
}
function karsamstag($year){
return mktime(0,0,0,3,$this->eastern($year)-1,$year);
}
function ostermontag($year){
return mktime(0,0,0,3,$this->eastern($year)+1,$year);
}
function christihimmelfahrt($year){
return mktime(0,0,0,3,$this->eastern($year)+39,$year);
}
function pfingstsonntag($year){
return mktime(0,0,0,3,$this->eastern($year)+49,$year);
}
function pfingstmontag($year){
return mktime(0,0,0,3,$this->eastern($year)+50,$year);
}
function fronleichnam($year){
return mktime(0,0,0,3,$this->eastern($year)+60,$year);
}
function neujahr($year){
return mktime(0,0,0,1,1,$year);
}
function hldreikoenige($year){
return mktime(0,0,0,1,6,$year);
}
function berchtoldstag($year){
return mktime(0,0,0,1,2,$year);
}
function valentinstag($year){
return mktime(0,0,0,2,14,$year);
}
function frauentag($year){
return mktime(0,0,0,3,8,$year);
}
function josephstag($year){
return mktime(0,0,0,3,19,$year);
}
function sommerzeit($year){
switch(date("w", mktime(0,0,0,3,31,$year))){
case 0:
$ret = mktime(0,0,0,3,31,$year);;
break;
case 1:
$ret = mktime(0,0,0,3,30,$year);
break;
case 2:
$ret = mktime(0,0,0,3,29,$year);
break;
case 3:
$ret = mktime(0,0,0,3,28,$year);
break;
case 4:
$ret = mktime(0,0,0,3,27,$year);
break;
case 5:
$ret = mktime(0,0,0,3,26,$year);
break;
case 6:
$ret = mktime(0,0,0,3,25,$year);
break;
} // switch
return $ret;
}
function winterzeit($year){
switch(date("w", mktime(0,0,0,10,31,$year))){
case 0:
$ret = mktime(0,0,0,10,31,$year);;
break;
case 1:
$ret = mktime(0,0,0,10,30,$year);
break;
case 2:
$ret = mktime(0,0,0,10,29,$year);
break;
case 3:
$ret = mktime(0,0,0,10,28,$year);
break;
case 4:
$ret = mktime(0,0,0,10,27,$year);
break;
case 5:
$ret = mktime(0,0,0,10,26,$year);
break;
case 6:
$ret = mktime(0,0,0,10,25,$year);
break;
} // switch
return $ret;
}
function maifeiertag($year){
return mktime(0,0,0,5,1,$year);
}
function muttertag($year){
return mktime(0,0,0,5,1,$year);
}
function siebenschlaefer($year){
return mktime(0,0,0,6,27,$year);
}
function peterundpaul($year){
return mktime(0,0,0,6,29,$year);
}
function bundesfeier($year){
return mktime(0,0,0,8,1,$year);
}
function friedensfest($year){
return mktime(0,0,0,8,8,$year);
}
function mariaehimmelfahrt($year){
return mktime(0,0,0,8,15,$year);
}
function tagderdeutscheneinheit($year){
return mktime(0,0,0,10,3,$year);
}
function nationalfeiertag($year){
return mktime(0,0,0,10,26,$year);
}
function weltspartag($year){
switch(date("w", mktime(0,0,0,10,30,$year))){
case 0:
$ret = mktime(0,0,0,10,29,$year);;
break;
case 1:
$ret = mktime(0,0,0,10,30,$year);
break;
case 2:
$ret = mktime(0,0,0,10,30,$year);
break;
case 3:
$ret = mktime(0,0,0,10,30,$year);
break;
case 4:
$ret = mktime(0,0,0,10,30,$year);
break;
case 5:
$ret = mktime(0,0,0,10,30,$year);
break;
case 6:
$ret = mktime(0,0,0,10,30,$year);
break;
} // switch
return $ret;
}
function reformationstag($year){
return mktime(0,0,0,10,31,$year);
}
function halloween($year){
return mktime(0,0,0,11,1,$year);
}
function allerheiligen($year){
return mktime(0,0,0,11,1,$year);
}
function allerseelen($year){
return mktime(0,0,0,11,2,$year);
}
function martinstag($year){
return mktime(0,0,0,11,11,$year);
}
function fastnachtsbeginn($year){
return mktime(0,0,0,11,11,$year);
}
function volkstrauertag($year){
switch (date("w", $this->heiligabend($year))) {
case 0:
$ret = mktime(0,0,0,11,19,$year);;
break;
case 1:
$ret = mktime(0,0,0,11,18,$year);;
break;
case 2:
$ret = mktime(0,0,0,11,17,$year);;
break;
case 3:
$ret = mktime(0,0,0,11,16,$year);;
break;
case 4:
$ret = mktime(0,0,0,11,15,$year);;
break;
case 5:
$ret = mktime(0,0,0,11,14,$year);;
break;
case 6:
$ret = mktime(0,0,0,11,13,$year);;
break;
}
return $ret;
}
function bussundbettag($year){
return $this->ersteradvent($year)-(60*60*24*11);
}
function totensonntag($year){
switch (date("w", $this->heiligabend($year))) {
case 0:
$ret = mktime(0,0,0,11,26,$year);;
break;
case 1:
$ret = mktime(0,0,0,11,25,$year);;
break;
case 2:
$ret = mktime(0,0,0,11,24,$year);;
break;
case 3:
$ret = mktime(0,0,0,11,23,$year);;
break;
case 4:
$ret = mktime(0,0,0,11,22,$year);;
break;
case 5:
$ret = mktime(0,0,0,11,21,$year);;
break;
case 6:
$ret = mktime(0,0,0,11,20,$year);;
break;
}
return $ret;
}
function ersteradvent($year){
switch (date("w", $this->heiligabend($year))) {
case 0:
$ret = mktime(0,0,0,12,3,$year);;
break;
case 1:
$ret = mktime(0,0,0,12,2,$year);;
break;
case 2:
$ret = mktime(0,0,0,12,1,$year);;
break;
case 3:
$ret = mktime(0,0,0,11,30,$year);;
break;
case 4:
$ret = mktime(0,0,0,11,29,$year);;
break;
case 5:
$ret = mktime(0,0,0,11,28,$year);;
break;
case 6:
$ret = mktime(0,0,0,11,27,$year);;
break;
}
return $ret;
}
function zweiteradvent($year){
switch (date("w", $this->heiligabend($year))) {
case 0:
$ret = mktime(0,0,0,12,10,$year);;
break;
case 1:
$ret = mktime(0,0,0,12,9,$year);;
break;
case 2:
$ret = mktime(0,0,0,12,8,$year);;
break;
case 3:
$ret = mktime(0,0,0,12,7,$year);;
break;
case 4:
$ret = mktime(0,0,0,12,6,$year);;
break;
case 5:
$ret = mktime(0,0,0,12,5,$year);;
break;
case 6:
$ret = mktime(0,0,0,12,4,$year);;
break;
}
return $ret;
}
function nikolaustag($year){
return mktime(0,0,0,12,6,$year);
}
function mariaeempfaengnis($year){
return mktime(0,0,0,12,8,$year);
}
function dritteradvent($year){
switch (date("w", $this->heiligabend($year))) {
case 0:
$ret = mktime(0,0,0,12,17,$year);;
break;
case 1:
$ret = mktime(0,0,0,12,16,$year);;
break;
case 2:
$ret = mktime(0,0,0,12,15,$year);;
break;
case 3:
$ret = mktime(0,0,0,12,14,$year);;
break;
case 4:
$ret = mktime(0,0,0,12,13,$year);;
break;
case 5:
$ret = mktime(0,0,0,12,12,$year);;
break;
case 6:
$ret = mktime(0,0,0,12,11,$year);;
break;
}
return $ret;
}
function vierteradvent($year){
switch (date("w", $this->heiligabend($year))) {
case 0:
$ret = mktime(0,0,0,12,24,$year);;
break;
case 1:
$ret = mktime(0,0,0,12,23,$year);;
break;
case 2:
$ret = mktime(0,0,0,12,22,$year);;
break;
case 3:
$ret = mktime(0,0,0,12,21,$year);;
break;
case 4:
$ret = mktime(0,0,0,12,20,$year);;
break;
case 5:
$ret = mktime(0,0,0,12,19,$year);;
break;
case 6:
$ret = mktime(0,0,0,12,18,$year);;
break;
}
return $ret;
}
function heiligabend($year){
return mktime(0,0,0,12,24,$year);
}
function ersterweihnachtstag($year){
return mktime(0,0,0,12,25,$year);
}
function zweiterweihnachtstag($year){
return mktime(0,0,0,12,26,$year);
}
function silvester($year){
return mktime(0,0,0,12,31,$year);
}
}
Timestamp in Datum umwandeln
Wer mit PHP arbeitet weiß, dass man oft das Datum ausgeben möchte oder auch muss. Da es praktischer ist, immer nur einen “Fingerabdruck” einer Zeit, also den sogenannten TimeStamp (deu: Zeitstempel), zu speichern, kommt man nicht ohne eine ensprechende Rückwandlung aus. Dafür bietet PHP zwar eine umfangreiche Funktion, doch manchmal ist es einfacher sich eine eigene Funktion zu erstellen. Wer also eine “einfache” Datumsausgabe (dd.mm.jjjj) wünscht, kann auf diese Funktion zurückgreifen:
function formatDatum($stamp){
return date("d.m.Y", $stamp);
}
Und wer dazu passend die Uhrzeit (hh:mm) ausgeben möchte kann entweder diese Funktion verwenden:
function formatZeit($stamp){
return date("H:i", $stamp);
}
Oder gleich eine Funktion für beides nutzen:
function formatDatumZeit($stamp){
return date("d.m.Y H:i", $stamp);
}
Möchte man “nur” das aktuelle Datum und die aktuelle Uhrzeit ausgeben, kann man folgendes schreiben:
function getDatumZeit(){
return date("d.m.Y H:i", time());
}
Ersetzt man das Schlüsselwort “return” durch “echo” wird das Datum und die Uhrzeit sofort ausgegeben, ansonsten würde man mit die Funktionen folgendermaßen aufrufen:
echo getDatumZeit();
Sonderzeichen maskieren
Oft sieht man auf Webseiten, dass Sonderzeichen nicht richtig angezeigt werden. Dazu gehören häufig das Eurozeichen, die Umlaute Ä, Ö und Ü, sowie das ß-Zeichen. Wenn man PHP verwendet um PDF-Dateien zur Laufzeit zu erstellen, kann es ebenfalls zu solchen Problemen kommen.
Um dem ganzen ein wenig aus dem Weg zu gehen, kann man die betreffenden Zeichen vor der Ausgabe maskieren. Dazu nutzen wir folgende einfache und schnell erweiterbare Funktion:
function mask($str){
$str = str_replace("&", "&", $str);
$str = str_replace("Ä", "Ä", $str);
$str = str_replace("Ö", "Ö", $str);
$str = str_replace("Ü", "Ü", $str);
$str = str_replace("ß", "ß", $str);
$str = str_replace("€", "€", $str);
$str = str_replace("!=", "≠", $str);
$str = str_replace("~~", "≈", $str);
$str = str_replace("~=", "≅", $str);
$str = str_replace("~", "∼", $str);
$str = str_replace("<=", "≤", $str);
$str = str_replace(">=", "≥", $str);
$str = str_replace(">", ">", $str);
$str = str_replace("<", "<", $str);
$str = str_replace(">>", "»", $str);
$str = str_replace("<<", "«", $str);
$str = str_replace("\"", """, $str);
$str = str_replace("ä", "ä", $str);
$str = str_replace("ö", "ö", $str);
$str = str_replace("ü", "ü", $str);
$str = str_replace("¡", "¡", $str);
$str = str_replace("¢", "¢", $str);
$str = str_replace("£", "£", $str);
$str = str_replace("(C)", "©", $str);
$str = str_replace("(R)", "®", $str);
$str = str_replace("+-", "±", $str);
$str = str_replace("²", "²", $str);
$str = str_replace("³", "³", $str);
$str = str_replace("^1", "¹", $str);
$str = str_replace("^2", "²", $str);
$str = str_replace("^3", "³", $str);
$str = str_replace("°", "°", $str);
$str = str_replace("1/2", "½", $str);
$str = str_replace("1/4", "¼", $str);
$str = str_replace("3/4", "¾", $str);
$str = str_replace("^TM", "™", $str);
$str = str_replace("0/00", "‰", $str);
$str = str_replace("^", "ˆ", $str);
return $str;
}
PHP: Verbindung zur MySQL-Datenbank (Tutorial)
Die Umsetzung eines größeren Projektes mit PHP macht es sehr oft notwendig, dass Benutzerdaten in einer Datenbank auf dem Server hinterlegt werden müssen. Das betrifft in der Regel die Daten, die man bei einer Registrierung als Nutzer hinterlegen muss, also etwa den Anmeldenamen und das dazu gehörige Passwort. Nur damit ist es möglich, eine authentifizierte Anmeldung zu realisieren und unbefugten Dritten den Zugriff zu verweigern. Während des Logins werden die in der Datenbank gespeicherten Daten mit den vom Benutzer im Login-Formular eingegebenen Daten verglichen. Sind beide Datensätze gleich, so ist der Nutzer eingeloggt.
Um die Datenspeicherung effizient und zeitnah zu realisieren und beim Vergleich der Eingaben mit dem gespeicherten Daten so geringe Scriptlaufzeiten wie möglich zu erzielen, ist eine Speicherung der Daten in einer lokalen Datei nicht ratsam.
Als deutlich reaktionsschneller zeigt sich hier eine Datenbank, mit der ein direkter Datenaustausch möglich ist. So setzt man unter ASP oftmals auf Microsoft SQL-SERVER und unter PHP auf MySQL-Server und -Datenbanken.
Nachfolgend möchten wir zeigen, wie man leicht und dennoch auch für große Projekte geeignete Verbindungen zu einer Datenbank herstellt und wie man damit Daten abruft und Datenabgleiche sowie -vergleiche realisiert.
Zuerst sollte einem PHP-Programmierer bewusst sein, dass es immer wichtig ist, den Code möglichst gut Strukturiert in einzelne Dateien ablegt. So werden auch wir zu allererst eine Konfigurationsdatei anlegen, in der alle notwendigen Angaben und Einstellungen getroffen werden. Das ist wichtig, denn so muss man bei einem Server-Umzug nicht in jeder Script-Datei Änderungen vorzunehmen, zumal man dann erst suchen müsste, an welcher Stelle im Code die Angaben stehen.
Unsere Konfigurationsdatei trägt den Namen “config.php” und liegt im Unterverzeichnis “includes”:
<?php
/**
* includes/config.php
* -> Konfigurationsdatei
*/
$_SETTINGS = array();
$_SETTINGS['mysql_host'] = 'localhost';
$_SETTINGS['mysql_user'] = 'username';
$_SETTINGS['mysql_pass'] = 'password';
$_SETTINGS['mysql_database'] = 'databasename';
?>
Wir erstellen zuerst ein Array mit dem Namen “$_SETTINGS”. Dieses Array werden wir später Global einsetzen um unsere Einstellungen jederzeit abzurufen. Diese Einstellungen legen wir jedoch bereits in unserer “config.php” fest. Der Logische Aufbau hierbei ist, dass wir für jedes Array-Element einen festen und eindeutigen Namen als Index einsetzen. Der Index-Name beginnt immer mit dem einem Wort, welches den Bereich festlegt, danach folgt ein Unterstrich: “_” und dann ein weiteres Wort für die einzelne Einstellung. Bis jetzt haben wir nur Einstellungen für die Verbindung zu einer MySQL-Datenbank hinterlegt, also fangen alle Index-Namen mit “mysql” an. Da wir einmal die Adresse des MySQL-Servers, einmal den Benutzernamen, das Passwort und letztlich den Namen der Datenbank hinterlegen möchten, erstellen wir 4 solcher Index-Namen mit den Endungen “_host”, “_user”, “_pass” und “_database”. Man kann hier natürlich auch deutsche namen verwenden, doch erfahrungsgemäß sind englische Titel strikt kürzer.
Als nächstes sollten wir uns eine Script-Datei anlegen, in der wir Funktionen und automatisierte Abläufe ablegen, die wir später immer und immer wieder benötigen.
Wir nennen diese Datei “functions.php” und legen diese ebenfalls im Unterverzeichnis “includes” ab:
<?php
/**
* includes/functions.php
* -> Funktionensammlung und Automatisierte Vorgänge
*/
function ConnectToDatabase() {
global $_SETTINGS;
@mysql_connect($_SETTINGS['mysql_host'], $_SETTINGS['mysql_user'], $_SETTINGS['mysql_pass']) OR
die ("Datenbankfehler in Functions.php (ConnectToDatabase::1): ".mysql_error());
if (!mysql_select_db($_SETTINGS['mysql_database'])
die ("Datenbankfehler in Functions.php (ConnectToDatabase::2): ".mysql_error());
return true;
}
?>
Eigentlich sollte man eine Funktion so aufbauen, dass diese Eingabewerte erwartet, dann eine Aufgabe (zum Beispiel: Berechnung) durchführt und einen Wert zurückliefert. Wir halten uns in diesem Falle nicht ganz an dieses Muster, den wir nutzen unsere erste Funktion nur zur Vereinfachung der Verbindungsherstellung zum Datenbankserver.
Dabei kommen zwei PHP-Funktionen zum Einsatz, zum einen “mysql_connect” und zum anderen “mysql_select_db”. Genau genommen ist auch “die” und “mysql_error” eine PHP-Funktion, auf die ich jetzt aber erstmal nicht eingehe. Mit “mysql_connect” stellt PHP eine Verbindung zum Datenbank-Server her, vorausgesetzt, dass man dieser Funktion die Adresse (URL) des Servers mitteilt und für die Authentifizierung einen Benutzernamen und dass dazugehörige Passwort angibt. Mit “mysql_select_db” wählen wir eine zuvor manuell oder durch den Serveranbieter angelegte Datenbank aus. Dabei müssen wir der Funktion natürlich den Namen der Datenbank mitteilen.
Nun möchte ich erstmal etwas zu dem “@”-Zeichen vor “mysql_connect” etwas sagen: Normalerweise gibt PHP (je nach Server-Einstellungen) an dieser Stelle eine Meldung aus, wenn der Verbindungsaufbau gescheitert ist. Leider sind die Informationen dabei nicht sehr Detailreich und wir haben uns dafür entschieden mit der “die”-Funktion eine eigene Fehlerbehandlung zu erstellen. Da dadurch die Fehlermeldung einmal durch PHP und einmal durch uns (“die”) ausgegeben würde, schalten wir die PHP-Fehlerausgabe mit dem “@”-Zeichen vor der Funktion ab. Somit würde “Datenbankfehler in…” ausgegeben werden, wenn ein Fehler passiert, bzw. die Verbindung scheitert. Die Funktion “mysql_error” liefert hierbei Detaillierte Informationen zum Fehler als String (Zeichenkette) zurück. Diese Informationen werden in der Regel vom MySQL-Server selbst ausgegeben, doch damit wir dies lesen können, hängen wir diese Fehlerausgabe an unsere Fehlerbehandlung an: “die (‘Datenbankfehler in … : ‘.mysql_error()”. Da bei einem Fehler das Script durch “die” sofort gestoppt und beendet werden würde, können wir problemlos mit “return true;” die Funktion als “erfolgreich abgeschlossen” deklarieren, da diese Stelle nur erreicht werden würde, wenn kein Fehler passiert.
PHP: Benchmark – Scriptlaufzeit messen
Oft sieht man auf Seiten am unteren Rand einen Hinweis darauf, wie lange die Seite zum Laden, bzw. das jeweilige Script zur Verarbeitung der Daten benötigt hat. Diese Zeitangaben sind gerade für Webentwickler sehr wichtig, um Rückschlüsse ziehen zu können, welche Bereiche weiter optimiert werden müssen.
Nimmt man Beispielsweise eine Statistik, die aus Tausende von Daten erstellt wird, so muss das Script teilweise hunderte aufeinanderfolgende Datenbank abfragen durchführen und eventuell im Nachgang alle Daten sortieren. Um dafür den bestmöglichen Algorithmus zu finden, der möglichst wenig Zeit in Anspruch nimmt, ist es notwendig die Script-Laufzeit zu messen.
Hier ist eine einfache Lösung um die Script-Laufzeit für PHP-Basierte Anwendungen und Webseiten zu messen und am Ende der Seite auszugeben.
Zuerst benötigen wir eine Datei in der wir die Benchmark-Klasse ablegen:
benchmark.inc
<?php
/**
* benchmark.inc
* @copyright 2009 by dejavu-design.eu
* Freigegeben für die ausschließlich private Verwendung.
*/
class benchmark
{
var $startstamp;
var $stopstamp;
function CBench()
{
$this->startstamp = 0;
$this->stopstamp = 0;
$this->start();
}
function readmicrotime()
{
list($usec, $sec) = explode(" ",microtime());
return ((float)$usec + (float)$sec);
}
function start()
{
$this->startstamp = $this->readmicrotime();
}
function stop()
{
$this->stopstamp = $this->readmicrotime();
}
function differenz()
{
$result = $this->stopstamp - $this->startstamp;
return $result;
}
}
?>
Für die Messung ist es nun lediglich notwendig die Klasse in das zu bemessende Script zu laden und am Ende das Messergebnis auszugeben:
index.php
<?php
/**
* index.php
* @copyright 2009 by dejavu-design.eu
* Freigegeben für die ausschließlich private Verwendung.
*/
// Benchmark initialisieren und starten
include ("benchmark.inc");
$bench = new benchmark;
// -------------------------BENCHMARK---
// Hauptscript abarbeiten --------------
// Hier sollte nun das eigentliche Script seine Arbeit tun..
// --------------------------SCRIPT---
// Benchmark stoppen und Wert ausgeben -
$bench->stop();
echo "Laufzeit: " . $bench->differenz() . " Sekunden";
// ------------------------BENCHMARKT---
?>
Mehr ist zur Messung nicht notwendig. Der Benchmark startet sich selbstständig, in dem Moment, in dem die Klasse eingebunden wird. Dabei wird die Mikro-Zeit gelesen. Am Ende des Scriptes erfolgt der Stop-Befehl, welcher das erneute lesen der Mikro-Zeit durchführt. Anschließend wird mit der Klassen-Funktion “differenz” die Differenz beider Werte errechnet und ausgegeben.
Senden...