In den letzten Tagen nach Erscheinen der neuen WordPress-Version häuften sich in den Blogs die Artikel zum Thema Speichererhöhung in Verbindung mit der Fehlermeldung

Fatal error: Allowed memory size of … bytes exhausted …

WordPress Deutschland hat dazu am 16. Juni 2009 eine gute Erklärung in den FAQ veröffentlicht. Besonders der Trick mit der Sprachdatei ist interessant (senkt bei mir den Speicherverbrauch um 13%).
Am gleichen Tag wurde dazu ebenfalls ein kleiner Beitrag auf bueltge.de veröffentlicht.
Beide weisen auf das Plugin „WP-Memory-Usage“ von Alex Rabe hin, das

• die Version
• den verfübaren Speicher
• sowie den aktuellen Speicherbedarf der WordPress-Installation

anzeigt.
Dieses Plugin ermittelt mit den PHP-Funktionen memory_get_usage() den aktuellen Speicherverbrauch und mit ini_get(’memory_limit’) die Lokal zugewiesene Speichergröße.

An dieser Stelle möchte ich Ihnen gerne einen tieferen Einblick in die Materie bieten.

Der Arbeitspeicher (memory_limit) für die einzelnen Hosts auf dem Webserver wird an 2 Stellen festgelegt. Die erste allumfassende Einstellung erfolgt durch den Webhoster in der php.ini.
In dieser wichtigen Konfigurationsdatei sind sämtliche Einstellungen für den PHP-Server hinterlegt. Verständlicherweise unterbinden Web-Hoster den Zugriff auf diese Datei, da sich viele Benutzer einen Server teilen. Mietet man sich einen sogenannten Root-Server sieht das natürlich anders aus.
Dort wird (unter vielen anderen Einstellungen) der memory_limit eingestellt, welcher dann als sogenannter master value für den gesamten Server und den darauf befindlichen einzelnen Hosts die maximal zur Verfügung stehende Speichergröße für PHP-Scripte vorgibt.

Dieser Wert bzw. die gesamte php.ini kann mit der PHP-Funktion phpinfo() ausgelesen werden. Wenn Sie das gerne machen möchten, dann führen Sie folgende Schritte aus:

• Legen Sie im Backend-Bereich von Wordpress eine neue Seite mit dem Titel Backend und einem kurzen Text an
• Stellen Sie die Sichtbarkeit rechts oben in der “Veröffentlichen-Box” auf Privat (dadurch kann die Seite erstens nur von Ihnen und zweitens nur wenn Sie eingeloggt sind aufgerufen werden. Die php.ini sollte aus Sicherheitsgründen nur von Ihnen einsehbar sein)
• Fügen Sie nach dem Speichern der Seite folgendes in die page.php unterhalb des “Loop” Ihres Theme-Ordners ein:

   /* .../wp-content/themes/ihr_theme/page.php */
  <?php
  if(is_page('backend')){
  phpinfo();
  }
  ?>
   /* Speichern nicht vergessen!
  Anmerkung: Anstatt die page.php zu verändern,
  kann diese auch kopiert und umbenannt werden
  (backend.php).
  Diese kann dann als Template beim Neuanlegen
  der Seite ausgewählt werden.
  Dadurch halten Sie die page.php "sauber"
  und können in Zukunft noch weitere php-Scripte
  einfügen ...*/
  

