Uploadscript Tutorial Vorraussetzungen

• mittlere PHP Kenntnisse
• Schwierigkeit: Mittel

Uploadscript Sicherheit

Man stelle sich nun vor es wäre jedem erlaubt jeden beliebigen Dateityp auf den Server zu laden. So wäre es einfach mittels einer hochgeladenen .php Datei einen Angriff auf den Server zu starten. Deshalb sollte vorgegeben werden welche Dateitypen erlaubt sind, und welche nicht.
Ein weiteres Sicherheitsrisiko sind die Servereinstellungen. Leider gibt es im World Wide Web immer noch schwarze Schafe unter den Webhostern, welche einen unprofessionellen und völlig falsch konfigurierten Server bzw. Webspace anbieten. Es ist also möglich das Dateien wie bild.php.jpg als php Datei ausgeführt werden. Dies sollte vor Installation eines Uploadscriptes unbedingt beachtet werden (Bevor du das Tutorial also weiterliest, prüfe bitte ob dies bei dir der Fall ist).

Das Uploadscript

Ich werde als erstes wieder das komplette Uploadscript posten, und dies dann im Laufe des Tutorials durcharbeiten.

 
<?php
$max_size = 2; // In MB
$max_size = $max_size*pow(10,6);
$upload_pfad = "uploads/";
$nachricht = array();
 
function check_file($dateiname, $pfad, $error, $mimetyp, $max_size) {
	$error = false;
 
	/* Fehlermeldungen definieren */
	switch($error) {
		case 1;
		$error[] = "Die hochgeladene Datei
			überschreitet die maximal festgelegte Größe.";
		break;
 
		case 2;
		$error[] = "Die hochgeladene Datei
			überschreitet die maximal festgelegte Größe.";
		break;
 
		case 3;
		$error[] = "Die Datei wurde nur teilweise hochgeladen,
			versuchen sie es erneut";
		break;
 
		case 4;
		$error[] = "Es wurde keine Datei hochgeladen.";
		break;
	}
	/* Nochmals Größe der Datei prüfen */
	if(filesize($_FILES["dateiupload"]["tmp_name"])>$max_size)
		$error[] = "Die hochgeladene Datei
			überschreitet die maximal festgelegte Größe.";
 
	/* Dateityp prüfen */
	$mime_erlaubt = array("image/gif",
				"image/jpeg",
				"image/png",
				"text/html",
				"text/plain",
				"text/css",
				"application/zip",
				"video/mpeg");
 
	if(!in_array($mimetyp, $mime_erlaubt))
		$error[] = "Unerlaubter Dateityp";
 
	/* 	Prüfen ob Datei schon existiert,
		wenn Ja, die datei umbennenen */
	while(file_exists($pfad.$dateiname)) {
		$dateiname = "a_".$dateiname;
	}
 
	$_FILES["dateiupload"]["name"] = $dateiname;	
 
	/* 	Fehlermeldungen zurückgeben, wenn keine Fehler
		wird false zurückgegeben */
	return $error;
}
 
/* Datei hochladen */
if(isset($_GET['action']) and ($_GET['action']=="upload")) {
 
$nachricht = check_file($_FILES["dateiupload"]["name"],
			$upload_pfad,
			$_FILES["dateiupload"]["error"],
			$_FILES["dateiupload"]["type"],
			$max_size);
 
if(!$nachricht) {
	/* File nun in das richtige Verzeichnis verschieben */
	if(move_uploaded_file($_FILES["dateiupload"]["tmp_name"],
	$upload_pfad.$_FILES["dateiupload"]["name"])) {
 
		if(!chmod($upload_pfad.$_FILES["dateiupload"]["name"], 0755))
			$nachricht[] = "Rechte der Datei wurden nicht gesetzt,
					dies ist möglicherweise eine
					Sicherheitslücke";
 
		$nachricht[] = "Datei wurde erfolgreich hochgeladen";
		}
 
	else
		$nachricht[] = "Unbekannter Fehler!
				Bitte versuchen sie es erneut";	
 
}
}
 
?>
 

 
<form enctype="multipart/form-data" action="?action=upload" method="POST">
<input type="hidden" name="MAX_FILE_SIZE" value="<?php echo $max_size ?>">
Datei hochladen:
<input name="dateiupload" type="file">
<input type="submit" value="Upload">
</form>

 
<?php
 /* Fehlermeldung ausgeben */
foreach($nachricht as $msg) {
	echo $msg."<br>";
}
?>
 

So nun schauen wir uns das ganze etwas näher an, als erstes den HTML Teil.

 
<form enctype="multipart/form-data" action="?action=upload" method="POST">
<input type="hidden" name="MAX_FILE_SIZE" value="<?php echo $max_size ?>">
Datei hochladen:
<input name="dateiupload" type="file">
<input type="submit" value="Upload">
</form>

