This code snippet outputs the time which is needed to execute some code.

- (void)someAction {

  // save current time
  CFAbsoluteTime startTime = CFAbsoluteTimeGetCurrent();

  [self someAwesomeAlgorithm];

  // print time difference to console
  // output Example: Took 0.000078 seconds.
  NSLog(@"Took %f seconds.", (CFAbsoluteTimeGetCurrent()-startTime));
}

Bei zahlreichen Webspace-Providern ist die Funktionalität von file_get_contents für http deaktiviert. Es treten dann Fehlermeldungen wie

Warning: file_get_contents() [function.file-get-contents]: URL file-access is disabled in the server configuration in [..] und

Warning: file_get_contents([..]) [function.file-get-contents]: failed to open stream: no suitable wrapper could be found in [..]

auf. Mit folgender Funktion kann man das Verhalten von file_get_contents jedoch emulieren.

Die Funktion get_contents_by_uri benutzt fsockopen um Inhalte zu laden:

/**
 * Gets contents of any webside by an URI.
 * @author http://blog.root-of-all-evil.com
 * @param String $uri
 */
function get_contents_by_uri($uri) {
	$uriElem = parse_url ( $uri );
	$fp = @fsockopen ( $uriElem ['host'], 80, $errno, $errstr, 10 );

	if (! $fp) {
		throw new Exception ( "Could not create socket: '" . $errnstr . "' (" . $errno . ")." );
	}

	$request = "GET " . $uriElem ['path'] . (isset ( $uriElem ['query'] ) ? "?" . $uriElem ['query'] : "") . " HTTP/1.1\r\n";
	$request .= "Host: " . $uriElem ['host'] . "\r\n";
	$request .= "Connection: Close\r\n\r\n";

	fwrite ( $fp, $request );
	$response = "";
	while ( ! feof ( $fp ) ) {
		$response .= fgets ( $fp, 128 );
	}
	fclose ( $fp );

	// split headers from data
	$responseSplit = explode ( "\r\n\r\n", $response, 2 );

	return $responseSplit [1];
}

Erklärung

Socket erstellen

Die übergebene URI wird über die PHP-Funktion parse_url in ihre Teilmengen zerlegt. Anschließend wird ein Socket erstellt für den entsprechenden Host, auf Port 80 mit einem Timeout von 10 Sekunden. Fehlermeldungen unterdrücken wir durch das @, da wir explizit nach Erfolg abfragen und ggf. eine Ausnahme werfen.

Anfrage schicken, Antwort lesen

Danach wird über fwrite eine entsprechende GET-Anfrage geschickt, welche auch – falls vorhanden – die Parameter der URI und nicht nur den Pfad beachtet. Die darauffolgende Antwort wird in die Variable response gelesen.

Antwort bearbeiten und zurückgeben

Da diese neben dem eigentlichen Inhalt auch den Antwortheader enthält wird die Funktion explode benutzt um den Inhalt davon abzuschneiden. Durch den dritten Parameter bei explode mit dem Wert 2, stellen wir sicher, dass nur einmalig an Hand einer Leerzeile getrennt wird wie Sie sich zwischen Antwort-Header und HTML-Code befindet und nicht mehrmals, da natürlich auch Leerzeilen im HTML-Code selbst auftreten können.

Das zweite Element von responseSplit wird zurückgegeben, responseSplit[0] würde entsprechend den Antwort-Header liefern.

Beispielaufrufe

Der einfachste Aufruf:

echo get_contents_by_uri ( 'http://www.google.de/' );

Aufruf mit Parametern:

echo get_contents_by_uri ( 'http://www.google.de/search?hl=de&site=&q=test' );

Aufruf mit Ausnahmebehandlung:

try{
    echo get_contents_by_uri ( 'http://does_not_exist_.com/bogus.html' );
}
catch(Exception $e)
{
    echo "get_contents_by_uri: ".$e->getMessage();
}

Weitere Links:

• PHP – Funktion parse_url
• PHP – Funktion file_get_contens
• PHP – Funktion fsockopen
• PHP – Funktion explode

Eines meiner etwas zurückliegenden Projekte zwang mich externe Bilder durch meinen Server zu laden, zu verkleinern und schließlich auch die Durchschnittsfarbe zu berechnen. Aus Gründen der Performancesteigerung war ich nie ein Fan davon die Durchschnittsfarbe Pixel für Pixel des Originalbildes zu berechnen. Es gibt eine viel elegantere und fast genauso exakte Lösung:

Unser Ziel: Wir möchten ein Bild (jpg, gif, png) über einen HTTP-Stream laden, dieses lokal auf dem Server speichern, ein entsprechendes Thumbnail (eine verkleinerte Version) erzeugen, speichern und schlussendlich die dominierende – oder auch durchschnittliche – Farbe im Bild berechnen und abspeichern. Eventuell möchten wir zusätzlich alles in einer Datenbank hinterlegen – das soll aber zunächst außerhalb unserer Betrachtung liegen.

Für das Berechnen der Durchschnittsfarbe gibt es einen wunderbar einfachen Trick. Doch dazu später mehr. Beginnen wir zunächst einmal mit einer Konstante und einer Funktion, die wir später noch benötigen:

DEFINE('CTX', stream_context_create(array(
    'http' => array(
        'timeout' => 20,
        'method' => 'get',
        'header' => 'Referer: XYZ'
    )
)));

Unsere Konstante CTX ist also ein array. Wir benötigen es für unsere HTTP-Anfrage, mit der wir das gewünschte Bild auf unseren Server laden. Für diese Anfrage verwenden wir die HTTP-GET-Methode, definieren einen Timeout von maximal 20 Sekunden und senden einen Referer im Header, den ich hier mal einfach nur “XYZ” genannt habe.

function randomstring_creator($len = 20) {
    $chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    $string = '';
    mt_srand((double) microtime() * 1000000);
    for($i = 0; $i < $len; $i++) {
        $string .= $chars{mt_rand(0, strlen($chars))};
    }
    return($string);
}

Die Funktion randomstring_creator() generiert uns eine zufällige Zeichenfolge mit einer beliebigen Länge. Wir benötigen diese Funktion, da wir in diesem Beispiel die Bilder lokal unter einem zufälligem Namen speichern werden.

Weiter geht es mit unseren Klassen. Beginnen wir mit der Klasse Image:

class Image {
    var $img;
    var $source;
    var $local;
    var $dimX;
    var $dimY;
    var $avg_colour;
    function get($source, $quality = 90) {
// siehe unten
    }
    function calc_avg_colour() {
// siehe unten
    }
}

Unsere Klasse besitzt also die Eigenschaften source (die Url, von der das Bild stammt), local (den lokalen Speicherpfad), dimX, dimY (die Abmessungen des Bildes in Pixel) und avg_colour (den farblichen Durchschnittswert als HEX-Code in der Form rrggbb). Die Eigenschaft img ist eine Referenz auf das Image-Objekt, dass ich aber später noch näher beleuchten werde.

Die beiden Funktionen get() und calc_avg_colour() der Klasse sollten selbsterklärend sein. Mit der Funktion get(), die gleichzeitig auch als Konstruktor dient, laden wir das Bild, dass unter source zu finden ist, auf unseren Server und speichern es in der gewünschten JPEG-Qualität (90 als Standard) lokal.

calc_avg_colour() berechnet – wie der Name schon sagt – die Durchschnittsfarbe des in der Eigenschaft img gespeicherten Bildes.

Wir wollen zusätzlich aber auch kleine Abbilder des Originalbildes erstellen und erweitern dazu unsere Image-Klasse um die Klasse Thumbnail:

class Thumbnail extends Image {
    function create($parent, $X = 300, $Y = 300, $quality = 60) {
// siehe unten
    }
}

Diese Erweiterung besitzt zunächst nur eine Funktion, mit der das Thumbnail erstellt wird. Die übergebene Variable parent enthält dabei eine bereits existierende Image-Klasse, die herunterskaliert werden soll. Die maximale Breite und Höhe werden mit den Variablen X und Y (standard bei 300 Pixel) übergeben. Die JPEG-Qualität beträgt standardmäßig nur 60.

Das eigentliche Programm sieht dann nur noch so aus:

$imgurl = 'original.jpg';
// neues Objekt der Klasse Image erzeugen
$img = new Image;
// Bild aus der imgurl laden
if($img->get($imgurl)) {
    // ein Objekt der Klasse Thumbnail erzeugen
    $thumb = new Thumbnail;
    // und ein Thumbnail des oben definierten Objektes der Klasse Image generieren
    $thumb->create($img, 300, 300);
    // dann noch die Durschschnittsfarbe berechnen
    $thumb->calc_avg_colour();
    // und Daten ausgeben... fertig
    echo('Image: ' . $img->source . "\n");
    echo('Thumbnail: ' . $thumb->source . "\n");
    echo('Average colour: #' . $thumb->avg_colour . "\n");
} else {
    echo('Could not get the image.');
}