• Rufen Sie nun die zuvor angelegte Seite auf, in dem Sie deren Permalink (z.B. http://ihre_domain/backend) in die Adresszeile Ihres Browser eingeben. Dazu müssen Sie sich wie schon erwähnt vorher eingeloggt haben (der Browser speichert das als Cookie ab).

Nun sollte die Seite mit der gesamten php.ini angezeigt werden. Suchen Sie dort (STRG+F) nach memory_limit. Es werden 3 Spalten angezeigt:

• Directive –> gibt den Namen an
• Local Value –> gibt den lokal verfügbaren maximalen Speicher an (… der Ihrer WordPress-Installation in Ihrem Host-Verzeichnis zur Verfügung steht)
• Master Value –> gibt den durch Ihren Webhoster freigegebenen bzw. vorgegebenen maximalen Speicher an (dieser Wert gildet auf dem gesamten Server für alle Hosts)

Somit wären wir auch schon bei der zweiten Einstellungsmöglichkeit, dem local value. Local value … master value? Etwas verwirrend, oder?! Ging mir zuerst genauso. Vor allem das Zusammenspiel bzw. die Abhängigkeit brachte mich etwas ins Grübeln.

Wenn der Webhoster das maximale Speicherlimit für alle Hosts auf dem Server schon durch den master value in der php.ini festgelegt hat (auf die ich keinen Zugriff habe), kann ich diesen Wert etwa Lokal in meinem eigenen Verzeichnis hochschrauben und mir so mehr Speicher zuschieben, als alle anderen zur Verfügung haben?

Richtig, genau so ist es!

Aber nür, wenn der Webhoster das auch zuläßt.
Dazu gibt es verschiedene Möglichkeiten. Eine wäre, in der wp-config.php die globale Variable WP_MEMORY_LIMIT neu zu setzen und ihr einen Wert zuzuweisen, der höher liegt als die Grundeinstellung von 32 MB (definiert in der wp-settings.php).

<?php
...
define('WP_MEMORY_LIMIT', '64M');
...
?>

Wobei die 65 MB nur ein Beispiel sind, ich konnte den Wert bei mir auch höher schrauben, …

… was mich etwas stutzig machte. Also habe ich mal bei meinem Webhoster nachgefragt und bekam folgende Antwort, die ich nur in Auszügen veröffentliche:

Hallo,

erst einmal möchte ich Ihnen mitteilen, dass ich bisher sehr zufrieden bin.
Und nun eine kleine Frage:
Ist es von Ihnen gewollt, dass der ‘memory_limit’ in der ‘php.ini’ lokal per htaccess oder ini_set() überschrieben werden kann?

Gruß
Jörg Mathuszczyk

Darauf kam folgende Antwort:

Hallo Herr Mathuszczyk,

vielen Dank für Ihre Anfrage.

Dies ist gewollt, da einige Scripte dies benötigen. Wenn sich dadurch jedoch feststellt, das besagter Kunde damit den Server überlastet müssen wir einschreiten.

Bei weiteren Fragen stehen wir Ihnen gern zur Verfügung.

…

An dieser Stelle noch mal vielen Dank an den Support für die (sehr) schnelle Antwort.

Kommen wir nun zu einer weiteren Möglichkeit, den memory_limit hochzusetzen.
Dazu benutzen wir die PHP-Funktion ini_set() und fügen diese an Stelle der zuvor genannten WP_MEMORY_LIMIT in die wp-config.php ein.

<?php
...
ini_set('memory_limit', '65M');
...
?>

Auch dies funktionierte bei mir ohne Probleme. Ist auch logisch, denn beim Setzen von WP_MEMORY_LIMIT wird haargenau die gleiche Funktion benutzt, um den memory_limit festzulegen. Dies geschieht per Zuweisung in der wp-settings.php.

<?php
/**
 * Used to setup and fix common variables and include
 * the WordPress procedural and class library.
 *
 * You should not have to change this file and allows
 * for some configuration in wp-config.php.
 *
 * @package WordPress
 */

if ( !defined('WP_MEMORY_LIMIT') )
	define('WP_MEMORY_LIMIT', '32M');

if ( function_exists('memory_get_usage') && ( (int) @ini_get('memory_limit') < abs(intval(WP_MEMORY_LIMIT)) ) )
	@ini_set('memory_limit', WP_MEMORY_LIMIT);

 ...

Eine dritte Möglichkeit ermöglicht das Speicherlimit in der .htacces-Datei festzulegen, indem dort folgendes eingefügt wird:

php_value memory_limit 65M

# BEGIN WordPress

RewriteEngine On
...

Dieser Weg war bei mir ebenfalls möglich, muss aber wiederum durch den jeweiligen Webhoster zugelassen werden.

Auch wenn es verlockend klingt, den Wert gleich um ein vielfaches hochzusetzen, rate ich davon dringend ab. Ein schlecht programmiertes oder fehlerhaftes Script (Plugin, …) könnte so den gesamten zur Verfügung stehenden Arbeitsspeicher “in Beschlag nehmen”, was den gesamten Server beinträchtigen würde. Aus diesem Grund empfehle ich einen eher kleinen Wert mit etwas Spielraum nach oben (65 MB sollten bei einem WordPress-Blog dicke ausreichen).
Ansonsten würde ich nach Plugins Ausschau halten, die “mächtig Hunger haben”. Eine schnelle Senkung kann durch die oben bereits angesprochene Deaktivierung der deutschen Sprachdatei in der wp-config.php erzielt werden.

define ('WPLANG', 'de_DE');
 /* hier 'de_DE' entfernen */
define ('WPLANG', '');

Durch diese Maßnahme wird das Backend von WordPress zwar wieder in Englisch angezeigt (Grundeinstellung), senkt aber den Ressourcenverbrauch um einiges. Wenn Sie nicht erst seit kurzem mit WordPress arbeiten, sollte das nicht weiter stören.

Bietet Ihr Webhoster von Haus aus nur wenig Arbeitspeicher und das Limit kann auch nicht lokal durch die genannten Maßnahmen erhöht werden, wäre ein Wechsel anzuraten. Dadurch treten auch in Zukunft solche Probleme gar nicht erst auf.

In der Programmierung, besonders bei größeren Projekten/ Scripten, wird der Quellcode schnell unübersichtlich und schwer wartbar. Wer schon einmal ein Programm/ Script mit mehr als 1000 Zeilen geschrieben hat, wird mir da sicherlich zustimmen. Aus diesem Grund empfiehlt es sich, den Quellcode zu kommentieren und übersichtlich einzurücken. Zu dem können if/else-Kontrollstrukturen und Datenbankabfragen verkürzt dargestellt werden. In diesem Tutorial möchte ich Ihnen dazu einige Beispiele bieten.

Kommentare einsetzen
In der Programmierung sind Kommentare (Comments) meiner Meinung nach das Salz in der Suppe. Sie ermöglichen es uns auch noch nach Monaten, jeden Abschnitt des jeweiligen Quellcodes besser und somit schneller zu verstehen. Dies ist besonders wichtig, wenn fremder (nicht von uns selbst programmierter) Code vorliegt. Ich habe mir angewöhnt, besonders komplexe Passagen direkt mit einem Kommentar zu versehen. In PHP gibt es dazu zwei Möglichkeiten:

/*Einzeiliger Kommentar*/
// einzeilige Kommentare können mit ’//’ (zwei Backslashes) in den Quellcode eingefügt werden

/*Mehrzeiliger Kommentar*/
/* mehrzeilige Kommentare werden mit einem
* beginnenden ’/*’ (Slash und folgendem Sternchen)
* eingeleitet und mit ’*/’ (also umgekehrt)
* wieder abgeschlossen.
* In jeder neuen Zeile empfehle ich ein
* Sternchen als Einleitung einzufügen
*/

Auch wenn Kommentare Mehrarbeit bedeuten, möchte ich Ihnen nahelegen, davon ausgiebig Gebrauch zu machen. Spätestens wenn ein älteres Projekt verändert/angepasst werden muss, werden sie dies zu schätzen wissen. Zudem wird der Lerneffekt verstärkt, da Sie sich mit dem erstellten Quellcode intensiver auseinandersetzen.

Quellcode einrücken
Genau wie beim Kommentieren erfordert das durchgehende Einrücken des Quellcodes zunächst mehr Aufwand (obwohl es bei mir eigentlich schon automatisch erfolgt). Aber neben der verbesserten Lesbarkeit wird durch diese Maßnahme vor allem die Fehlersuche enorm erleichert. Dabei haben sich folgende zwei Möglichkeiten/ Stile etabliert (Einrückunsstile)

/* Stil 1 */
if($ausruf == 'Hallo') {
	echo "Er hat 'Hallo' gerufen";
} else  {
	echo "Er hat nichts gerufen";
}

/* Stil 2 */
if($ausruf == 'Hallo')
{
	echo "Er hat ‘Hallo’ gerufen";
}
else
{
	echo "Er hat nichts gerufen";
}

Die Einrückungstiefe kann dabei getrost selbst bestimmt werden. Einige nehmen einen ganzen ‘Tab’, andere nur zwei oder drei Leerzeichen. Ich denke, dabei kommt es auf die Verschachtelungstiefe an.

Ich persönliche ertappe mich regelmäßig dabei, dass ich Mal den einen und Mal den anderen Einrückungsstil verwende. Den ersteren Aufgrund meiner Java/C++-Erfahrung (der etwas mehr Platz spart) und den zweiten hinsichtlich PHP (den ich als etwas übersichtlicher empfinde). Des Weiteren achte ich darauf, dass z.B. Gleichheitszeichen bei Zuweisungen ordentlich untereinanderstehen.

$string    = 'Hallo Welt';
$boolean   = true;
$int       = 5;
...

Entscheiden Sie selber, wie Sie Ihren Quellcode überschaubarer gestalten! Viele Editoren besitzen bereits eine automatische Einrückung oder das sogenannte Syntaxhighlighting, wodurch dieser Schritt vereinfacht wird.

Quellcode verkürzen
Dies ist ein heikles Thema und es gehört viel Erfahrung und eine Menge Grips dazu, Algorithmen oder einfacher gesagt die Programmierlogik zu verkürzen. Während der ersten Schritte, in denen man sich die Basics der Programmierung aneignet, kommt es meistens zu ausufernden Konstrukten, um z.B. eine Anweisung zu programmieren.
Ausgiebiger Gebrauch von verschachtelten if/else-Kontollstrukturen führen zwar letztendlich ebenfalls zum Ziel, sind jedoch fehleranfälliger und verlangsamen das Programm/ Script (mal ganz abgesehen von der bereits zuvor angesprochenen schlechteren Übersichtlichkeit).

Während diverser Weiterbildungen war es ein beliebter „Wettbewerb“ unter den Teilnehmern, alles möglichst kurz zu programmieren. Die Königsklasse hierbei war der legendäre „Einzeiler“: Unter Verwendung der ausgeklügelsten Techniken (Stichworte: Modulo, Reguläre Ausdrücke, …) wurde mehrzeiliger Code zu einer einzigen Zeile komprimiert.

Ich habe dabei ein ums andere Mal große Augen bekommen, mir dies aber möglichst nicht anmerken lassen !
Doch neben genug Gehirnschmalz und Erfahrung gibt es auch ein paar Techniken, die leicht erlernbar sind und den Quellcode ebenfalls kürzer und überschaubarer gestalten.
Eine Möglichkeit besteht darin, einfache if/else-Kontrollstrukturen in einer einzigen Zeile auszuführen:

/* Lange Version */

if(isset($_POST['color']))
{
	$backgroundcolor =  $_POST['color'];
}
else
{
	$backgroundcolor =  'white';
}

/* Kurze Version */
$backgroundcolor = (isset($_POST['color'])) ? ($_POST['color'] : 'white';

Das Beispiel ist aus der Luft gegriffen und bezieht sich auf PHP. Eine ähnliche Syntax gibt es auch für Java und C++ (…). Es handelt sich hierbei um die sogenannten ‘Ternary Operators’ (engl. Dreifach-Operatoren). Am Anfang etwas gewöhnungsbedürftig, möchte man sie später (einmal verinnerlicht) nicht mehr missen.
Mit dem PHP-Befehl sprintf läßt sich der Quellcode ebenfalls oftmals verürzt und übersichtlicher darstellen.

/* Beipiel herkömmliche Schreibweise */
<?php
$query = "SELECT telefon
          FROM kunde
          WHERE vorname = '".addslashes($vorname)."'
          AND name = '".addslashes($name)."'
          AND strasse = '".addslashes($strasse)."'";
$result = mysql_query($query);
...
/* Nicht sehr übersichlich, oder?!
Dann schauen Sie sich mal dieses Beispiel an*/

$query = sprintf("SELECT telefon
                  FROM kunde
                  WHERE vorname= '%s'
                  AND name = '%s'
                  AND strasse = '%s'",
                  addslashes($vorname),
                  addslashes($name),
                  addslashes($strasse));
$result = mysql_query($query);
?>

Hierbei werden im Quellcode Platzhalter (Literale) eingesetzt, die anschließend in der gleichen Reihenfolge durch die angefügten Parameter ersetzt werden.
Ein %s bedeutet hierbei, dass an dieser Stelle ein String gesetzt wird. Es können auch Dezimalzahlen (%d) oder Zahlen vom Typ float (%f) übergeben werden. Zudem lassen sich neben anderen Angaben auch Ausrichtung und Länge einfügen, auf die ich hier aber nicht weiter eingehen werde (weiterführende Informationen).

Tun Sie sich (und eventuell anderen) einen Gefallen und schreiben Sie lesbaren Quellcode!

Web 2.0 ist in aller Munde. Nachrichten werden zwischen einzelnen Webseiten ausgetauscht (Stichwort Abonnementdienste wie RSS/Atom). Weblogs schießen wie Pilze aus den Boden. Dynamische Webseiten (DHTML) sowie DOM-Scripting sind in der heutigen Zeit zum Standard geworden. Menüs klappen auf, Texte werden eingeblendet, Seiteninhalte lassen sich einfach verschieben … überall bewegt sich etwas.

Es werden Techniken eingesetzt, die Web-Anwendungen wie Desktop-Anwendungen aussehen lassen (Stichwort Ajax). Rein statische Seiten fristen in den Weiten des Internet nur noch ein Schatten-Dasein.
Und wenn wir ehrlich sind, haben wir uns daran gewöhnt.

Wir erwarten, das Webprogrammierer -und Designer die Seiten so gestalten, das sie attraktiv und „usability“ daher kommen. Das Webseiten auch körperlich beeinträchtigten Menschen zugänglich sind (Stichwort Barrierefreiheit) und nach Möglichkeit in jedem Browser … zumindest einigermaßen … ähnlich aussehen.

Es können Videos und Fotos betrachtet, Musik gehört und Spiele gespielt werden. Animationen, erstellt mit Java, Flash, Javascript oder als GIF-Bild, lassen Webseiten „leben“ (wenn sie uns nicht gerade stören).

Und da ich von diesen Dingen einfach fasziniert bin, habe ich mich daran gesetzt, dem Stylesheet meines Blogs mit Hilfe von PHP ebenfalls etwas Dynamik einzuhauchen.

Anleitung dynamisches Stylesheet
Zuerst muss die Endung der normalen Stylesheet-Datei …

style.css

… durch …

style.css.php

… ersetzt werden.
Eingebunden wird die neue dynamische Stylesheet-Datei wie gewohnt im Head-Bereich der Seite:

<!DOCTYPE html PUBLIC …
<html>
  <head>
    <link rel="stylesheet" type="text/css" href="pfad_zur_datei/style.css.php" />
  </head>
  <body>
  ...
  </body>
</html>

Nun wird im neuen Stylesheet innerhalb eines PHP-Blocks der Content-type angegeben, da der Server beim Parsen sonst davon ausgeht, dass es sich hierbei um eine gewöhnliche HTML-Datei handelt. Dazu wird im Kopf der css.php-Datei folgendes deklariert:

<?php
  header('Content-type: text/css');
   /*
    An dieser Stelle wird der Quellcode eingefügt.
    Mehr dazu später …
   */
?>

/* Begin Typography & Colors */

body {

	font-size: 62.5%; /* Resets 1em to 10px */

	font-family: Arial, Helvetica, Sans-Serif;

	background: #063164; 

	color: #999;

	text-align: center;

	}
…

Nun „weiß“ der Server Bescheid, gibt die PHP-Datei als CSS-Datei an den Browser und dieser kann die Datei anschließend richtig interpretieren.

Erklärung

<?php
 …
?>

Da mir diese Webseite neben dem Bloggen auch als „Bastelstube“ dient (siehe auch mein Kolophon), um Webtechniken anzuwenden, hatte ich mir überlegt, die Hintergrundfarbe beim ersten Aufruf der Seite zufällig aus einem Pool von Hintergrundgrafiken generieren zu lassen. Diese sind bereits als PNG-Dateien auf dem Webspace hinterlegt und werden über den Name eingebunden.

   bg_hellgruen.png
   bg_blau.png
   bg_beige.png
   ...

Dazu legte ich zunächst ein Array an, in das die Namen derjenigen Grafiken einfügte wurde, die später angezeigt werden sollen.

$farben = array('weiss', 'schwarz', 'blau', 'gruen',
        'beige', 'hellblau', 'hellgruen', 'rose',
        'sand', 'grau_gruen');

Aus diesem wird ein zufälliges ausgewählt

 $zufall = array_rand($farben, 1);/* ... die 1 kann bei einem
Wert auch weggelassen werden */
 $zufalls_farbe = $farben[$zufall];

und danach in einem switch-Kontrollblock die Textfarbe an die jeweilige Hintergrundfarbe angepasst, um einen ausreichenden Kontrast zu garantieren.

switch ($zufalls_farbe) {
    case 'weiss':
     $_SESSION['textcolor'] = '#222';
        break;
    case 'beige':
      $_SESSION['textcolor'] = '#222';
        break;
    case 'hellblau':
      $_SESSION['textcolor'] = '#222';
        break;
    case 'oliv':
      $_SESSION['textcolor'] = '#222';
        break;
    case 'rose':
      $_SESSION['textcolor'] = '#222';
        break;
    case 'hellgruen':
      $_SESSION['textcolor'] = '#222';
        break;
    case 'sand':
      $_SESSION['textcolor'] = '#222';
        break;
    case 'grau_gruen':
      $_SESSION['textcolor'] = '#222';
        break;
    default:
      $_SESSION['textcolor'] = '#aaa';
        break;
  }

Anstatt des switch-Kontrollblocks kann natürlich auch eine if-Abfrage eingesetzt werden. Ich habe dies lediglich auf diese Art gelöst, um wieder mal mit der switch-Syntax zu arbeiten. Hinsichtlich der Geschwindigkeit dürften sich beide Möglichkeiten (auch bei größeren Datenmengen) nicht wesentlich unterscheiden (unter Programmierern führt dieser Aspekt gern zu ausufernden Diskussionen –> kürzer, schneller …).

Um die einmal ausgewählte Hintergrundfarbe während des Besuchs beizubehalten, wird noch eine Session-Variable erstellt. In dieser wird beim ersten Einlesen der css.php-Datei ebenfalls die zufällig generierte Hintergrundfarbe gespeichert.

 $_SESSION['color'] = $zufalls_farbe;

Dies wurde für die Textfarbe bereits schon im switch realisiert.
Normalerweise legt der Browser die CSS- Datei (und noch einige andere Dateien, z.B. Grafiken) im eigenen Cache-Speicher ab und ein erneutes Einlesen ist bei Seitenwechsel nicht mehr nötig. Dadurch kann die Webseite nach dem ersten Aufruf schneller geladen werden.

Da dies aber nicht garantiert ist (was mir meine Erfahrungen auch bestätigen), wird bei jedem Einlesen überprüft, ob diese Session-Variable existiert. Sollte dies der Fall sein, erfolgt keine erneute Auswahl der Hintergrundfarbe, sondern es wird dann der gespeicherte Wert der Session-Variable verwendet. Dafür wird der gesamte Quellcode in eine Abfrage eingeschlossen, welche direkt überprüft, ob die Session-Variable bereits existiert.

if(!isset($_SESSION['color'])) {
...
}
/* Nur wenn die SESSION-Variable noch nicht (!)
existiert, wird eine neue Farbe ausgewählt
*/

Nun werden die gefüllten Variablen an den jeweiligen Stellen im normalen Stylesheet-Bereich eingefügt und mit dem echo-Befehl ausgegeben.

#header {
	background: transparent url('images/layout/bg_<?php
        if(isset($_SESSION['color'])) echo $_SESSION['color'];
        else echo 'bg_weiss'; ?>.png') repeat-y top center;
        /* Der else-Block dient nur als Beispiel
        und dürfte nicht ausgeführt werden*/
	}
...

#content {
	font-size: 1.35em;
        color:<?php if(isset($_SESSION['textcolor'])) echo $_SESSION['textcolor']; else echo '#222'; ?>;
	}
...

Durch diese Maßnahme bekommt jeder Besucher der Seite beim ersten Aufruf eine zufällige Hintergrundfarbe, die auch bei Seitenwechsel erhalten bleibt (es sei denn, es wird ein anderer Hintergrund über den Einstellungen-Button gewählt).

Aber anstatt der Hintergrundfarbe könnte auch der body-Hintergrund geändert werden. In dem PHP-Bereich kann das ganze Potenzial dieser Scriptsprache eingesetzt werden, um das Stylesheet den eigenen Bedürfnissen dynamisch anzupassen.
Auch eine Darstellung, welche an die jeweilige Tageszeit angepasst wird bzw. von dieser abhängig ist, kann so leicht realisiert werden (time-Funktion von PHP).

 /* H - Stunde im 24-Stunden-Format (00-23 ) */
if (date("H")>8 && date("H")<20){
$background = "#ffffff";
    $color = "#000000";
  } else {
    $background = "#000000";
    $color = "#ffffff";
  }

Doch es traten auch Probleme auf. Die Stylesheet-Anpassungen für die -Browser der Redmonder habe ich direkt im Stylesheet stehen und nicht wie sonst üblich über eine Browserweiche (Conditional Comments ) als zusätzliches Stylesheet eingebunden.
Die Separierung erfolgt über die “Holzhammer-Methode” mit dem !important-Hack:

/* Beispiel */
.navigation {
	display: block;
	text-align: center;
        /* 'Normale' Browser führen diese Zuweisung aus ... */
	margin-top: 10px !important;
        /* ... während der IE !important nicht kennt und diese
        Zuweisung interpretiert */
        margin-top:0px;
        /* Dies wird dann wieder von allen ausgeführt */
	margin-bottom: 60px;
	}

Diese Art, IE-Bugs zu beheben, sollte eigentlich nicht verwendet werden ( … um das Grund-Stylesheet sauber zu halten). Da ich jedoch bisher nicht viele Anpassungen vornehmen mußte, habe ich es auf diese (nicht besonders elegante Weise) gelöst.
Nach Umänderung meines Stylesheets zu einer PHP-CSS-Datei mit Content-Type-Deklaration wurde ich auch sofort bestraft und der Hack funktionierte aus mir unerklärlichen Gründen nicht mehr. Als Folge wurde meine Seite 3 Tage lang etwas “zerissen” im IE angezeigt, bis ich es als Firefox-Nutzer endlich gemerkt hatte. Dadurch wurde ich mal wieder daran erinnert, dass in der Programmierung umfangreiche Tests unabdingbar sind.
Nun hätte ich mein Grund-Stylesheet ändern und die IE-Anweisungen auslagern können. Ich entschied mich aber dafür, den PHP-Teil in eine separate Datei zu schreiben und zusätzlich in die Seite einzufügen. So können zukünftige weitere Schritte überschaubarer realisiert werden.

Ich hoffe, diese Einführung in dynamische Stylesheets war hilfreich für eigene Projekte.

Hier noch mal der gesamte Quellcode

<?php
session_start(); /* ... muss am Anfang eingefügt werden */
/* error_reporting(E_ALL)  und ini_set('display_errors', 'On') zur Fehlersuche */
error_reporting(E_ALL);
ini_set('display_errors', 'On');
header('Content-type: text/css');

/* Zufallshintergrund */
if(!isset($_SESSION['color'])) {

  $farben = array('weiss', 'schwarz', 'blau', 'gruen', 'beige', 'hellblau', 'hellgruen', 'rose', 'sand', 'grau_gruen');
  $zufall = array_rand($farben, 1);/* ... die 1 kann bei einem Wert auch weggelassen werden */
  $zufalls_farbe = $farben[$zufall];

  switch ($zufalls_farbe) {
    case 'weiss':
      $_SESSION['textcolor'] = '#222';
        break;
    case 'beige':
      $_SESSION['textcolor'] = '#222';
        break;
    case 'hellblau':
      $_SESSION['textcolor'] = '#222';
        break;
    case 'oliv':
      $_SESSION['textcolor'] = '#222';
        break;
    case 'rose':
      $_SESSION['textcolor'] = '#222';
        break;
    case 'hellgruen':
      $_SESSION['textcolor'] = '#222';
        break;
    case 'sand':
      $_SESSION['textcolor'] = '#222';
        break;
    case 'grau_gruen':
      $_SESSION['textcolor'] = '#222';
        break;
    default:
      $_SESSION['textcolor'] = '#ccc';
        break;
  }
  $_SESSION['color'] = $zufalls_farbe;
}
?>

#header {
	background: transparent url('images/layout/bg_<?php
             if(isset($_SESSION['color']))
                 echo $_SESSION['color'];
             else
                 echo 'bg_weiss'; ?>.png') repeat-y top center;
	}

#container_inside {
	background: transparent url('images/layout/bg_<?php
             if(isset($_SESSION['color']))
                 echo $_SESSION['color'];
             else
                 echo 'bg_weiss'; ?>.png') repeat-y top center;
	}

#content {
	font-size: 1.35em;
        color:<?php
            if(isset($_SESSION['textcolor']))
               echo $_SESSION['textcolor'];
            else
               echo '#222'; ?>;
	}

