Dejavu-Design.eu

Autorenarchiv

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”.

Bilder und Videos von der Unwetterfront vom 24.05.2010 in Wetteritz und den Schäden vom 25.05.2010 in Großenhain.

Alle Bilder und Videos sind Kopierrechtlich geschützt. Wenn Sie eines oder mehrere Bilder verwenden möchten, kontaktieren Sie uns bitte unter der im Impressum angegebenen Kontaktadresse.

Es ist zwar kaum vorstellbar, aber es hat Zeiten gegeben, in denen man sich über die Kanalbündelung bei ISDN gefreut hat. Heute ist es gar nicht mehr denkbar, mit solch einer geringen Bandbreite im Internet zu stöbern. Neuere Techniken machen es heute möglich, mancherorts in den Genuss einer 50.000er DSL-Leitung zu kommen. Aber auch für 100 Mbit/s-Leitungen (100.000er DSL) wird schon geworben und wer in der glücklichen Lage ist, solch eine Bandbreite geschalten zu bekommen ist nahezu genauso schnell angeschlossen, wie kleinere Server-Zentren.

Wenn man aber damit immer noch nicht genug hat, sollte man einen Blick auf die Tätigkeiten von Google werfen. Derzeit testet der Suchmaschinen-Gigant eine neue Hochgeschwindigkeitsanbindung speziell für Webanwendungen, über die eine deutlich größere Datenmenge befördert werden kann. Laut Angaben von Google sollen damit Bandbreiten mit bis zu ein Gigabit pro Sekunde möglich werden. Derzeit wird die Technik allerdings noch ausschließlich in Amerika getestet. Wann das ganze in Deutschland verfügbar sein wird, ist noch unklar.

In Deutschland wird derzeit jedoch eine weitere Technik getestet: 100 Mbit/s – Anbindungen im Mobilfunk-Netz. Eine neue Übertragungstechnik, also ein Nachfolger für HSDPA soll dies ermöglichen. Da jedoch die Frequenzbereiche stark begrenzt sind und auch die Bandbreiten der jeweiligen Funkstationen nicht unerschöpflich sind, wird man dies aller Wahrscheinlichkeit nach nur in Großstädten ermöglichen. Auch preislich werden diese Tarife für private Endkunden kaum tragbar sein.

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);
	}

 }

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);
	}

 }

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();

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("<=", "&le;", $str);
     $str = str_replace(">=", "&ge;", $str);
     $str = str_replace(">", "&gt;", $str);
     $str = str_replace("<", "&lt;", $str);
     $str = str_replace(">>", "&raquo;", $str);
     $str = str_replace("<<", "&laquo;", $str);
     $str = str_replace("\"", "&quot;", $str);
     $str = str_replace("ä", "&auml;", $str);
     $str = str_replace("ö", "&ouml;", $str);
     $str = str_replace("ü", "&uuml;", $str);
     $str = str_replace("¡", "&iexcl;", $str);
     $str = str_replace("¢", "&cent;", $str);
     $str = str_replace("£", "&pound;", $str);
     $str = str_replace("(C)", "&copy;", $str);
     $str = str_replace("(R)", "&reg;", $str);
     $str = str_replace("+-", "&plusmn;", $str);
     $str = str_replace("²", "&sup2;", $str);
     $str = str_replace("³", "&sup3;", $str);
     $str = str_replace("^1", "&sup1;", $str);
     $str = str_replace("^2", "&sup2;", $str);
     $str = str_replace("^3", "&sup3;", $str);
     $str = str_replace("°", "&deg;", $str);
     $str = str_replace("1/2", "&frac12;", $str);
     $str = str_replace("1/4", "&frac14;", $str);
     $str = str_replace("3/4", "&frac34;", $str);
     $str = str_replace("^TM", "&trade;", $str);
     $str = str_replace("0/00", "&permil;", $str);
     $str = str_replace("^", "&circ;", $str);
     return $str;
}

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.

Der technologische Fortschritt ist nicht aufzuhalten. Gerade jetzt, wo man überall mit dem Thema Energie sparen konfrontiert wird, boomt der Markt für alternativen. Dieser trend ist auch bei der Beleuchtungsindustrie zu erkennen. Derzeit wird man dazu bewegt, seine herkömmlichen Glühbirnen gegen neue und energie sparende Leuchtmittel zu tauschen. Eine dieser Alternativen ist die Beleuchtung mit LEDs. Doch wer etwa seine Hallogen-Lampen neu bestücken möchte, der greift oftmals zu Birnen mit 12 oder mehr LEDs und ist spätestens zuhause von deren Lichtausbeute enttäuscht. Doch damit ist nun Schluss, denn neue extrem helle LEDs und spezielle Birnen-Gehäuse sorgen für ein helles, angenehmes und weit reichendes Licht. Auch beim Preis für solche Birnen hat sich einiges getan. Kosteten drei solcher Birnen vor zwei Jahren noch knapp 170 Euro so zahlt man heute pro Stück rund 12 Euro. Wenn man nun bedenkt, dass diese Birnen gerade mal 3 Watt benötigen, so hat man das Geld schnell wieder rein.

Mit Hilfe moderner Handys ist es nun sogar möglich kinderleicht etwa einen Blog-Eintrag direkt auf den mittlerweile doch recht großen Displays zu schreiben und sofort Online verfügbar zu machen. Diesen Beitrag, welchen sie gerade lesen haben wir mit Hilfe eines Samsung-Handys geschrieben. Natürlich benötigt man noch eine entsprechende Software, welche den eingegebenen Text an den Blog sendet, doch hinsichtlich der Texteingabe gibt es nichts auszusetzen. Dadurch, dass man die Texte direkt mit dem Finger auf dem Display eingeben kann, ist das Bloggen unterwegs recht gut möglich.

Auch die bei der Internetanbindung hat sich einiges getan, erreichte man noch vor ein bis zwei Jahren in vielen Orten nur GPRS-Empfang so kommt man dort jetzt bereits in den Genuss von EDGE-Signalen und damit höheren Bandbreiten. In vielen Städten ist das Mobile Internet mit einem herkömmlichen DSL-Anschluss nicht mehr zu unterscheiden. Man erreich mit Hilfe der HSDPA-Technik Geschwindigkeiten bis zu 7.200 kb/s. Und damit macht es nicht nur auf den großen Displays der Touchscreen-Handys Spaß ein Video etwa von YouTube anzusehen.