Vielleicht checkts durch dieses Beispiel auch ein anderer PHP-Coder, der das auch noch nicht so kapiert hat. Bzw. isses ja mehr oder weniger übertragbar auf andere OOP-Sprachen.

Basisklasse ist Human. Sepp ist ein Human, Maria auch.

Klasse Male leitet sich ab von Human. (Male extends Human)
Klasse Female leitet sich ab von Human. (Female extends Human)

Beide können auf die Methoden von Human zugreifen (eat, drink).

Male implementiert Interface IMale (und somit die Methode “ejakulieren”).
Female implementiert Interface IFemale (und somit die Methode “schwanger werden”).

Male kann ejakulieren, Female nicht (naja, darüber kann man streiten, klar ^^).
Female kann schwanger werden, Male nicht.

Ne, so stimmt das eigentlich nicht.
Male muss ejakulieren können. Wenn die Methode ejakulieren fehlt, dann ist die Klasse Male fehlerhaft. Deshalb wird durch das Interface Male sicher gestellt, dass Male ejakulieren kann, ansonsten wird das Skript mit einer Fehlermeldung beendet.

Female muss schwanger werden können. Wenn die Methode “schwanger werden” fehlt, ist die Klasse Female fehlerhaft (bzw. unvollständig).

Ich hab das echt nie gecheckt bzw. nicht so genau angeschaut, deshalb dacht ich immer das ich das auch noch lernen muss, irgendwann halt. Dabei ist es total easy.

[php]

class Human {

protected $name;
protected $gender;
protected $age;

public function eat($food){
echo “{$this->name} isst {$food}.\n”;
}

public function drink($drink){
echo “{$this->name} trinkt {$drink}.\n”;
}

}

interface IMale {
function ejaculate($female);
}

class Male extends Human implements IMale {

public function __construct($name, $age) {
$this->name = $name;
$this->age = (int) $age;
$this->gender = “male”;
}

public function ejaculate($female){
echo “{$this->name} ejakuliert auf {$female->name} => “;

if (get_class($female) != get_class($this)) $female->getPregnant($this);
elseif ($female == $this) echo “{$this->name} hat onaniert.\n”;
else echo “{$this->name} hat mit {$female->name} Poposex gemacht.\n”;

}

}

interface IFemale {
function getPregnant($male);
}

class Female extends Human implements IFemale {

private $pregnant;

public function __construct($name, $age) {

$this->name = $name;
$this->age = (int) $age;
$this->gender = “female”;

}

public function getPregnant($male) {

if ($this->pregnant) {
echo “{$this->name} ist bereits schwanger.\n”;
return;
}

if (get_class($male) != get_class($this)) {
$this->pregnant = true;
echo “{$this->name} wurde von {$male->name} geschwängert.\n”;
}

}

}

$sepp = new Male(‘Sepp’, 36);
$klaus = new Male(‘Klaus’, 27);
$maria = new Female(‘Maria’, 26);

print_r($sepp);
print_r($maria);
print_r($klaus);

$sepp->eat(‘Pizza’);
$sepp->drink(‘Bier’);
$maria->eat(‘Pizza’);
$maria->drink(‘Bier’);

$sepp->ejaculate($maria);
$sepp->ejaculate($sepp);
$klaus->ejaculate($sepp);
$klaus->ejaculate($maria);

/*
Male Object
(
[name:protected] => Sepp
[gender:protected] => male
[age:protected] => 36
)
Female Object
(
[pregnant:Female:private] =>
[name:protected] => Maria
[gender:protected] => female
[age:protected] => 26
)
Male Object
(
[name:protected] => Klaus
[gender:protected] => male
[age:protected] => 27
)

Sepp isst Pizza.
Sepp trinkt Bier.
Maria isst Pizza.
Maria trinkt Bier.
Sepp ejakuliert auf Maria => Maria wurde von Sepp geschwängert.
Sepp ejakuliert auf Sepp => Sepp hat onaniert.
Klaus ejakuliert auf Sepp => Klaus hat mit Sepp Poposex gemacht.
Klaus ejakuliert auf Maria => Maria ist bereits schwanger.
*/
[/php]

Vielleicht brauchts ja sonst noch jemand, es ist eine Sache von ein paar Minuten und man braucht keinen API Key oder sonstiges. Hier eine Anleitung, was man machen muss, um vor englischsprachigem Spam verschont zu bleiben.

Die Idee ist folgende: Unter dem Kommentar-Formular wird das Bild einer Frucht angezeigt. Darunter ist ein weiteres Input-Feld, in das der Kommentator den Namen der Frucht schreiben muss. Und zwar auf deutsch.

1. Spambots sind zu blöd Früchte zu erkennen
2. die meisten Spambots können kein deutsch
3. englisch kommentierende Spamer können die Früchte erkennen, können aber kein deutsch (zumindest die meisten). Ausser sie schauen in ein Wörterbuch, aber ich glaube da suchen sie sich eher den nächsten Blog.

Naja, ich muss wohl erstmal ne Zeitlang warten, aber ich hab so das Gefühl, dass jetzt erstmal Schluss ist mit dem massenhaften Spam.

Schritt 1 – Speichert euch die ganzen Bilder unter den gleichen Namen wie ich sie habe auf den Rechner (1.jpg – 8.jpg)

2. Schritt
Erstellt auf eurem Webspace einen Ordner namens “fruits”, und zwar im untersten Verzeichnis. Ladet dort per ftp die Bilder hoch. (die genaus heissen müssen, wie bei mir)

3. Schritt
Öffnet mit einem Editor die Datei comment-template.php im wp-includes Ordner (per ftp downloaden).
Sucht die Stelle