Um mit PHP eine Verbindung zu einer mySQL-Datenbank herzustellen, benötigt man unter anderem die mysql_connect()-Funktion von PHP.

Dabei wird es auf Dauer etwas mühselig, immer wieder auf´s Neue alle benötigten Funktionen einzubringen. Aus diesem Grund bietet es sich an, für den Zugriff auf eine Datenbank eine eigene objektorientierte Klasse zu programmieren, die einfach in jedes neue Projekt eingebunden wird (includiert oder required).
Für mein eigenes kleines CMS hatte ich vor längerer Zeit mal eine Klasse geschrieben, die nach Instanziierung eines Objektes folgendes ermöglicht:

• Verbindung zur mySQL-Datenbank herstellen
• Auswahl einer Datenbank/ Tabelle
• Senden einer SQL-Anfrage
• Daten holen (in einem Array)
• Anzahl Datensätze anzeigen
  (z.B. zur Überprüfung).

Schritt für Schritt von oben nach unten:

<?php
//dbconnect.class.php

class 	DBconnect //Klassenname
{
     private $ers; //Hilfs-Variable

     ...

Zunächst kommt nach dem einleitenden PHP-Tag der spätere Name der Datei. Dieser wird auskommentiert und ist nicht zwingend notwendig, sollte ordnungshalber aber aufgeführt werden (Name, Erstellungsdatum … lasse ich mal außen vor).

Die Klasse bekommt nun ihren Namen, den ich am Anfang groß schreibe (genau wie in Java …) und wird durch das Schlüsselwort public für den öffentlichen Zugriff freigegeben. Die folgende Variable $ers dient innerhalb der Klasse als Helferlein und ist durch das Schlüsselwort privat nur innerhalb der Klasse verfügbar (kann nicht von außen angesprochen werden).
Darauf folgt der Konstruktor:

...

public function __construct($datenbank,$host="127.0.0.1",
                   $benutzer="root",$passwd="passwort")
{
  /*
  mysql_connect — ÖFFNET eine VERBINDUNG zu einem MySQL-
  Server und gibt eine Meldung aus, falls ein
  SQL-Fehler erfolgt
  */
  $db_link = mysql_connect($host,$benutzer,$passwd,TRUE)
              or die (mysql_error());
 /*
 ------------------------------------------------------------
 Anmerkung: Anstatt das Script über '... or die(...)' einfach
 abzubrechen, kann auch eine Fehlermeldung wie folgt ausgegeben
 werden.
 if(!$db_link) {
    trigger_error("Es konnte keine Verbindung zur Datenbank
    hergestellt werden.", E_USER_ERROR);
 }

 -------------------------------------------------------------
*/

  /*
  mysql_select_db — AUSWAHL einer MySQL DATENBANK
  */
  mysql_select_db($datenbank) or die("Konnte die Datenbank nicht waehlen.");
}

...

Der Konstruktor wird automatisch bei Erzeugung/ Instanziierung eines Objektes der Klasse DBconnect aufgerufen und erwartet Parameter (Datenbankname, Host, Benutzername und Passwort).
Wird stets nur auf eine Datenbank zugegriffen, dann kann den Parametern direkt in der Klasse ein Wert zugewiesen werden. Die Zuweisung erfolgt aber nur dann, wenn kein Wert für den jeweiligen Parameter übergeben wird.
In unserem Beispiel müßte für die Verbindung zur Datenbank lediglich der Name der Tabelle bei der Objekterzeugung mit übergeben werden. Die restlichen Informationen werden der Zuweisung (rot dargestellt) entnommen. Übergibt man aber nicht nur den Name der Tabelle, sondern zum Beispiel ein anderes Passwort (…), dann müssen alle Parameter in der richtigen Reihenfolge von links nach rechts übergeben werden (und die vordefinierten zählen dann nicht). Das bedeutet, dass zusätzlich zum Passwort auch der Benutzername übergeben werden muss, da dieser vor dem Passwort in der Parameterübergabe liegt.

Dies soll nur der Vollständigkeit halber verdeutlichen, dass einem Parameter so wie oben auch ein fester Wert zugewiesen werden kann.
Würde jetzt der Tabellenname ebenfalls einen festen Wert erhalten, dann bräuchte man überhaupt keinen Parameter übergeben (vorausgesetzt, die Werte stimmen mit denen der anzusprechenden Datenbank überein).
Ich merke, dass ich schon wieder viel zu viel schreibe und abdrifte, daher bremse ich hier etwas ab!
Durch den so definierten Konstruktor könnte nun im jeweiligen Script, wo unsere Klasse eingebunden wurde, schon ein Objekt erzeugt werden:

$datenbankverbindung = DBconnect('tabellenname');

// oder bei einer anderen Datenbank

$datenbankverbindung = DBconnect('tabellenname','127.0.0.1','willi','geheim');

Dadurch wird aber erst die Verbindung hergestellt.
Kommen wir nun weiter zu den Funktionen (auch Methoden genannt), durch die nun mit der Datenbank kommuniziert werden kann, nachdem die Verbindung aufgebaut wurde.

function sql($sql_query)
  {
      return $this->ers = mysql_query($sql_query)
      or die ('Anfrage fehlgeschlagen');
      /*mysql_query — SENDET eine ANFRAGE an MySQL*/
  }

function data()
  {
      return mysql_fetch_row($this->ers);
      /*mysql_fetch_row — LIEFERT einen DATENSATZ
        als indiziertes ARRAY*/
  }

function anzahl()
  {
      return mysql_num_rows($this->ers);
      /*mysql_num_rows — LIEFERT die ANZAHL der
        DATENSÄTZE*/

  }

function __destruct()
  {
      mysql_close();
      /*mysql_close — SCHLIEßT die VERBINDUNG zur Datenbank*/

  }

Die erste Funktion sql ermöglich es, durch die PHP-Funktion mysql_query(’string’) ein SQL-Statement an die Datenbank zu stellen (SELECT, UPDATE, DELETE, …).
Bei den weiteren Funktionen sollte klar sein, was sie bewirken. Wobei die __destruct-Funktion eigentlich nicht nötig ist, da nach Beendigung des jeweiligen Scriptes die Verbindung sowieso getrennt wird. Jedoch kann es vorkommen, dass mehrere Verbindungen hergestellt werden sollen …!
Was hat man nun gewonnen? Dazu sehen Sie sich bitte folgende Beispiele an.
Ohne DBconnect-Klasse

$db_link = mysql_connect($host,$benutzer,$passwd,TRUE)
or die (mysql_error());

mysql_select_db('tabellenname')
or die("Konnte die Datenbank nicht waehlen.");

$sql_query = 'SELECT * FROM datenbank';

$ressource = mysql_query($sql_query)
                  or die ('Anfrage fehlgeschlagen');

$anzahl = mysql_num_rows($ressource);

if($anzahl > 0){
     while ($data = mysql_fetch_array($ressource)){
     ...
     }
}

Mit DBconnect-Klasse:

$dbconnect = new DBconnect("tabellenname");
$sql_query = 'SELECT * FROM datenbank';
$dbconnect->sql($sql_query);
if($dbconnect->anzahl() > 0){
    while($data=$dbconnect->data()){
    ...
    }
}

Sehr viel kürzer und übersichtlicher, oder?! Man beachte im Beispiel ohne DBconnect-Klasse die Variable $ressource. Die Übergabe dieses Wertes erfolgt bei uns schon in der Klasse selber. Sie haben es bestimmt erkannt, dafür wurde unsere Variable $ers … unser Helferlein eingesetzt.
Der Quellcode steht zur freien Verfügung!

(Hier noch mal der gesamte Quellcode)

------------------------------------------------------------------------------------------------------------------------
<?php
//dbconnect.class.php
class 	DBconnect
{
	private $ers;