Durch dieses Formular können mit jedem RFC-1867 konformen Browser (dazu gehören der Netscape Navigator 3 oder höher, Microsoft Internet Explorer 3 mit einem Patch von Microsoft oder höher ohne Patch) Dateiuploads durchgeführt werden. Mittels PHP kann man dann steuern wer Dateien hochladen darf und was mit diesen Dateien geschieht. Sobald dieses Formular abgeschickt wurde, wird eine Datei in ein temporäres Verzeichnis geuploaded. Mit MAX_FILE_SIZE kann erstmal einfach eine maximale Dateigröße vorgegeben werden (Welche in diesem Tutorial in der Variable $max_size steht). Achtung: Diese Prüfung kann sehr einfach umgangen werden!
Kommen wir zum nächsten Teil des PHP Uploadscript Tutorials, der Funktion check_file() welche den MIME-Typ, die Dateigröße und änhliches prüft. Als ersten Teil der Funktion schauen wir uns die Variable $_SERVER["dateiupload"]["error"] an, in welcher, falls es zu einem Uploadfehler kommt, ein Fehlercode steht. (1, 2, 3 oder 4).

 
	/* Fehlermeldungen definieren */
	switch($error) {
		case 1;
		$error[] = "Die hochgeladene Datei
			überschreitet die maximal festgelegte Größe.";
		break;
 
		case 2;
		$error[] = "Die hochgeladene Datei
			überschreitet die maximal festgelegte Größe.";
		break;
 
		case 3;
		$error[] = "Die Datei wurde nur teilweise hochgeladen,
			versuchen sie es erneut";
		break;
 
		case 4;
		$error[] = "Es wurde keine Datei hochgeladen.";
		break;
	}
 

In diesem Abschnitt des Uploadscriptes wird also mittels Switch Abfrage geprüft welcher Fehler vorkam, und gegebenenfalls eine passende Fehlermeldung in das Array $error, welches am Ende der Funktion zurückgegeben wird, geschrieben.
Im nächsten Teil der Funktion check_file(), das nochmalige prüfen der Dateigröße, da wie oben schon beschrieben die Vorgabe mittels MAX_FILE_SIZE unsicher ist.

 
	/* Nochmals Größe der Datei prüfen */
	if(filesize($_FILES["dateiupload"]["tmp_name"])>$max_size)
		$error[] = "Die hochgeladene Datei
			überschreitet die maximal festgelegte Größe.";
 

Es wird also die Dateigröße der bereits hochgeladene Datei (temporär gespeichert) überprüft, und falls diese Größe zu groß ist, wird eine Fehlermeldung in unserer Array $error geschrieben. Im nächsten Teil von check_file() wird der MIME-Typ geprüft, denn es werden nur einige Vorgegebene MIME-Typen in dem Uploadscript zugelassen.

 
	/* Dateityp prüfen */
	$mime_erlaubt = array("image/gif",
				"image/jpeg",
				"image/png",
				"text/html",
				"text/plain",
				"text/css",
				"application/zip",
				"video/mpeg");
 
	if(!in_array($mimetyp, $mime_erlaubt))
		$error[] = "Unerlaubter Dateityp";
 

Hier erstellen wir einen Array mit dem Namen $mime_erlaubt, in welchen alle erlaubten MIME Typen stehen. Mittels einer If Abfrage und der Funktion in_array prüfen wir nun ob der MIME Typ der hochgeladenen Datei ein erlaubter MIME Typ ist. (Den MIME Typ der hochgeladenen Datei bekommt man mittels $_FILES["dateiupload"]["type"]).
Im vorletzten Abschnitt unserer eigenen Funktion check_file() überprüfen wir ob eine Datei schon existiert, und geben der Datei gegebenenfalls einen Präfix...

 
	/* 	Prüfen ob Datei schon existiert,
		wenn Ja, die datei umbennenen */
	while(file_exists($pfad.$dateiname)) {
		$dateiname = "a_".$dateiname;
	}
 
	$_FILES["dateiupload"]["name"] = $dateiname;
 

Es wird also mittels While-Schleife und der Funktion file_exists geprüft ob die Datei mit dem Dateinamen $dateinamen im Verzeichnis $pfad vorhanden ist, und solange dies der Fall ist wird dem Dateinamen ein "a_" angehängt. Abschließend wird unserer Superglobalen $_FILES["dateiupload"]["name"] welchen den Namen der Datei beinhaltet, der neue Dateiname zugewiesen.
Als Abschluss der Funktion check_file() geben wir jetzt nur noch den Array mit den Fehlermeldungen zurück.
Kommen wir also zum nächsten Schritt des Tutorials, dem aufrufen der Funktion und dem Verschieben der temporär gespeicherten Datei.

 
/* Rufen wir also die selbt definierte Funktion auf
Und übergeben den Dateinamen, den Pfad,
ggf den Fehler der beim Hochladen verursacht wurde
Den MIME-Typ und die maximale Filegröße */
$nachricht = check_file($_FILES["dateiupload"]["name"],
			$upload_pfad,
			$_FILES["dateiupload"]["error"],
			$_FILES["dateiupload"]["type"],
			$max_size);