[php]

[/php]

DAVOR fügt ihr diesen Code ein:

[php]
// hacked by mighty marcus / spam protection
$fruit = mt_rand(1, 8);
echo '

‘;
echo ‘
‘;
echo ‘Was ist das?*
‘;
echo ‘
‘;
echo ‘
‘;
echo ‘

‘;
// end hack
?>
[/php]

Datei speichern und wieder hochladen.

4. Schritt
Holt euch die Datei wp-comments-post.php im untersten Verzeichnis und öffnet sie mit einem Editor.
Sucht die Stelle:
[php]
if ( ” == $comment_content )
wp_die( __(‘Error: please type a comment.’) );
[/php]

DANACH einfügen:
[php]
// hack
if (isset($_POST['fruit_answer']) && $_POST['fruit_answer'] != ”) {
$fruit_ary = array(”, ‘ananas’, ‘erdbeere’, ‘pfirsich’, ‘apfel’, ‘kirsche’, ‘banane’, ‘birne’, ‘zitrone’);
$fruit = $fruit_ary[$_POST['fruit']];
if ($fruit != strtolower($_POST['fruit_answer']))
wp_die( __(‘Fehler: Du müsstest eigentlich wissen, was das für eine Frucht ist!’) );
}
else
wp_die( __(‘Fehler: Sie müssen den Namen der Frucht eintragen!’) );
// hack end
[/php]

Fertig. Die Spambot Macher könnten jetzt zwar einfach den Blogeintrag lesen und ihren Bots beibringen, dass zum Beispiel 1.jpg eine Ananas ist usw… Aber ich schätze nur wegen meinem Blog wird das keiner machen. Check it out!

Wie immer am Ende noch ein paar Keywords, haha. Anti Spam yes Anti Spam. Ein Minimales Anti Spam System für WordPress von mighty.marcus. See ya (in hell) !

UPDATE: Und es funktioniert. Bisher kein einziger Spam-Kommentar!

UPDATE 2 (24. April): Immer noch kein Spam! Haha Loser!

/* wir speichern die Referenz zum Element #infoBox ( id=”infoBox”) in der globalen Variable infoBox
* Und zwar erst, wenn der DOM komplett geladen ist, Ansonsten könnte es sein, dass infoBox = null
* Es ist zwar in diesem Beispiel nicht notwendig, aber man sollte es sich angewöhnen sich gleich Referenzen
* zu DOM-Element anzulegen, die man öfter benutzt.
*/