	 /*Konstruktor ... wird automatisch bei Erzeugung/ Instanziierung eines Objektes der Klasse
              aufgerufen und erwartet Parameter (Datenbankname, Host, Benutzername, Passwort)*/
	public function __construct($datenbank,$host="127.0.0.1",$benutzer="root",$passwd="passwort")
	{
		 /*mysql_connect — ÖFFNET eine VERBINDUNG zu einem MySQL-Server und
                          gibt eine Meldung aus, falls ein SQL-Fehler erfolgt*/
		$db_link = mysql_connect($host,$benutzer,$passwd,TRUE) or die (mysql_error());
		 /*mysql_select_db — AUSWAHL einer MySQL DATENBANK*/
		mysql_select_db($datenbank) or die("Konnte die Datenbank nicht waehlen.");
		 /*if(!$db_link) echo "Fehler DB-Verbindung";*/
	}

	function sql($sql_query)
	{
		return $this->ers = mysql_query($sql_query) or die ('Anfrage fehlgeschlagen');
                /*mysql_query — SENDET eine ANFRAGE an MySQL*/
	}

	function data()
	{
		return mysql_fetch_row($this->ers);
                /*mysql_fetch_row — LIEFERT einen DATENSATZ als indiziertes ARRAY*/
	}

	function anzahl()
	{

		return mysql_num_rows($this->ers);
                 /*mysql_num_rows — LIEFERT die ANZAHL der DATENSÄTZE*/

	}