So, dann sehen wir uns also mal unsere Funktionen der Klassen an. Beginnen wir mit der Funktion get():

function get($source, $quality = 90) {
    $this->source = $source;
    // wir laden das Bild von $source:
    if(($file = file_get_contents($this->source, false, CTX))) {
        // wenn erfolgreich, erzeugen wir mit den geladenen Daten
        // ein neues Bild und speichern dieses in der Eigenschaft img
        $this->img = imagecreatefromstring($file);
        // wir lesen die Höhe und Breite des Bildes aus
        $this->dimX = imagesx($this->img);
        $this->dimY = imagesy($this->img);
        // und speichern das Bild unter zufälligem Namen mit imagejpeg lokal im Ordner "raw"
        $this->local = 'raw/' . randomstring_creator() . '.jpg';
        imagejpeg($this->img, $this->local, $quality);
        // bei Erfolg true zurückgeben
        return(true);
    } else {
        // false, wenn das Bild nicht geladen werden konnte
        return(false);
    }
}

Ein Thumbnail erzeugen wir mit dieser Funktion der Klasse Thumbnail:

function create($parent, $X = 300, $Y = 300, $quality = 60) {
    // zunächst die vorläufigen Abmessungen speichern
    $this->dimX = $X;
    $this->dimY = $Y;
    // die Abmessungen und deren Verhältnis des Originalbildes holen
    $origX = $parent->dimX;
    $origY = $parent->dimY;
    $ratio = $origX / $origY;
    // wenn das Originalbild breiter als hoch ist, kürzen wir die Höhe
    if($X / $Y > $ratio) {
        $this->dimX = $Y * $ratio;
    } else {
    // wenn das Originalbild höher als breit ist, kürzen wir die Breite
        $this->dimY = $X / $ratio;
    }
    // hier erstellen wir ein neues Bild mit den oben berechneten Abmessungen
    $this->img = imagecreatetruecolor($this->dimX, $this->dimY);
    // und kopieren das Originalbild einfach in das eben erstellte kleinere, dabei wird es verkleinert
    imagecopyresampled($this->img, $parent->img, 0, 0, 0, 0, $this->dimX, $this->dimY, $origX, $origY);
    // jetzt speichern wir das neue Thumbnail noch unter zufälligem Namen im Ordner "thumb"
    $this->source = $parent->local;
    $this->local = 'thumb/' . randomstring_creator() . '.jpg';
    imagejpeg($this->img, $this->local, $quality);
}

Das Herzstück: Wir wollen die Durchschnittsfarbe ermitteln. Dazu könnten wir einfach alle Farbwerte aller Pixel zusammen addieren und dann durch die Anzahl der Pixel teilen. Bei einem Thumbnail von der Größe 300 x 300 Pixel, würden wir aber eine Schleife mit 90.000 Durchläufen benötigen. Es gibt einen besseren Weg – einen ganz logischen Trick.

Durchschnittsfarbe berechnen

Wir haben oben beim Erstellen des Thumbnails die Funktion imagecopyresampled() verwendet. Was wenn wir unser Thumbnail einfach auf eine Größe von 1×1 Pixel skalieren? Genau: Es bleibt ein Pixel mit der Durschnittsfarbe übrig. Dessen Farbe auszulesen ist mit imagecolorat() dann nur noch eine Kleinigkeit. Los gehts:

function calc_avg_colour() {
    // ein temporäres Bild mit den Abmessungen 1x1 Pixel erstellen
    $avrg = imagecreatetruecolor(1, 1);
    // Das Thumbnail einfach reinkopieren, dabei auf 1x1 Pixel skalieren
    imagecopyresampled($avrg, $this->img, 0, 0, 0, 0, 1, 1, $this->dimX, $this->dimY);
    // Die Farbe des verbleibenden Pixels auslesen
    $rgb = imagecolorat($avrg, 0, 0);
    // Das temporäre Bild wieder löschen
    imagedestroy($avrg);
    // Und die Farbe in HEX umwandeln
    $r = dechex($rgb >> 16);
    $g = dechex($rgb >> 8 & 255);
    $b = dechex($rgb & 255);
    if(strlen($r) < 2) $r = 0 . $r;
    if(strlen($g) < 2) $g = 0 . $g;
    if(strlen($b) < 2) $b = 0 . $b;
    // tataaaa... da ist unsere Durchschnittsfarbe:
    $this->avg_colour = $r . $g . $b;
}