/* Da wir die Fehlermeldungen in der Funktion zurückgeben
enthält nun die Variable $nachricht Fehlermeldungen, wenn
welche vorhanden sein sollten. Deshalb prüfen wir im
nächsten Schritt ob diese Variable false, d.h nicht gesetzt
ist */
if(!$nachricht) {
 
/* Mittels move_uploaded_file verschieben wir die temporär
gespeicherte Datei in unser Wunschverzeichnis */
if(move_uploaded_file($_FILES["dateiupload"]["tmp_name"],
	$upload_pfad.$_FILES["dateiupload"]["name"])) {
 
		/* Und als Abschluss noch chmod Rechte setzen damit
		nicht jeder mit den Dateien machen kann was er will */
		if(!chmod($upload_pfad.$_FILES["dateiupload"]["name"], 0755))
			$nachricht[] = "Rechte der Datei wurden nicht gesetzt,
					dies ist möglicherweise eine
					Sicherheitslücke";
 
		$nachricht[] = "Datei wurde erfolgreich hochgeladen";
		}
 
	else
		$nachricht[] = "Unbekannter Fehler!
				Bitte versuchen sie es erneut";	
 
}
}
 

Und um das Tutorial noch abzuschließen werden die Meldungen aus dem Array $nachricht noch mittels einer Foreach-Schleife ausgegeben.

 
<?php
 /* Fehlermeldung ausgeben */
foreach($nachricht as $msg) {
	echo $msg."<br>";
}
?>
 

Ich hoffe ich konnte euch mit diesem PHP Uploadscript Tutorial etwas helfen und wäre über Rückmeldungen, Fragen oder Kommentare jeder Art dankbar.

Script um Dateidownload zu erzwingen

 
function download_file($file) {
	$filename = basename($file);
	$filesize = filesize($file);
	header("Content-Type: application/force-download");
	header("Content-Disposition: attachment; filename=".$filename);
	header("Content-Length: $filesize");
	readfile($file);
}
download_file("pfad/datei.php");
 

Erklärung des Downloadscriptes

In unserer Funktion lesen wirmittels basename("file") den Dateinamen aus und speichern diesen in die Variable $filename. Mittels filesize("file") wird die Dateigröße ermittelt, und in die Variable $filesize gespeichert. Jetzt setzten wir einige Headerinformationen, damit der Browser weiß dass es sich um einen Dateidownload handelt. Nun geben wir Datei noch mittels readfile("file") aus. Und das war es schon! Diese Funktion kann jetzt einfach mittels download_file("file") aufgerufen werden! Viel spaß mit eurem erzwungenem Dateidownload

Thumbnail Tutorialvorraussetzungen

• PHP Kenntnisse
• GD Library

Das Thumnial Tutorial insgesamt hat einen mittleren Schwierigkeitsgrad.

Zuerst werde ich einfach das ganze Scipt zeigen, und dieses zerlegen wir langsam im Laufe des Tutorials.

 
function new_thumb(	$picturepath,
					$thumbpath = false,
					$newsize = 100) {
 
	/* Prüfen ob Datei existiert */
	if(!file_exists($picturepath)) {
		echo "Grafik nicht vorhanden";
		return false;
	}
 
	/* MIME-Typ auslesen */
	$size=getimagesize($picturepath);
	switch($size[2]) {
		case "1";
		$oldpic = imagecreatefromgif($picturepath);
		break;
 
		case "2";
		$oldpic = imagecreatefromjpeg($picturepath);
		break;
 
		case "3";
		$oldpic = imagecreatefrompng($picturepath);
		break;
 
		default;
		echo "Grafiktyp wird nicht unterstützt";
		return false;
	}
 
	/* Alte Maße auslesen */
	$width = $size[0];
	$height = $size[1]; 
 
	/* Neue Maße errechnen */
	if($width>=$height) {
		$newwidth = $newsize;
		$newheight = $newsize*$height/$width;
	}
	else {
		$newheight = $newsize;
		$newwidth = $newsize*$width/$height;
	}	
 
	/* Neues Bild erstellen mit den neuen Maßen */
	$newpic=imagecreatetruecolor($newwidth,$newheight);
 
	/* Jetzt wird das Bild nur noch verkleinerd */
	imagecopyresized($newpic,$oldpic,0,0,0,0,
				$newwidth,$newheight,$width,$height); 
 
	/* Und hier schon ausgegeben wenn es nicht gespeichert wird */
	if(!$thumbpath) {
		/* Grafik ausgeben */
		switch($size[2]) {
		case "1";	header ("Content-type: image/gif");
					return imagegif($newpic);
		break;
		case "2";	header ("Content-type: image/jpg");
					return imagejpeg($newpic);
		break;
		case "3";	header ("Content-type: image/png");
					return imagepng($newpic);
		break;
		}
	}
	/* Wenn es gespeichert werden soll */
	else {
		switch($size[2]) {
		case "1";	return imagegif($newpic, $thumbpath);
		break;
		case "2";	return imagejpeg($newpic, $thumbpath);
		break;
		case "3";	return imagepng($newpic, $thumbpath);
		break;
		}
	}
 
	//Bilderspeicher freigeben
    imagedestroy($oldpic);
    imagedestroy($newpic);
}

 
/* Jetzt geben wir ein Bild aus */
new_thumb("bild1.jpg", false, 500)
 