	function __destruct()
	{
		mysql_close();
                /*mysql_close — SCHLIEßT die VERBINDUNG zur Datenbank*/
	}
}

?>

Diesen einfach in einen Editor ihrer Wahl kopieren und zum Beispiel als dbconnect.class.php speichern. In ein neues Projekt wird die Klasse direkt oben per include oder require eingebunden:

include("class/dbconnect.class.php");
 // oder 
require("class/dbconnect.class.php");
 // oder 
require_once("class/dbconnect.class.php");

Ich hoffe, ich konnte dem einen oder anderen die Vorteile einer Datenbank-Klasse näherbringen.

Captcha ist die Abkürzung für Completely Automated Public Turing test to tell Computers and Humans Apart und dient in Gästebüchern, Foren, Weblog und anderen Eingabe- bzw. Kontaktformularen als Möglichkeit zu entscheiden, ob die Eintragung der Daten durch einen Menschen oder maschinell durch ein Script ( BOT) erfolgt. Dazu wird ein Bild generiert, welches (meist verschleierte) Schriftzeichen enthält, die zur Überprüfung in ein Textfeld eingetragen werden müssen. Diese Aufgabe soll für den Menschen einfach zu bewältigen sein, für die Maschine dagegen eine Hürde darstellen und so vor Spam schützen.

Leider werden diese sogenannten Spam-Bots immer besser programmiert und setzen Mustererkennungs-Algorithmen ein, welche mittlerweile auch stark verschleierte Captchas auslesen können (wobei diese auch für den Mensch unleserlich werden) und somit den Schutz aufheben. Aus diesem Grund lassen sich Entwickler von Captchas immer neue Hürden einfallen, die dann im Gegenzug von der “dunklen” Seite wieder geknackt werden.

Um sich davon mal ein Bild machen zu können ist diese Seite interessant. In der mittleren Spalte wird angegeben, um wie viel Prozent das jeweilige Captcha keinen Schutz mehr bietet. Einen weiteren interessanten Artikel hierzu finden Sie auf der Seite der W3C Working Group (in Englisch).

Letztendlich kann man sagen, das Captchas nicht mehr “up to date” sind und vor allem hinsichtlich barrierefreiher Seiten wohl bald der Vergangenheit angehören. Vereinzelt sieht man auf Webseiten Captchas, welche auch eine Sprachausgabe erzeugen können … ein guter Schritt hinsichtlich der eben angesprochenen Barrierefreiheit wie ich finde.

Soll dennoch ein Captcha eingesetzt werden, dann sollte dieses mit weiteren “Hürden” kombiniert werden. Beispielsweise könnte ein weiteres Feld in das Formular eingebracht werden, welches durch CSS versteckt wird und frei bleiben muss. Da ein Spam-Bot in der Regel alles ausfüllt wäre er als Maschine entarnt und der Programmierer kann darauf eingehen. An vielen Stellen werden auch einfache Rechenaufgaben (Was ergibt 7+5?) oder Fragen gestellt (Das Gras ist …?). Eine weitere Möglichkeit besteht darin, einen Zeitwert beim Aufruf der Webseite zu speichern und diesen mit einem 2. Wert beim Abschicken des Formulars zu vergleichen. Spam-Bots füllen das Formular in wenigen Sekunden aus, ein Mensch benötigt da wesentlich mehr Zeit … hier sollte klar sein, was ich meine. Über die .htaccess-datei können ebenfalls Spam-Bots über die IP gesperrt werden …!

Aber eigentlich ging es bei diesem Artikel um das Programmieren eines Captchas. Ich hoffe, dass jetzt nicht die Lust dazu verflogen ist. Denn es ist eine schöne Übung, wie ich finde und zudem leicht verständlich. Außerdem wird ein guter Einstieg in die grafische Programmierung mit PHP geboten.

Auf gehts!

Wir programmieren ein Captcha

Öffnen Sie bitte Ihren gewohnten Standard-Editor, ich persönlich benutze dafür meist immer Notepad++. Der ist klein, fein und reicht mir. Für größere Projekte greife ich dann zumeist auf die PHP-Version von Eclipse zurück. In eine neue Datei geben wir den Anfang und den Endtag für PHP ein

<?php

?>

und speichern diese dann direkt an einem beliebigen Ort unter captcha.php ab. Danach sollte das Syntax-Highlighting aktiviert sein!

Für das Erzeugen der Zeichen bietet sich eine Funktion an

<?php
//capture.php
function generate(){

Zuerst erzeugen wir ein Array, welches wir mit Zeichen füllen

/*Beispiel-Array für die Zeichen und Zahlen*/
$zeichen = array('a','A','b','A','c','C','d','D','e','E','f','F',
                'g','G','h','H','i','I','j','J','k','l','m','n','o',
                'p','q','r','s','t','u','v','w','x','y','z',
                1,2,3,4,5,6,7,8,9);

Anstatt ein Array händig zu füllen könnte man auch mit ‘range’ die Zeichen/Zahlen erzeugen

/*
$abc=range("A","Z");
$abc2=range("a","z");
$zahlen=range(0,9);
...
*/

jedoch haben Sie mit dem Array was fürs Auge, daher kommentieren wir diesen Bereich aus.
Das Array mischen wir nun mit der PHP-Funktion shuffle

shuffle($zeichen);

Anschließend wählen wir 4 zufällige Einträge (array_rand) aus
dem Array aus. Und Sie haben Recht, ’shuffle’ könnte man sich somit auch sparen!

$rand_keys = array_rand($zeichen, 4);

Nun basteln wir aus den 4 Array-Einträgen einen String (Punkt-Operator) und wandeln die 4 Zeichen zu Großbuchstaben um (strtoupper ⇒ string to upper). Natürlich werden hierbei nur Buchstaben und keine Zahlen konvertiert. Lässt man diesen Schritt aus, dann können später auch Kleinbuchstaben (wie im Array angegeben) vorkommen.

return strtoupper($zeichen[$rand_keys[0]].$zeichen[$rand_keys[1]].
	$zeichen[$rand_keys[2]].$zeichen[$rand_keys[3]]);
}/* Schließende Klammer unserer Funktion nicht vergessen*/

Damit ist die Funktion für die Zeichen schon fertig. Ich habe hier bewusst PHP-Funktionen eingebaut, die eigentlich nicht nötig wären. Dazu gehört die shuffle-Funktion, da die array_rand-Funktion ebenfalls zufällige Zeichen aus dem Array raus zieht. Zudem schreiben wir auch Kleinbuchstaben in das Array und konvertieren diese dann vor der Rückgabe zu Großbuchstaben … ebenfalls unnötig. Aber so sehen Sie gleich mehrere Möglichkeiten, lernen mehr und können selber wählen, was Sie für richtig halten.
Damit ist der erste Schritt getan, kommen wir nun zum Bild.

Als erstes wird das Image erzeugt. Hierzu nutzen wir Funktion imagecreate(), wobei die Werte in der Klammer (Parameter) die Größe des Images in Pixel bestimmen .

$im = imagecreate(180, 100);// Image erzeugen

Darauf folgt die Erzeugung der Hintergrundfarbe mit der Funktion imagecolorallocate(), wobei hier als Parameter zunächst das zuvor erzeugte Image ($im) übergeben wird, welchem dann RGB-Werte zugeordnet werden:

$yellow = imagecolorallocate($im, 255, 255, 0);// Farben erzeugen
/*$black = imagecolorallocate($im, 0, 0, 0);*/

Damit ist das Image an sich schon fertig und könnte z.B mit imagegif() als gif-Datei abgespeichert werden (dazu gleich mehr).
Aber unser String fehlt noch und den erzeugen wir durch unsere zuvor erstellte Funktion, in dem wir diese einfach aufrufen:

$string = generate();// String erzeugen

Das war´s schon, in der Variablen (oder heißt es Variabel) ist nun unser zufällig erzeugter 4-Zeichen-String gespeichert und muss jetzt noch in das Image eingefügt werden. An dieser Stelle wird es ein klein wenig komplizierter. Die einzelnen Zeichen (oder auch Texte) werden einzeln nach und nach über eine for-Schleife in das Image eingefügt. Dafür nutzen wir die Funktion imagefttext(), welche mehrere Parameter beinhaltet:

imagefttext($im, $font_size, $rotation, $shadow_x, $shadow_y, $shadow_color, $font, $string[$i], array());

• $im steht für unser Image
• $font_size für die Schriftgröße
• $rotation für den Drehungswinkel des Zeichens
• $shadow_x und $shadow_y für die Position innerhalb vom Image
• $shadow_color für die Farbe des jeweiligen Zeichens
• $font für die Schriftart (die als .ttf-Datei vorliegen muss)
• $string[$i] beinhaltet das jeweilige Zeichen
• array() … keine Ahnung, aber nicht nötig

Schauen wir uns jetzt mal gemeinsam den Quelltext an:

for($i=1; $i <= 4; $i++)
{
	$ro = mt_rand(0, 90);// Zufallszahl Rotation
	$y = mt_rand(35, 100);// Zufallszahl y-Achse
	$font = rand(20, 40);// Schriftgröße
	$color = imagecolorallocate($im, rand(50,200), rand(50, 200), rand(50,200));
	/* Zufallsfarbe --> den RGB-End-Wert tiefer wählen, damit die Zeichen dunkler als der Hintergrund sind*/	

imagefttext ($im, $font, $ro, $i*36, $y, $color, 'arial.ttf', $string[$i-1]);
}

Zunächst beginnen wir mit einer for-Schleife, die genau 4x den Schleifenkörper durchläuft. Bei jedem einzelnen Durchlauf wird durch die imagefttext-Funktion ein Zeichen aus unserem Zeichen-Array in das Image geschrieben ($string[$i-1]). Beim ersten Durchlauf enthält die Zählvariable den Wert 1, der bei jedem weiteren Durchlauf um 1 ($i++) erhöht wird. Da unsere $string-Array aber mit dem Index 0 für das erste Zeichen beginnt, müssen wir den Wert wie oben angegeben ‘jede Runde’ um den Wert 1 reduzieren, um das jeweilige Zeichen zu erhalten. Ich denke, dass sollte klar sein.
Nun erzeugen wir die einzelnen Werte wie Rotation ($ro), Position ($y), Schriftgröße ($font) und Zeichenfarbe ($color) mit Hilfe der Zufalls-Funktion rand(), der wir als Parameter einen Wertebereich übergeben. So kann das jeweilige Zeichen zum Beispiel durch Zufall von 0°-90° gedreht werden (Rotation). Die y-Position verläuft innerhalb von 35-100 Pixel (also innerhalb vom Image, welches 100 Pixel hoch ist). Die Schriftgröße variiert zwischen 20 und 40 Pixel. Dazu kommt ein Zufalls-RGB-Wert für die Farbe des jeweilgen Zeichens. Hierbei wurde der Endwert bewußt auf maximal 200 (von möglichen 255 ⇒ weiss) beschränkt, damit das Zeichen nicht zu hell wird und somit vom Benutzer nur noch schlecht oder gar überhaupt nicht mehr gelesen werden kann (sollte der Hintergrund dunkel sein, verhält sich das entsprechend anders).
Der Wert für die x-Position (horizontal) wird einfach dadurch erzeugt, das wir den jeweiligen Wert der Zählvariable mit 36 multiplizieren. Damit bleibt das jeweilige Zeichen auf jeden Fall innerhalb von unserem Image (wir erinnern uns ⇒ 180 Pixel breit), wandert aber automatisch bei jedem neuen Schleifendurchlauf in Folge der höheren Zählvariable weiter auf der y-Achse nach rechts. Somit liegen die Zeichen nebeneinander und verdecken sich nicht eventuell untereinander.
Nun muss noch eine Schriftdatei eingebunden werden, die entweder im gleichen Ordner liegt (wie im Beispiel zu sehen) oder aber per Pfadangabe eingebunden wird. Diese finden Sie zum Beispiel bei den Betriebssystemen der Redmonder unter

C:\WINDOWS\FONTS\ bzw. C:\WINNT\Fonts\

Zum Abschluss wird das Image als gif-Datei gespeichert (hier sind auch andere Bildtypen möglich) und per echo-Befehl ausgegeben:

imagegif($im, "captcha.gif");
echo "<img src='captcha.gif' border='2'>";
}
?>