Super. Das wäre es. Ende und aus.

Man stelle sich folgendes Szenario vor: Es existiert eine Webseite, die eine Vielzahl von Grafiken, die auf dem gleichem Server hinterlegt sind, einbindet. Diese Webseite wird erfahrungsgemäß eine überdurchschnittlich lange Ladezeit haben. Aber nicht nur aufgrund der zu übertragenen Datenmengen, sondern auch aufgrund der maximalen Anzahl von Verbindungen, die ein Browser auf ein und denselben Server erlaubt. Hier werde ich etwas über die Beschleunigung vom Aufbau von Webseiten schreiben. Dabei verwende ich gewisse DNS Einstellungen, so genannte CNAME-Records mit denen ich serverseitig mehrere parallele HTTP-Verbindungen erlauben kann und so das Laden der Webseite durch den Browser des Nutzers beschleunige.

Standardmäßig sind moderne Browser mit maximalen Anzahl von sechs Verbindungen (IE 6 und IE 7 maximal zwei Verbindungen) zu ein und demselben Host begrenzt. Das führt dazu, dass das Laden von Dateien (Bilder, HTML-Seiten, JavaScripts oder Stylesheets) von einer Webseite in Blöcken unterteilt wird. Dabei würde es um einiges schneller gehen können, wenn ich die zu ladenden Dateien auf verschiedene Hostnamen verteile. So können für jeden Hostnamen mehr Verbindungen gleichzeitig ermöglicht werden.

Man betrachte zum Beispiel Google Maps. Die angezeigte Karte besteht aus einer vielzahl von so genannten Tiles. Tiles sind einfach Kacheln. Jede Kachel stellt einen Kartenausschnitt dar:

Damit die Karte schnellstmöglich trotz der Browserbegrenzung von sechs Verbindungen geladen werden kann, verteilt Google Maps die zu ladenden Kacheln auf verschiedene Hostnamen (Subdomains). Google verwendet vier Subdomains: mt0, mt1, mt2 und mt3.google.de:

Grundsätzlich ist es kein großes Problem verschiedene Subdomains anzulegen und die Dateien einer Webseite auf diese Subdomains zu verteilen. Allerdings besteht so recht schnell die Gefahr, dass man als Administrator den Überblick verliert, wo welche Dateien abgespeichert sind. Einfacher wäre es, zB. alle Mediendateien (zB. Bilder, Videos) unter einer Subdomain abzuspeichern. Um das Laden der Startseite erheblich zu beschleunigen, aber ohne zahlreiche Subdomains zu arbeiten kann man wie folgt vorgehen:

1. Ich lege unter der Hauptdomain eine einzige subdomain namens media.domain an. Hier speichere ich alle Bilder ab.
2. Ich lege so genannte CNAMES Einträge in meinen DNS Einstellungen an. Ein CNAME ist – einfach erklärt – ein Domain-Alias. In meinem Fall wähle ich zwei CNAME-Einträge namens “media0.domain.de” und “media1.domain.de” an. Am einfachsten geht es über die Adminoberfläche Plesk und sieht folgendermaße aus:
3. Diese beiden Einträge bewirken, dass media0.domain.de und media1.domain.de auf die gleiche subdomain media.domain.de umleiten. Ich habe jetzt also eine Subdomain, die auf drei unterschiedliche Weisen erreicht werden kann. Der Browser des Nutzers interpretiert die drei Domains als drei unterschiedliche Adressen, die aber auf den gleichen Speicherort verweisen. So sind drei mal so viele Verbindungen zum eigentlich gleichen Host möglich. Der Browser wird einfach ausgetrickst.
4. Bei der Einbindung der Bilder in die Webseite muss ich jetzt nur die zwei verschiedenen “subdomains” media0 und media1 verteilen. Ich löse das über einen Zufallsgenerator in meinem PHP Script, dass den HTML-Code generiert. Dieser könnte zB. so aussehen:

$media_domains = array('media0', 'media1');
foreach($bilder as $bild) {
  shuffle($media_domains);
  echo('<img src="' . $media_domains[0] . '.domain.tld/img/'. $bild . '" />');
}

Und fertig. Kommentare, Verbesserungsvorschlage? Dazu sind die Kommentare da.