Das Bild bild1.jpg wird jetzt dynamisch erstellt (Thumbnail) und im Browser ausgegeben. Eine Besonderheit ist, das die maximale Seitenlänge in unserem Beispiel 500 Beträgt, entweder bei der Höhe oder bei der Breite (je nachdem was Größer ist). Wollen wir jetzt aber kein Thumbnail ausgeben sondern eines speichern, so müssen wir die Funktion einfach anders aufrufen.

 
/* Jetzt speichern wir ein Bild */
new_thumb("bild1.jpg", "bild1_thumb.jpg", 500)
 

Nun wird unser Bild1 als Thumbnail gespeichert, mit der gleichen maximalen Seitenlänge wie oben (500px).

Was passiert eigentlich in unserer Funktion?

Schauen wir uns also den ersten Teil der Funktion an, wir überprüfen ob die Grafik, aus welcher wir ein Thumbnail erstellen wollen vorhanden ist. Dies geschieht mit file_exists()

 
	/* Prüfen ob Datei existiert */
	if(!file_exists($picturepath)) {
		echo "Grafik nicht vorhanden";
		return false;
	}
 

Kommen wir zum nächsten Punkt, zum "Erstellen" eines Bildes aus der Originalgrafik (Originaldatei)

 
	/* MIME-Typ auslesen */
	$size=getimagesize($picturepath);
	switch($size[2]) {
		case "1";
		$oldpic = imagecreatefromgif($picturepath);
		break;
 
		case "2";
		$oldpic = imagecreatefromjpeg($picturepath);
		break;
 
		case "3";
		$oldpic = imagecreatefrompng($picturepath);
		break;
 
		default;
		echo "Grafiktyp wird nicht unterstützt";
		return false;
	}
 

Mittels getimagesize(pfad) lesen wir diverse Informationen einer Grafikdatei aus und speichern diese als Array in $size ($size[0] enthält die Breite, $size[1] enthält die Höhe, $size[2] enthält einen Integerwert welcher einem MIME-Typ zugewiesen wird).
Also erstellen wir entweder eine gif, jpeg oder png Grafik (Thumbnails von anderen Grafiken zu erstellen ist mit diesem Script leider nicht möglich!). Im nächsten Teil der Funktion (Tutorials) lesen wir die Breite und Höhe des Originalbildes aus und berechnen gleich die Maße unseres Thumbnails

 
	/* Alte Maße auslesen */
	$width = $size[0];
	$height = $size[1]; 
 
	/* Neue Maße errechnen */
	if($width>=$height) {
		$newwidth = $newsize;
		$newheight = $newsize*$height/$width;
	}
	else {
		$newheight = $newsize;
		$newwidth = $newsize*$width/$height;
	}
 

Wie Oben schon beschrieben holen wir uns aus dem Array $size die Breite und die Höhe, danach prüfen wir ob unser Bild ein Bild im Querformat (Breite>Höhe) oder Hochformat (Höhe>Breite) ist. Dies geschieht mit einer einfachen If-Abfrage.
Beispiel: Nehmen wir an unsere Ausgangsgrafik hat die Maße 1000px Breite und 500px Höhe (Querformat denn die Breite > Höhe). Wollen wir jetzt eine maximale Seitenlänge von 200px haben, so wird jetzt der Variable $newwidth der Wert 200 zugewiesen. Die Variable $newheight wird berechnet (200*500/1000) und wir bekommen eine neue Höhe von 100px für das Thumbnail heraus. Somit bleiben die Seitenverhältnisse des Bildes auch im Thumnail erhalten und es wird nicht verzerrt.

Kommen wir nun zum nächsten Teil der Funktion (des Tutorials)

 
	/* Neues Bild erstellen mit den neuen Maßen */
	$newpic=imagecreatetruecolor($newwidth,$newheight);
 
	/* Jetzt wird das Bild nur noch verkleinerd */
	imagecopyresized($newpic,$oldpic,0,0,0,0,
				$newwidth,$newheight,$width,$height);
 

Als erstes wird mit imagecreatetruecolor() ein neues leeres Bild erstellt, und in dieses werden dann die Farbwerte vom der Originalgrafik mittels imagecopyresized() eingefügt. Nun nähern wir uns schon dem Ende des Tutorials an, nämlich der Ausgabe bzw Speicherung unseres Thumbnails.

 
	/* Und hier schon ausgegeben wenn es nicht gespeichert wird */
	if(!$thumbpath) {
		/* Grafik ausgeben */
		switch($size[2]) {
		case "1";	header ("Content-type: image/gif");
					return imagegif($newpic);
		break;
		case "2";	header ("Content-type: image/jpg");
					return imagejpeg($newpic);
		break;
		case "3";	header ("Content-type: image/png");
					return imagepng($newpic);
		break;
		}
	}
 

Wenn das Thumbnail nicht gespeichert sondern ausgegeben werden soll, muss beim Aufrufen unserer selbstgeschriebenen Funktion new_thumb() als Speicherort ($thumbpath) false (= der Standartwert) angegeben sein. Mit der Switch prüfen wir wieder den MIME-Typ und geben die Datei aus. Wollen wir das Thumbnail allerdings nicht ausgeben sondern speichern, muss die Variable $thumbpath gesetzt sein. Dann läuft das Script weiter und wir kommen zum Ende der Funktion:

 
	/* Wenn es gespeichert werden soll */
	else {
		switch($size[2]) {
		case "1";	return imagegif($newpic, $thumbpath);
		break;
		case "2";	return imagejpeg($newpic, $thumbpath);
		break;
		case "3";	return imagepng($newpic, $thumbpath);
		break;
		}
	}
 