$(document).ready(function() {
infoBox = $(“#infoBox”);
});

// Diese JS-Funktion ruft die Jquery-Funktion “post” auf. Der Output einer Datei wird gespeichert in “data”.
// Die Jquery-Funktion “html” fügt data in das Element #infoBox ein.
function get_servertime() {
$.post(“php_output.php”, function(data) {
$(infoBox).html(data);
});
}

Ein Link mit onclick=”get_servertime(); return false;” href=”javascript:”

Eine Datei php_output.php.

echo date(“d.m.Y H:i”, time());
[/php]

Und fertig. Wenn man auf den Link klickt, holt Jquery sich den Output der Datei php_output.php und fügt ihn in das Element #infoBox im DOM ein.

Mit Perl ist viel mehr möglich als „nur“ dynamische Webseiten zu erstellen, auch auf die Socket-API von C lässt sich darauf zugreifen und in Verbindung mit Flash als Client lassen sich damit Chats und sogar Multiplayer-Spiele realisieren. Was ist ein Socket? Um es kurz zu machen: ein Socket ist eine Schnittstelle in einem Netzwerk, die es ermöglicht Daten beinahe in Echtzeit zu übertragen. Dabei fungiert ein Perl-Script als zentraler Server, lauscht auf Verbindungen und eingehende Daten, parst die Daten und sendet sie bei Bedarf weiter an andere Computer, die auch mit dem Perl-Server verbunden sind.
Zum Vergleich: ein Apache-Webserver macht eigentlich das selbe. Er lauscht auf sogenannte HTTP-Requests, die wir senden, wenn wir einen Link anklicken. Der Webserver parst die Daten und liefert uns die gewollte Seite aus. Der vorteilhafte Unterschied zwischen einem Apache-Webserver und einem Perl-Socket-Server liegt aber darin, dass es nicht ganze HTML-Seiten sind, die über die Leitungen fließen, sondern schlanke Strings.

Kleines Beispiel: Wir klicken einen Button in Flash an, auf dem steht: Zeig mir die Server-Zeit.
Flash sendet durch einen (TCP-)Socket den String „[aktion:serverzeit]\0“ an den Perl-Socket-Server. Das „\0“ fügt der Flash-Player übrigens automatisch hinzu, um damit das Ende des Strings zu signalisieren.
Der Perl-Server parst den String und findet heraus: aha, ich soll die Serverzeit ausliefern. Als Antwort schickt er nun den String „[serverzeit:12:32:54]\0“.
Es sei an dieser Stelle auch gleich erwähnt, dass die XMLSocket-Klasse nicht zwingend Strings im XML-Format verlangt. Und das ist auch gut so, denn ein
„<xml version=“1.0“><aktion>serverzeit</aktion></xml>“ im vergleich zu „[aktion:serverzeit]“ ist ganz klar bandbreitenschonender, weil man einfach viel weniger Daten senden muss. Natürlich hätte ich auch „{aktion}{serverzeit}“ schreiben können oder auch „[a][s]“ oder gar „[s]“. Welches Protokoll man auch verwendet, solange man es selbst versteht und solange es logisch ist, passt alles.

Perl, der Meister der Regular-Expressions. Damit wird es sehr einfach, die Daten zu parsen.

$flashDaten =~ /\[aktion:(\w+)\]/;
my $aktion = $1;

if ($aktion eq „serverzeit“) {
my ($sec,$min,$hour) = localtime(time);
my $anwort = „[serverzeit:$hour:$min:$sec]\0“;
sende_zurück($antwort);
}

Ok, ich glaube man hat mich verstanden: Sockets dienen hauptsächlich dazu möglichst kleine Daten möglichst schnell zu senden/empfangen, und bieten damit die Möglichkeit viele Clients gleichzeitig zu bedienen. Man stelle sich einen Chat vor auf dem sich gerade hunderte User unterhalten. Die Nachrichten müssen so schnell wie möglich weitergeleitet werden, um überhaupt einen Chat möglich zu machen. Es reicht nicht, die Nachrichten in einer Datenbank zu speichern und alle paar Sekunden mittels eines HTTP-Requests die Seite zu aktualisieren. Es gibt zwar solche Chats, z.B. mit PHP, MySQL und Javascript (für automatische HTTP-Requests) realisiert – aber die taugen doch nicht wirklich was; und zwingen mit steigender Useranzahl selbst die stärksten Server in die Knie.

Ein ganz nützliches Perl-Modul, mit dem die Arbeit mit Sockets zum Kinderspiel wird, ist das POE-Modul. POE heisst Perl Object Environment, es ist objektorientiert und dadurch ist die Syntax auch leicht verständlich.

Was ist POE? POE ist ein Framework, welches es wie ein Betriebssystem erlaubt, mehrere Prozesse in einem Perl-Skript gleichzeitig laufen zu lassen, über sogenannte Sessions. Es lassen sich damit wunderbare Programme schreiben, in denen verschiedene Sessions sich um verschiedene Aufgaben kümmern. Da es für viele Bereiche – vor allem im Netzwerk-Bereich – vorgefertigte POE-Module gibt, schreibt sich ein Socket-Server damit fast schon von alleine. Die Hauptarbeit überlassen wir einfach POE und können uns direkt um die lustigen Sachen kümmern wie die Logik unseres Servers, Datenparsen usw.

Ladet euch das POE-Framework von CPAN herunter und installiert es. Falls ihr keinen eigenen Server habt sondern einen Webspace ohne Root-Zugang, kein Problem. Erstellt einfach einen Ordner auf dem Webspace, ladet dort das POE-Modul hoch und inkludiert es anstatt einfach nur:

use POE;

mit…

use lib „dein/absoluter/pfad/zum/POE-Ordner/lib“;
use POE;

Nun aber endlich mal zu einem Beispiel. Ich zeige euch einen kompletten Perl-Socket-Server, der eigentlich zwei Server beinhaltet: der eigentliche Hauptserver kümmert sich um den Flash-Film, der andere Server – nennen wir ihn Policy-File-Server – kümmert sich um die Auslieferung einer virtuellen XML-Datei, dem sogenannten Policy-File. Policy-File, was ist das?
Nun ja, machen wir es kurz: Adobe verlangt aus Sicherheitsgründen die Auslieferung eines virtuellen Policy-Files, quasi eine Datei in der geschrieben steht, dass der Flash-Film dazu berechtigt ist auf bestimmte Ports des Servers zugreifen zu dürfen.
Diese Datei liegt in unserem Perl-Skript in einem String und wartet nur darauf, in die große weite Welt verschickt zu werden. Sie sieht, bei mir zumindest, so aus:

my $xml = ‘<?xml version=”1.0″?><!DOCTYPE cross-domain-policy SYSTEM “/xml/dtds/cross-domain-policy.dtd”><cross-domain-policy><site-control permitted-cross-domain-policies=”master-only”/><allow-access-from domain=”localhost” to-ports=”5006″ /></cross-domain-policy>’;

Wie man sieht, steht darin geschrieben, dass localhost auf den Flash-Film zugreifen darf, und der Flash-Film auf den Server auf Port 5006.

Auf Port 5005 lauscht ein zweiter Server, also eine zweite POE-Session, die sich um nichts anderes kümmert als auf eine Verbindung und einen String „<policy-file-request/>\0“.
Schickt ein Flash-Film – oder wer auch immer – solch einen String, bekommt er als Antwort die $xml-Datei.

Ladet euch einfach die Quelltexte für den Actionscript-Client und den Perl-Server herunter. Schaut euch mal die Datei testServer.pl an.

Ganz kurz, was der Hauptserver macht: Er lauscht auf Verbindungen, akzeptiert diese, schreibt die Verbindungen oder besser gesagt die Referenzen dazu in das Array @connections, sendet eingehende Daten an die Verbindungen (im Array @connections, ausser an den Sender), löscht beendete Verbindungen wieder aus @connections (das ist wichtig, damit der Server nicht versucht Daten an bereits beendete Verbindungen zu senden – was zu einem sehr unschönen Programmabbruch führen würde). Daten parsen tut er nicht, aber falls er das tun soll, könnte es etwa so aussehen wie schon oben erwähnt, mit Regular Expressions:

$buff =~ /\[aktion:(\w+)\]/;
my $aktion = $1;

if ($aktion eq „serverzeit“) {
my ($sec,$min,$hour) = localtime(time);
my $anwort = „[serverzeit:$hour:$min:$sec]\0“;
$outbuffer{$client} .= $antwort;
$kernel->select_write($client, „event_write“);
}

Nun zum Flash-Teil. Wir erstellen nun einen Flash-Film, der einfach ein blaues Viereck zeigt. Dieses Viereck lässt sich verschieben, und wenn man es verschoben hat, sendet es die neuen Koordinaten des Vierecks an die anderen Flash-Filme, die noch mit dem Server verbunden sind. Die anderen Flash-Filme platzieren das Viereck dann an der neuen Position.

Ich zeige erstmal den Actionscript-Code. Es ist übrigens möglich den Code via der freien Flex-SDK
zu kompilieren, falls man kein Flash besitzt. Und das schöne an der Flex-SDK ist – außer dass sie nichts kostet – dass man sie auch unter Linux einsetzen kann. Da POE unter Windows nur zu Versuchszwecken taugt (POE verursacht zumindest beim strawberry-Perl unter Windows nach kurzer Zeit eine CPU-Auslastung von 100%) ist das natürlich sehr praktisch.
Falls ihr an der Flex-SDK interessiert seit, benutzt Google, ist leicht zu finden.

Erstellt in Flash einen neuen Film, speichert ihn und gebt in den Eigenschaften als Dokumentklasse TestSocket an. Mit TestSocket ist die Datei TestSocket.as gemeint, die ihr zusammen mit dem neuen Flash-Film in den selben Ordner kopiert. Oder kopiert die AS-Datei in den bin-Ordner der Flex-SDK und kompiliert den Code mittles Eingabeaufforderung bzw. Terminal dort mit mxmlc TestSocket.as. Danach bindet ihr die SWF-Datei in eine HTML-Seite ein und ladet diese zusammen mit der SWF-Datei auf euren Webspace bzw. xampp bzw. /var/www/ oder wo auch immer ihr eure Webseiten liegen habt hoch.

Startet nun den Server mittels Terminal oder Eingabeaufforderung und ruft über den Browser die HTML-Seite mit dem Flash Film auf. Wenn alles geklappt hat, macht weitere Fenster oder Tabs auf und verschiebt das Viereck. Es müsste nun auf allen anderen Seiten ebenfalls verschoben worden sein.

Ach ja, ein besonderes Schmankerl für die eigene Webseite ist es natürlich einen unsichtbaren Flash-Film laufen zu lassen, der eine Socket-Verbindung herstellt. So ist ein Datenaustausch auch ohne Seitenreload möglich. Dabei kann man Javascript als Brücke verwenden, um so empfangene Daten direkt im Browser auszugeben bzw. anzuzeigen. Man stelle sich einfach vor, dass ein User namens „Hans“ dem User mit der Uid 12 eine Nachricht schreibt, ganz normal über die Webseite. Nun wird eine Funktion in Javascript aufgerufen, die dem Flash-Film sagt, er soll eine Nachricht an den Server schicken, z.B. „[post][12][Hans]“. Der Server parst diesen String und findet heraus: aha, ich soll dem User 12 Bescheid sagen, dass er soeben Post von Hans bekommen hat. Der Server schickt an den Socket des Users 12 den String „[post][Hans]“.
Nun erscheint am rechten unteren Bildschirmrand des Postempfängers – der ja noch nichts von seinem Glück weiß, weil er die Seite noch nicht aktualisiert hat – eine kleine schicke Box, in der steht: „Sie haben Post von Hans!“. Posteingang-Benachrichtigung ohne Seitenreload beinahe in Echtzeit, realisiert mit einem TCP-Socket.

Sehr vorteilhaft ist es natürlich diesen unsichtbaren Flash-Film in einer Hauptseite laufen zu lassen, in der die eigentlichen Webseiten in einem iframe dargestellt werden. Warum? Weil sonst bei jedem neuen Seitenaufruf die Verbindung unterbrochen und dann wieder hergestellt wird.

Es gibt übrigens eine Javascript-Klasse, die diese Brücke herstellt, gebt mal in einer Suchmaschine „JSXML Bridge Javascript Flash“ ein. Diese Klasse arbeitet mit der ExternalInterface-Klasse von Flash.

Zuguterletzt noch zwei Punkte:
1.Warum muss ich jeden String, den ich vom Perl-Socket-Server an einen Flash-Client schicke mit einem „\0“ beenden? Weil Flash sonst ewig auf das Ende der Nachricht warten würde.
2.Kann jedes Programm, dass Socketverbindungen möglich macht, von jedem anderen Menschen dazu benutzt werden meine auf Port 5005 und 5006 lauschenden Server mit Nachrichten geradezu zu überfluten? Und ob. Stichwort Flooding. Leider können die Server nicht erkennen, ob Daten von einem Flash-Film, einem C++-Programm, einem anderen Perl-Skript oder von sonstwo geschickt werden. Hier ist es wirklich sehr wichtig, sich sichheitstechnisch abzusichern, will man nicht von seinem Webhoster gesperrt werden. Ich z.B. habe es so realisiert, dass nachdem sich ein User in meine Webseite eingeloggt hat seine IP-Adresse über einen UNIX-Socket an das POE-Skript gesendet wird; diese IP-Adresse wird für ein paar Sekunden erlaubt, d.h. Nur IP-Adressen werden gestattet, die praktisch „von oben“ ein okay bekommen haben, und das nur für ein paar Sekunden. Jede andere IP-Adresse wird gar nicht erst reingelassen bzw. sofort wieder rausgeworfen. „Tut mir leid, sie stehen nicht auf der Gästeliste!“. Ausserdem muss der Client auch seine Session-ID mitschicken, und es wird geprüft, ob diese in der Datenbank unter den eingeloggten Usern steht. Wenn nicht, auf Wiedersehen.

Okay, und das ist auch das Stichwort für mich, ich muss weg. Ich hoffe ich konnte dem einen oder anderen einen groben Einblick in die Welt der Sockets bieten und wünsche euch viel Spaß beim Erstellen von coolen Flash-Perl-Applikationen.

Wir haben also zwei unterschiedliche Texte, die in Hinblick auf das relevante Keyword jedoch völlig gleich sind.

Der erste Text wird über diesen Artikel über diesen Link: deiramantis für die Suchmaschinen erreichbar sein.

Der zweite Text wird über diesen Artikel über diesen Link: deiramantis für die Suchmaschinen erreichbar sein.

Die Linktexte sind also die gleichen, die Dateinamen – und somit die URL sind aber verschieden. Beim ersten Text ist das Keyword in der Url vorhanden; beim zweiten nicht. Ob es nun eine Rolle spielt, dass der Link zu Text eins eher vorkommt, also die Suchmaschine eher darauf stößt als auf den zweiten Text, lasse ich jetzt mal ausser Acht.

Als Titel und Description werde ich einfach die ersten 5 Pseudo-Wörter des jeweiligen Textes bzw. die ersten 12 Wörter des jeweiligen Textes verwenden. So sind auch Titel und Description unique, obwohl sie eigentlich suchmaschinentechnisch gesehen äquivalent sind. Wichtig ist ja nur das Keyword.

Die Ergebnisse werde ich dann in ein paar Wochen hier posten.

Ach, jetzt habe ich doch glatt vergessen suchmaschinenfreundlich zu schreiben. Also müssen natürlich noch ein paar Keywords rein. HALLO OUT THERE! Hier geht es um das Thema: Keywords in der Url – ein praktischer Test.

Ich tippe mal stark darauf, dass der Text mit dem Keyword Dateinamen das Rennen macht.

UPDATE: Inzwischen wurde die Seite test007.html in den Index aufgenommen, wenn man im index-cache nachsieht sogar schon am 16.02.2009, also einen Tag nach Veröffentlichung dieses Artikels.
Die andere Seite mit dem Keyword im Dateinamen ist allerdings noch nicht aufgetaucht. Das muss man jetzt nicht verstehen, denke ich mal. Heute ist der 24.02.

UPDATE2: 27. Februar.
Die zweite Seite deiramantis.html wurde nun auch in den Index aufgenommen. Momentan belegt sie noch den zweiten Platz. Mal sehen, ob sich das noch ändert.

Momentan sieht es so aus: KLICK ME!

UPDATE 1. April 2009

Ähm, ja, lasst euch vom Datum (1.April) nicht täuschen. Ich haber gerade bei Google nachgeschaut und hab gesehen, dass sich der deiramantis.html Artikel jetzt doch durchgesetzt hat. Also das Keyword in der URL scheint doch besser bewertet zu werden.

Eine viel bessere Lösung wäre es, nicht nur nach großgeschriebenen Wörtern zu suchen, sondern den Text mit einer Keywords-Bibliothek zu vergleichen. Das ist jedoch mühsam, denn wo kriegt man so eine Keywords Bibliothek her, in der so ziemlich alle Wörter stehen, die wichtig sein könnten? Zweitens würde sicher die Performance darunter leiden, wenn wir den Text mit solch einer riesigen Bibliothek vergleichen würden.

Mein Keyword Generator macht den Job auch ziemlich gut. Ein Problem sind die Leute, die alles klein schreiben, aber mit denen müssen wir halt leben.

Wir fangen einfach mal an und erstellen einen String mit dem Text.

[php]
$text = ‘Wir schreiben einen Keyword Generator. Man könnte auch sagen es ist ein Keyword Generator Tool, vielleicht schreiben wir einfach mal Keyword-Generator Tool, oder auch Keyword-GENERATOR-Tool, was ja das gleiche ist. Das Keyword in diesem Text ist natürlich KeYwoRD.’;
[/php]

Wir haben jetzt unseren Text, der in der Praxis z.b. aus sämtlichen Forumspostings einer Seite bestehen könnte, so wie es in meinem Forum der Fall ist.

Nun machen wir uns daran, einfach mal alle groß geschriebenen Wörter und Wortkombinationen (bestehend aus maximal 3 aufeinanderfolgenden groß geschriebenen Wörtern) herauszufiltern. Dafür benutzen wir ein Pattern und den PHP Befehl preg_match_all.

[php]
$pattern1 = ‘/\b[A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+ [A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+ [A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+|[A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+ [A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+|[A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+\b/’;
preg_match_all($pattern1, $text, $array1);
[/php]

Nicht erschrecken! Dieses Pattern besteht regex-Mustern, also Mustern, mit denen wir nach Übereinstimmungen suchen können. [A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+ bedeutet einfach, wir suchen nach Wörtern, deren erster Buchstabe groß geschrieben ist, die darauf folgenden Wörter groß oder klein geschrieben sind, und das Wort muss aus mindestens 3 Buchstaben bestehen.
Da wir aber nicht nur einzelne Wörter auslesen wollen, sondern auch Kombinationen aus Wörtern, sagen wir in unserem Muster, dass zuerst nach Wortkombinationen aus drei Wörtern gesucht werden soll – oder nach Kombis mit zwei Wörtern, zum Schluß nach einzelnen Wörtern – in dieser Reihenfolge.

Wir schauen uns mal das Ergebnis an, welches in dem Array $array1[0] gespeichert ist.

[php]
print_r($array1[0]);
[/php]

Das Ergebnis:
Array ( [0] => Wir [1] => Keyword Generator [2] => Man [3] => Keyword Generator Tool [4] => Keyword [5] => Generator Tool [6] => Keyword [7] => GENERATOR [8] => Tool [9] => Das Keyword [10] => Text [11] => KeYwoRD )

Naja, irgendwie ist da etwas schief gelaufen! Wo kommt denn Generator Tool her, oder gar Generator? In unserem Muster steht doch Keyword-Generator Tool, aber wir bekommen nur Generator Tool. Achja, der Bindestrich. Klar, unser Muster ignoriert Keyword-Generator, da es davon ausgeht, dass Wortkombinationen mit einem Leerzeichen getrennt werden. Also ersetzen wir einfach mal alle Binde- und Unterstriche mit einem Leerzeichen, sodaß aus Keyword-Generator Tool ganz einfach Keyword Generator Tool wird.

[php]
$text = str_replace(array(‘-’,'_’),array(‘ ‘),$text);
[/php]

Array ( [0] => Wir [1] => Keyword Generator [2] => Man [3] => Keyword Generator Tool [4] => Keyword Generator Tool [5] => Keyword GENERATOR Tool [6] => Das Keyword [7] => Text [8] => KeYwoRD )

Ja, so gefällt mir das schon besser.

Jetzt zählen wir die Wörter nach ihrem Vorkommen und sortieren sie auch danach. Das geht ziemlich einfach.

[php]
$ausgabe1 = array_count_values($array1[0]);
array_multisort($ausgabe1, SORT_DESC);
[/php]

Nun haben wir ein weiteres Array, nämlich $ausgabe1. Wir sehen uns mal den Inhalt an.

[php]
print_r($ausgabe1);
[/php]

Array ( [Keyword Generator Tool] => 2 [Text] => 1 [KeYwoRD] => 1 [Das Keyword] => 1 [Keyword GENERATOR Tool] => 1 [Man] => 1 [Wir] => 1 [Keyword Generator] => 1 )

Aha, wie wir sehen, bestehen die Schlüssel dieses Arrays aus unseren Wörtern, die Werte bestehen aus der Häufigkeit ihres Vorkommens. Demnach kommt Keyword Generator Tool 2 mal vor, Text 1 mal, KeYwoRD auch 1 mal. Moment, das ist doch dumm. KeYwoRD und Keyword ist doch das selbe.
Ja, für Menschen natürlich schon, für einen Computer ist es aber absolut nicht das selbe.

Also was machen wir? Wir lösen dieses Problem ganz einfach so: wir wandeln von Anfang an alle unsere durch das Muster gefundenen Wörter in Kleinbuchstaben um, um dann jeden ersten Buchstaben eines jeden Wortes in einen Großbuchstaben zu verwandeln.

[php]
$array1[0] = array_map(‘ucwords’, array_map(‘strtolower’, $array1[0]));
[/php]

Ergebnis:
Array ( [Keyword Generator Tool] => 3 [Text] => 1 [Keyword] => 1 [Das Keyword] => 1 [Wir] => 1 [Man] => 1 [Keyword Generator] => 1 )

Gut, es hat hingehauen. Keyword GENERATOR Tool wurde zu Keyword Generator Tool und kommt nun drei mal vor, statt nur 2 mal wie vorher.

Wir werden jetzt mal einen String erzeugen, den wir dann einfach als META-TAG benutzen können. Die Werte des Arrays, also das Vorkommen der Wörter, interessiert uns jetzt nicht mehr, da wir ja die Worte schon danach geordnet haben. Uns interessieren jetzt die Schlüssel, also die Wörter, die wir für unsere Liste brauchen.

[php]
$keywords = array_keys($ausgabe1);
$keywords = implode(‘, ‘,$keywords);
echo $keywords;
[/php]

Ergebnis:
Keyword Generator Tool, Text, Keyword, Das Keyword, Wir, Man, Keyword Generator

Naja, nicht schlecht, aber auch noch nicht das wahre. Die Wörter “Wir”, “Man” und auch das “Das” haben in unserer Liste nichts verloren. Faul wie wir sind, werden wir sie direkt am Anfang einfach aus dem Text entfernen. Dazu brauchen wir eine sogenannte Stopwords-Liste.

Stopwords sind z.B. das, er, sie, es, wenn, seine, und etc.

[php]
$stopwords = array(‘Wir ‘,’Das ‘,’Man ‘);
$text = str_replace($stopwords,”,$text);
[/php]

Das ist so ziemlich die einfachste Methode, um ungewünschte Wörter zu entfernen. Wir benutzen ganz einfach str_replace und fügen nach jedem Stopword ein Leerezeichen hinzu. So können wir vermeiden, dass aus Wörtern wie “Manchester” “chester” wird, wenn wir das “Man” entfernen, oder aus dem Wort “Wirtshaus” “tshaus”.
Normalerweise werden diese Stopwords eh klein geschrieben und fallen eh durch unser Suchraster, allerdings kann es vorkommen, dass diese Wörter auch mal groß geschrieben werden. Eben am Satzanfang.

Das einzige Problem ist es, wenn dem “Wir” oder “Das” oder “Man” kein Leerzeichen folgen würde, sonder z.B. ein Komma. Dieses “Das,” würde nicht entfernt werden.
Mit preg_replace könnten wir das auch noch hinkriegen, aber erstens müssten wir dann unser ganzes Skript umkrempeln. Ich habe jetzt keine Lust, genauer darauf einzugehen, es hat jedenfalls etwas mit der Reihenfolge meines Skripts zu tun.
Und zweitens geht es auch so, und das wahrscheinlich performance-freundlicher (genau!!).

Gut, dann schauen wir mal, wie es jetzt aussieht.

Keyword Generator Tool, Keyword, Text, Keyword Generator

Ok. Bei längeren Texten empfiehlt es sich auch, die Keywords auf maximal 40 Wörter zu beschneiden.

[php]
$ausgabe1 = array_slice($ausgabe1,0,39);
[/php]

Bis jetzt sieht unser Skript so aus:

[php]
$stopwords = array(‘Man ‘,’Wir ‘,’Das ‘);
$text = ‘Wir schreiben einen Keyword Generator. Man könnte auch sagen es ist ein Keyword Generator Tool, vielleicht schreiben wir einfach mal Keyword-Generator Tool, oder auch Keyword-GENERATOR-Tool, was ja das gleiche ist. Das Keyword in diesem Text ist natürlich KeYwoRD.’;
$text = str_replace($stopwords,”,$text);
$text = str_replace(array(‘-’,'_’),array(‘ ‘),$text);
$pattern1 = ‘/\b[A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+ [A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+ [A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+|[A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+ [A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+|[A-Z\ÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+\b/’;
preg_match_all($pattern1, $text, $array1);
$array1[0] = array_map(‘ucwords’, array_map(‘strtolower’, $array1[0]));
$ausgabe1 = array_count_values($array1[0]);
$ausgabe1 = array_slice($ausgabe1,0,39);
array_multisort($ausgabe1, SORT_DESC);
$keywords = array_keys($ausgabe1);
$keywords = implode(‘, ‘,$keywords);
echo $keywords;
[/php]

Wir können es aber noch besser machen.
Und zwar benutzen wir einfach mehrere Pattern. Das erste Pattern liest alle großgeschriebenen Wörter aus, sowie auch alle Wortkombinationen aus maximal drei aufeinander folgenden großgeschriebenen Wörtern.

Das zweite Pattern liest nur alle Wortkombinationen bestehend aus exakt drei aufeinander folgenden großgeschriebenen Wörtern aus. (Und zwar nicht aus dem ganzen Text sondern aus dem 1. Ergebnis, weil hier schon alles was wir brauchen enthalten ist. Es wäre ja auch blöd viermal den gesamten Text durchzusuchen)

Das dritte Pattern liest nur alle Wortkombinationen bestehend aus exakt zwei aufeinander folgenden großgeschriebenen Wörtern aus. Natürlich aus dem vorigen Ergebnis.

Und das vierte Pattern liest nur alle einzelnen roßgeschriebenen Wörter aus. Natürlich aus dem vorigen Ergebnis.

Dazu poste ich einfach mal das veränderte Skript und erkläre dann, was es damit auf sich hat.

[php]
$tags = ‘Wir schreiben einen Keyword Generator. Man könnte auch sagen es ist ein Keyword Generator Tool, vielleicht schreiben wir einfach mal Keyword-Generator Tool, oder auch Keyword-GENERATOR-Tool, was ja das gleiche ist. Das Keyword in diesem Text ist natürlich KeYwoRD.’;

$pattern1 = ‘/\b[A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+ [A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+ [A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+|[A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+ [A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+|[A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+\b/’;
$pattern2 = ‘/\b[A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+ [A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+ [A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+\b/’;$pattern3 = ‘/\b[A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+ [A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+\b/’;
$pattern4 = ‘/\b[A-ZÄÖÜ]{1}+[A-Za-zäüöéèáàúùß]{2,}+\b/’;

preg_match_all($pattern1, $tags, $array1);
$tags2 = implode(‘, ‘,$array1[0]);
preg_match_all($pattern2, $tags2, $array2);
$tags3 = implode(‘, ‘,$array1[0]);
preg_match_all($pattern3, $tags3, $array3);
$tags4 = implode(‘, ‘,$array1[0]);
preg_match_all($pattern4, $tags4, $array4);

$array1[0] = array_map(‘ucwords’, array_map(‘strtolower’, $array1[0]));
$array2[0] = array_map(‘ucwords’, array_map(‘strtolower’, $array2[0]));
$array3[0] = array_map(‘ucwords’, array_map(‘strtolower’, $array3[0]));
$array4[0] = array_map(‘ucwords’, array_map(‘strtolower’, $array4[0]));

$ausgabe1 = array_count_values($array1[0]);
$ausgabe2 = array_count_values($array2[0]);
$ausgabe3 = array_count_values($array3[0]);
$ausgabe4 = array_count_values($array4[0]);

$new_keys = array_merge($ausgabe1,$ausgabe2,$ausgabe3,$ausgabe4);
array_multisort($new_keys, SORT_DESC);
$new_keys = array_slice($new_keys,0,39);
$keywords = array_keys($new_keys);
$keywords = implode(‘, ‘,$keywords);
[/php]

Das Ergebnis:

Erstes Skript:
Keyword Generator Tool, Keyword, Text, Keyword Generator

Zweites Skript:
Keyword, Generator, Keyword Generator, Tool, Keyword Generator Tool, Text

Genial, Keyword ist an erster Stelle. Das Generator an zweiter stelle bereitet mir aber doch irgendwie Unbehangen. Um einen Generator geht es hier ja nicht wirklich, oder?

Hm, kurz überlegen. Mit array_merge verbinden wir ja alle $ausgabe Arrays zu einem einzigen Array, das uns dann das Ergebnis liefert.

In $ausgabe1 finden wir alle Wörter und Wortkombinationen. Wenn das Pattern auf eine Wortkombination aus drei Wörtern stößt, wird dieser Treffer gespeichert. Es speichert dann bei Keyword Generator Tool nur “Keyword Generator Tool”. “Generator” und “Tool” wird nicht noch mal gespeichert.
Wenn es aber nicht auf eine Wortkombination aus drei Elementen stößt, schaut es nach, ob es eine Wortkombination aus zwei Worten findet. “Keyword Generator” zum Beispiel. Wir auch vorher speichert es “Keyword Generator” und fährt mit der Suche fort, ohne sich um den “Generator” zu kümmern.

In $ausgabe2 finden wir alle Wortkombinationen aus drei Elementen bestehend. Das zweite Pattern ignoriert jetzt alle einzelnen Wörter und alle Kombis mit zwei Elementen.

In $ausgabe3 finden wir alle Kombis aus zwei Elementen.

In $ausgabe4 finden wir alle einzelnen Wörter, unabhängig davon, ob diese in einer Wortkombination stehen oder nicht. Es findet bei “Keyword Generator Tool” einmal “Keyword”, einmal “Generator” und einmal “Tool”.

Mit [php]array_merge($ausgabe1,$ausgabe2,$ausgabe3,$ausgabe4);[/php] fügen wir nun alle $ausgaben zusammen, wobei die Werte der jeweils vorherigen $ausgabe von der folgenden Ausgabe überschrieben werden.

Das heisst, steht in $ausgabe1 das Wort Keyword => 4 mal, und in $ausgabe4, dass ja alle einzelnen Wörter zählt, Keyword => 6 mal, wird aus dem Keyword => 4 in $ausgabe1 Keyword => 6.

Und so weiter.

Das Problem ist nun die Sache mit dem Generator. In der ersten $ausgabe1 kommt es gar nicht vor, denn im Text steht es nicht alleine, d.h. es steht immer in einer Kombination. Das ist schon mal gut.
In $ausgabe4 wird aber auf die Kombinationen gepfiffen und es erscheint dann trotzdem im Ergebnis-Array, und zwar nicht nur einmal sondern öfter, weil es ja schon in “Keyword Generator” vorkommt, aber auch in “Keyword Generator Tool”. Dabei ist dieses “Generator”, wenn es alleine steht, unnütz, belegt aber in unserer Keywords-Liste den zweiten Platz.

Das ist gewiss suboptimal. Was könnte man da machen? Die Lösung ist natürlich relativ einfach.
Wir schauen einfach in unserer ersten $ausgabe1 nach, ob das Wort “Generator” auch als einzelnes Wort ausserhalb einer Kombi gefunden wurde. Ist dem so, schenken wir ihm die volle Aufmerksamkeit. Ist dem nicht so, ignorieren wir es komplett als einzelnes Wort: Wir lassen es erst gar nicht in unserem Suchergebnis erscheinen.

Dazu schreiben wir einfach vor dem array_merge($ausgabe1,$ausgabe2,$ausgabe3,$ausgabe4); zwei foreach-Schleifen. Die kümmern sich nur um die einzelnden und um die Kombis mit 2 Elementen. Um die 3er Kombis müssen wir uns nicht weiter kümmern, wir können sie danach einfach zum ersten $ausgabe1 dazufügen.
[php]
foreach ($ausgabe3 as $key => $value) {
if (isset($ausgabe1[$key])) {$ausgabe1[$key] = $value;}
}

foreach ($ausgabe4 as $key => $value) {
if (isset($ausgabe1[$key])) {$ausgabe1[$key] = $value;}
}
[/php]
Wir ändern jetzt einfach die Zeile mit
[php]$new_keys = array_merge($ausgabe1,$ausgabe2,$ausgabe3,$ausgabe4);[/php]
in
[php]$new_keys = array_merge($ausgabe1,$ausgabe2);[/php]

In den Schleifen steht einfach drin, dass wir für jeden Treffer in den jeweiligen $ausgaben diese mit dem Wert in $ausgabe1 ersetzen – so kann kein in einer Kombi gefundenes “Generator” im Ergebnis landen.
Anders ist es, wenn wir im Text einmal das Wort “Generator” alleine finden würden. Das ist aber nicht der Fall.

Und das Ergebnis sieht dann so aus:

Keyword, Keyword Generator, Keyword Generator Tool, Text

Das Generator ist weg.

Nehmen wir jetzt mal ein anderes Beispiel als Text.

“Super Metroid Fans können mit dem Super Metroid Hack Super Metroid Redesign endlich mal ein neues Super Metroid spielen. Metroid ist ja auch ein geiles Spiel! Super Metroid Redesign ist ein Hack vom originalen Super Metroid. Es ist einfach genial.”

Ergebnis:
Metroid, Super Metroid, Super Metroid Redesign, Hack, Spiel, Super Metroid Hack, Super Metroid Fans

Seht ihr was ich meine? Metroid ist an erster Stelle, weil es auch mal als alleine stehendes Wort gefunden wird. Super ist erst gar nicht dabei? Warum nicht? Weil es im Text nicht ein einziges mal ausserhalb einer Kombination vorkommt. Hack kommt vor, und Spiel kommt auch vor, aber Super nicht. Das finde ich gut, denn Super würde den ersten Platz in unserer Liste belegen, weil es in Kombis öfter auftaucht.

Evtl. werde ich das Skript noch soweit verändern, dass ein alleine stehendes Wort auch öfter Vorkommen muss, um gezählt zu werden.

Denn was passiert, wenn in dem Text zufällig “Ja, das ist Super!” vorkommt. Na, die Frage könnt ihr doch selbst beantworten, nehme ich an.

So, jetzt muss ich aber Schluß machen.
Ich hoffe der eine oder andere kann mit diesem Beinahe Tutorial etwas anfangen. Ich weiß, das Skript ist nicht perfekt, aber vermutlich ein guter Ansatz für Newbies, die auch mal so etwas programmieren wollen und nicht nur fertige Skripts einbauen wollen.

Wenn ihr euch für die Sache interessiert könnt ihr irgendwann sicher ein Skript schreiben, dass meins alt aussehen lässt. Viel Spaß dabei. (Ich werde dann mal versuchen es zu verbessern.)