Das schöne daran ist, das bei jedem Neuaufruf unseres Captcha-Scriptes die vorherige Bild-Datei durch das neue Image überschrieben wird.

(Hier noch mal der gesamte Quellcode)

<?php
//capture.php

function generate()
{
	$zeichen = array('a','A','b','A','c','C','d',
      'D','e','E','f','F','g','G','h','H','i','I','j','J,
      'k','l','m','n','o','p','q','r','s','t',
      'u','v','w','x','y','z',1,2,3,4,5,6,7,8,9);
	/*
	$abc=range("A","Z");
	$abc2=range("a","z");
	$zahlen=range(0,9);
	*/

	shuffle($zeichen);
	$rand_keys = array_rand($zeichen, 4);

	return strtoupper($zeichen[$rand_keys[0]].$zeichen[$rand_keys[1]].
	$zeichen[$rand_keys[2]].$zeichen[$rand_keys[3]]);
}

//------------------------------------------------------------------------------------------

$im = imagecreate(180, 100);// Image erzeugen
$yellow = imagecolorallocate($im, 255, 255, 0);// Farben erzeugen
$black = imagecolorallocate($im, 0, 0, 0);

$string = generate();// String erzeugen

for($i=1; $i <= 4; $i++)
{
	$ro = mt_rand(0, 90);// Zufallszahl Rotation
	$y = mt_rand(35, 100);// Zufallszahl y-Achse
	$font = rand(20, 40);// Schriftgröße
	$color = imagecolorallocate($im, rand(50,200), rand(50, 200), rand(50,200));
	/* Zufallsfarbe --> den RGB-End-Wert tiefer wählen, damit die Zeichen dunkler als
                      der Hintergrund sind*/

	/* imagefttext($im, $font_size, $rotation, $shadow_x, $shadow_y, $shadow_color,
           $font, string[$i], array());*/
	imagefttext ($im, $font, $ro, $i*36, $y, $color, 'arial.ttf', $string[$i-1]);
}

imagegif($im, "captcha.gif");
echo '<img src="captcha.gif" border="2">';
?>

Das hier erstellte Captcha dürfte für viele Spam-Bots kein Hindernis darstellen. Aber da die Grundvoraussetzung für ein eigenes Captcha gelegt ist (hoffe ich zumindest) steht einer Variation von Ihnen nichts mehr im Wege.

Um das Captcha auszuwerten lediglich die Varible $string gegenprüfen.

Ich wünsche viel Spaß beim Ausprobieren!

Ein Beispiel findet sich hier.
Das dortige Formular ist übrigens ebenfalls selbst programmiert.