Wieder mittels Switch-Abfrage den MIME-Typ abfragen und dann wird das Bild mittels imagejpeg, imagegif oder imagepng gespeichert, da ein Speicherort ($thumbpath) angegeben wurde. Zum abschluss leeren wir nur noch den Speicher:

 
//Bilderspeicher freigeben
    imagedestroy($oldpic);
    imagedestroy($newpic);
 

Ich hoffe ich konnte mit diesem Tutorial einigen Leuten helfen ihre eignenen Thumnails zu erstllen und wäre für Rückmeldungen (mittels der Kommentarfunktion) dankbar.

Web Developer, das beste Firefox Addon für die Webentwicklung

Web Developer ist meiner Meinung nach eines der besten und wichtigsten Firefox Addons für die Entwicklung von Webseiten, es mittlerweile sogar in deutscher Sprache verfügbar. Mit den Web Developer kann alles Erdenkliche deaktiviert/aktiviert/verändert werden.

Firebug

Ist man die Funktionalität von Firebug einmal gewöhnt, so ist dieses Addon kaum noch weg zu denken. Für mich gehört Firebug zur Standartausrüstung eines Webentwicklers. Es Hilft bei der Fehlersuche im HTML-Code bzw auch im Javascript-Code. Die Visualisierung von div-Containern macht das Tool zu einer Super Hilfe.

ColorZilla

Man surft durch das Internet und sieht eine schöne Farbe, will jedoch nicht lange im Quelltext (CSS) den RBG-Farbcode bzw. den Hex-Farbcode suchen. Früher startete man Photoshop, nun gehts mit ColorZilla. ColorZilla ist praktisch, zum Beispiel auch um Farben in einem fertigen Template (z.B: für CMS, Foren, Gästebücher etc.) anzupassen. Einfach auf die Farbe im Browser klicken, Farbcode (RBG oder Hex) kopieren und fertig.

Google Pagerank Status

Vl mag der Eine oder Andere jetzt sagen: “Was interessiert mich der Pagerank noch?”, aber es ist trotzdem interessant zu schauen, wie der Pagerank der jeweiligen Seite ist. Dieses Addon lässt rechts unten einen kleinen Balken erscheinen welcher den Pagerank anzeigt.

Mit der Funktion filesize() kann man die größe einer Datei auslesen. Filzesize() gibt die Größe einer Datei in Bytes zurück, man muss (oder sollte zumindest) diese immer in die entsprechende Einheit umwandeln (kb, mb, gb). Wir schreiben uns also eine kleine Funktion welche das alles für uns übernimmt.

 
<?php
function fs_convert ($datei, $nachkommastellen = 0) {
	if(!file_exists($datei)) { // Wenn Datei nicht existiert
		echo "0 Byte";
		return; // Ende der Funktion
	}
 
	$size = filesize($datei); // Größe in Bytes
 
	if($size >= 1073741824)  // Wenn über 1 GB
		echo round($size/(1073741824), $nachkommastellen)." GB";
 
	elseif($size >= 1048576) // Wenn über 1 MB
		echo round($size/(1048576), $nachkommastellen)." MB";
 
	elseif($size >= 1024) // Wenn über 1 KB
		echo round($size/(1024), $nachkommastellen)." KB";
 
	else // Ansonsten sind es nur Bytes
		echo  $size." Byte";
}
?>
 

Diese Funktion können wir nun einfach aufrufen und die Dateigröße wird mittels PHP mit der entsprechenden Einheit ausgelesen bzw. zurückgeliefert. Ein kleines Beispiel wie das Ganze aussehen könnte.

 
<?php
function fs_convert ($datei, $nachkommastellen = 0) {
	if(!file_exists($datei)) { // Wenn Datei nicht existiert
		echo "0 Byte";
		return; // Ende der Funktion
	}
 
	$size = filesize($datei); // Größe in Bytes
 
	if($size >= 1073741824)  // Wenn über 1 GB
		echo round($size/(1073741824), $nachkommastellen)." GB";
 
	elseif($size >= 1048576) // Wenn über 1 MB
		echo round($size/(1048576), $nachkommastellen)." MB";
 
	elseif($size >= 1024) // Wenn über 1 KB
		echo round($size/(1024), $nachkommastellen)." KB";
 
	else // Ansonsten sind es nur Bytes
		echo  $size." Byte";
}
?>
 
Die Datei: <a href="email.zip">email.php</a> ist
<?php fs_convert("email.zip", 2); ?> groß.
 
<br>
<br>
 
Die Datei: <a href="test/datei_2.zip">Datei 2</a> ist
<?php fs_convert("test/datei_2.zip", 2); ?>
groß.
 

In diesem Beispiel müsste die Datei email.zip im selben Verzeichniss liegen, in dem diese Funktion aufgerufen wird. Die Datei datei_2.zip müssten in einem Unterordner namens "test" liegen.
Nun wünsche ich viel Spaß beim dynamischen ermitteln von Dateigrößen mittels PHP.

Funktion schreiben um Email Adresse zu Überprüfen

Zuerst einmal zeige ich euch einfach den Code für die Funktion welche überprüft ob die Variable eine gültige Email Adresse ist.

 
function mail_pruefen($adresse) {
	if(empty($adresse)) // Wenn leer
		return false; // Funktion beenden
 
	/* Überprüfen */
	$regex = '§[\w-.]{1,}@[\w-]{3,}\.[\w-]{2,3}§';
	preg_match($regex, $adresse, $matches);
 
	if(empty($matches)) // Wenn keine Email
		return false; // Funktion beenden
	if(strlen($matches[0])!=strlen($adresse))
		return false; // Funktion beenden
 
	return($matches[0]);
	}
$mailcheck = mail_pruefen($_POST["email"]);
 

So, was passiert hier nun? Die Variable $regex enthält unseren Regulären Ausdruck und überprüft mit Hilfe von preg_match() ob die Variable $adresse eine gültige Email Adresse enthält. $matches ist ist ein Array in das die gültige Email Adresse dann gespeichert wird. Deshalb greifen wir auch auf den ersten (und in den meisten Fällen einzigen Wert) mittels $matches[0] zu. Nun geben wir mit return noch den Inhalt von $matches[0] zurück (die gültige Email Adresse). Die Variable $mailcheck, enthält entweder die Email Adresse oder false.

Komplett funktionsfähiges Skript um Email Adresse zu überprüfen

Um unser PHP Email Adresse Prüfen Skript noch im Einsatz zu zeigen hier ein kompletter funktionierender Code, welchen man auch hier testen kann.

 
<?php
function mail_pruefen($adresse) {
	if(empty($adresse)) // Wenn leer
		return false; // Funktion beenden
 
	/* Überprüfen */
	$regex = '§[\w-.]{1,}@[\w-]{3,}\.[\w-]{2,3}§';
	preg_match($regex, $adresse, $matches);
 
	if(empty($matches)) // Wenn keine Email
		return false; // Funktion beenden
	if(strlen($matches[0])!=strlen($adresse))
		return false; // Funktion beenden
 
	return($matches[0]);
	}
$mailcheck = mail_pruefen($_POST["email"]);
?>
<form action="" method="post">
Email:
<input name="email" type="text" value="<?php echo $_POST["email"] ?>" />
<input type="submit" value="Prüfen" />
</form>
 
<?php
	if($mailcheck)
		echo "Gültige Email Adresse";
	else
		echo "Ungültige Email Adresse";
?>
 

Viel Spam bei Überprüfen deiner Email Adresse mit PHP. Diese Funktion kann ganz einfach eingebunden werden, solltest du jedoch trozdem Fragen dazu haben melde dich einfach hier.

• round() - mathematisch Runden
• ceil() - Aufrunden
• floor() - Abrunden

Diese Rundungsfunktionen sollten eigentlich selbst erklärend sein, doch ich werde sie hier anhand einiger Beispiele erklären. Fangen wir mit dem Aufrunden an:

PHP Aufrunden

Hierbei rundet die Funktion ceil() einen Fließkommawert auf die nächstgrößere Ganzzahl auf. Anhand der Beispiele dürfte dies verständlich dargestellt sein

 
	echo ceil(2.25); // rundet auf 3 auf
	echo ceil(2.9); // 3
	echo ceil(225.001) // 226
 

PHP Abrunden

Hierbei rundet die Funktion floor() einen Fließkommawert auf die nächstkleinere Ganzzahl ab. Anhand der Beispiele dürfte dies verständlich dargestellt sein

 
	echo floor(2.25); // rundet auf 2 ab
	echo floor(2.9); // 2
	echo floor(225.001) // 225
 

Mathematisch korrektes runden mit PHP

Mit der Funktion round() rundet PHP mathematisch korrekt. Es wird ab 5 aufgerunden, ansonsten abgerundet. Die Funktion round($zahl, $kommastellen) hat 2 Parameter, wobei nur der Erste($zahl) notwendig ist, $kommastellen ist als Standart 0. Einige Beispiele dürften diese Funktion verständlich erklären:

 
	echo round(14.4); // Gibt 14 aus
	echo round(14.5); // Gibt 15 aus
	echo round(14.4, -1) // Gibt 10 aus
	echo round(123.1234, 2) // Gibt 123.23 aus
 

Wie man also sehen kann, kann der Parameter der für die Kommastellen zuständig ist auch negativ sein. So ist der Parameter z.B: -1 wird auf volle Zehner gerundet, bei -2 auf volle Hunderter usw.

Ich hoffe ich konnte dir das Runden mittels PHP einigermaßen verständlich erklären und wünsche viel Spaß beim Aufrunden bzw Abrunden mit PHP

Das Stichwort für eine funktionierende Blätterfunktion lautet LIMIT. LIMIT gibt eine gewisse Datenmenge x ab dem Eintrag y aus! Dies können wir optimal nutzen um unsere Blätterfunktion für PHP zu erstellen.

So genug geredet so sieht das ganze nun erst einmal als PHP-Code aus!

 
function limitierte_ausgabe($anfang, $eintrage_lesen) {
 
	mysql_connect("localhost, username, passwort");
	mysql_select_db("tabelle");
 
	$sql = 'SELECT*
		FROM guestbook
		ORDER BY datum desc
		LIMIT '.$anfangen.', '.$eintrage_lesen;
 
	$query = mysql_query($sql);
 
		while($row = mysql_fetch_assoc($query)) {
			$gaestebuchausgabe[] = $row;
		}
	return $gaestebuchausgabe;
}
 

So dies währe jetzt eigentlich schon eine Funktion die uns eine PHP bzw mySQL Blätterfunktion ermöglicht, doch wie wendet man diese nun an?

 
function limitierte_ausgabe($auslesen_beginnen, $eintrage_lesen) {
 
	mysql_connect("localhost, username, passwort");
	mysql_select_db("tabelle");
 
	$sql = 'SELECT*
		FROM guestbook
		ORDER BY datum desc
		LIMIT '.$auslesen_beginnen.', '.$eintrage_lesen;
 
	$query = mysql_query($sql);
 
		while($row = mysql_fetch_assoc($query)) {
			$gaestebuchausgabe[] = $row;
		}
	return $gaestebuchausgabe;
}
 
$eintraege_seite = 10; /// 10 Einträge/Seite
$aktuelle_seite = $_GET["page"];
	if(!$_GET["page"]>=1) /// Wenn die Seite nicht größer oder gleich 1 ist
		$aktuelle_seite = 1; /// Soll sie 1 sein
 
$auslesen_beginnen = $eintraege_seite*$aktuelle_seite - $eintraege_seite;
 
/* Und nun nur noch die Funktion aufrufen */
$ausgabewerte = limitierte_ausgabe($auslesen_beginnen, $eintraege_seite);
 

Rufen wir jetzt unsere Funktion limitierte_ausgabe auf, so müssen wir 2 Parameter eingeben ($auslesen_beginnen, $eintraege_seite), diese werden dann an unsere mySQL Funktion limit weitergegeben, um eben nur eine gewisse Anzahl an Einträge auszulesen!

Wie ja bekannt ist gibt mysql_fetch_assoc($query) ja eine Zeile nach der Anderen aus. Mit LIMIT werden jedoch nicht immer alle Zeilen in unserer Datenbank angesprochen, sondern nur eine gewisse Anzahl beginnend von dem Eintrag x von dennen die normal ausgelesen werden würden!

Ein kleines Beispiel:
Wir haben eine Gästebuchdatenbank mit 20 Einträgen. Wenn wir jetzt nur die ersten 10 Einträge auslesen wollen, müssen wir mit LIMIT angeben von wo weg, bis wo hin, hier speziell LIMIT 0,10 so. Wir wollen also vom ersten Beitrag (0) weg, 10 Beiträge auslesen! Wenn wir jetzt die Einträge 10-20 anzeigen möchten, so müssen wir ganz einfach LIMIT 10,10 angeben. Dies heist jetzt, es werden vom 10ten Eintrag weg 10 weitere Einträge ausgelesen!

Was nun noch fehlt ist eine Ausgabe der Seiten. Wir lesen mittels $_GET["page"] aus auf welcher Seite wir gerade sind. Somit müssen wir nun einfach mittels einer Schleife die Links zu den Seiten ausgeben. Vorher muss nur noch geprüft werden wie viele Seiten wir haben, dies machen wir mittels mySQL, wir schauen wie viele Datensätze vorhanden sind, dividieren diese durch die Anzahl an Einträge/ Seite und runden diese Zahl auf! Fertig...

 
$query = mysql_query('SELECT COUNT(*) as zeilen FROM guestbook');
$row = mysql_fetch_assoc($query);
$zeilen = $row["zeilen"];
$seiten = ceil($zeilen/$eintraege_seite);
 
	for($i=1;$i<=$seiten;$i++) {
		echo "<a href=\"?page=". $i ."\">". $i ."</a> ";
	}
 

Und das war eigentlich schon alles um eine PHP Blätterfunktion mit mySQL Datenbank zu programmieren. Solltest du Fragen haben oder etwas unverständlich erklärt sein schreib bitte einfach einen Kommentar, ich werde innerhalb von 24 Stunden darauf antworten!

Viel spaß mit eurer eigenen PHP Blätterfunktion!

PS: Wenn hier etwas unverständlich erklärt ist, bitte meldet euch

Grundsätzlich gibt es dafür jetzt zwei Möglichkeiten, einmal eine SQL Funktion und einmal mit Hilfe von PHP.
Die erste Möglichkeit hierfür wäre, das Ganze mit Hilfe von if not exists (SQL Code) zu realisieren, das würde dann folgendermaßen aussehen.

 
mysql_query("CREATE TABLE IF NOT EXISTS
		tabelle (spalte spaltentyp, [...])");
 

Die zweite, für mich schönere Lösung wäre mittels PHP zu überprüfen ob eine Tabelle in der Datenbank schon vorhanden ist. Dazu schreiben wir uns eine kleine Funktion die wir immer, wenn wir sie brauchen verwenden können.

 
	function checktable($tablename){
		$query = "SHOW TABLES LIKE ".$tablename;
		if(mysql_num_rows(mysql_query($query))) {
			return true;
		}
 
		else{
			return false;
		}
	}
 

mysql_num_rows(mysql_query("SHOW TABLES LIKE ".$tablename."")) gibt true bzw eine Zahl zurück, wenn die Tabelle mit dem Namen der in der Variable $tablename gespeichert ist existiert und false wenn diese Tabelle noch nicht Existent ist.

Diese Funktion können wir nun folgendermaßen aufrufen:

 
if(checktable("News")) {
	echo "Tabelle News wurde bereits angelegt";
}
else {
	echo "Tabelle News wurde noch nicht angelegt";
	}
 

Frames werden also in den meisten Fällen nur eingesetzt, um einen fixen
Bereich zu haben, der nicht mit scrollt (Non-Scrolling-Region), oder um eine zentrale Navigationsliste zu haben, welche man bei Änderungen auch nur einmal ändern muss(siehe dazu PHP-Include). Hier möchte ich zeigen, wie so etwas auch ohne Frames funktioniert – aus der
Überlegung heraus, dass es einfach zu schade ist, die zahlreichen Nachteile, vorallem die Suchmaschinenunfreundlichkeit, von Frames in Kauf zu nehmen, wenn das gewünschte Ziel auch anders erreichbar ist.

CSS kennt eine Positionierungseigenschaft position:fixed, welche mittels top, left, bottom und right absolut positioniert wird.
Die CSS Datei fix.css

#navigation {
position:fixed;
top:1em;
left:1em;
padding-right:1em;
border-right:black solid 4px;
height: 100%;
background: #EEE;
}
#content {
margin-left:7em;
margin-right:1em;
background: #CCC;
}

und die HTML datei

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html lang="de">
<head>
<meta http-equiv="content-type" content="text/html;
charset=ISO-8859-1">
<title>Fixer Bereich</title>
<link rel="stylesheet" type="text/css" href="fix.css">
<!--[if gte IE 5]>
<link rel="stylesheet" type="text/css" href="ie-fix.css">
<![endif]-->
</head>
<body>
<div id="navigation">
<h1>Navigation</h1>
<ul>
<li><a href="">Seite 2</a></li>
<li><a href="">Seite 3</a></li>
<li><a href="">Seite 4</a></li>
</ul>
</div>
<div id="content">
<h1>Content</h1>
 
Content...
</div>
 
</body>
</html>

So, nun sieht das ganze erstmal so aus
Das div-Element mit der id Navigation wird nun beim scrollen nicht mehr mitgescrollt. Allerdings gibt es leider auch den Internet Explorer, der position:fixed bis einschließlich Version 6 nicht kennt. Doch für den Internet gibt es ein Workaround, mit Hilfe von Javascript!

Workaround für Internet Explorer bis Version 6

Zuerst einmal ändern wir unsere eigentliche fix.css Datei.

body >body > #navigation {
position:fixed;
top:20px;
left:20px;
width: 10em;
border-right:black solid 4px;
height: 100%;
background: #EEE;
}
body > #content {
margin-left:12em;
margin-right:10px;
background: #CCC;
}

Geändert wird die Syntax der Selektoren dahingehend, dass von den CSS-2.0-spezifischen
Adressierungsmöglichkeiten für Elemente Gebrauch gemacht wird. Diese werden vom
Internet Explorer ebenfalls nicht erkannt. Als Ergebnis ignoriert dieser Browser die
Formatdefinitionen für beide div-Bereiche komplett.
Stattdessen bekommt der IE eine nur für ihn lesbare
CSS-Datei spendiert. Dazu wird im HEAD-Bereich des HTML-Dokuments folgendes notiert:

Der IE interpretiert dieses Kommentar im Quelltext, und liest seine ie-fix.css Datei.

html, body {
overflow:hidden;
width:100%;
height:100%;
}
#navigation {
position:absolute;
top:20px;
left:20px;
padding-right:20px;
border-right:black solid 4px;
height: 100%;
background: #eee;
}
#content {
position:absolute;
top:0px;
left:200px;
margin-top:20px;
height:expression(document.body.clientHeight - 20 + "px");
width:expression(document.body.clientWidth - 200 + "px");
overflow:auto;
background: #ccc;
}

Nun sieht das ganze so aus, im Firefox und Co, ist aber kein unterschied zu sehen

Zunächst wird für die Basiselemente html und body festgelegt, dass diese die volle Breite und Höhe einnehmen. Gleichzeitig wird bestimmt, dass Inhalte, die länger oder breiter sind, einfach abgeschnitten werden (overflow:hidden, Überfluss unsichtbar). Die beiden div-Bereiche werden daraufhin beide absolut positioniert. Bis auf die Art der Positionierung sind die Formatdefinitionen für den Bereich navigation die gleichen wie in der normalen CSS-Datei. Bei den Definitionen für content gibt es hingegen einige Unterschiede. Mit position:absolute, top und left muss dessen gewünschte Anfangsposition bestimmt werden, da er ja absolu