Fangen wir also an. Das Ziel ist es eine E-Mail Adresse zwar lesbar auf dem Monitor anzuzeigen, es den Spam-Bots aber nicht zu einfach zu machen. Dazu nehmen wir die E-Mail Adresse rückwärts und schreiben einfach von Rechts nach Links. CSS unterstützt das ohne Probleme. Dazu brauchen wir nur zwei Attribute: unicode-bidi und direction.

<style type="text/css">
 span.crypted_email { unicode-bidi:bidi-override; direction: rtl;}
</style>
<span class="crypted_email">ed.80nalp@rengnal</span>

Der Code-Schnipsel gibt euch dann langner@plan08.de (mist jetzt hab ich meine Adresse doch hingeschrieben!) aus.  Genau das was wir wollten. Im Code steht die Adresse aber niemals Plaintext. Natürlich hat diese Technik auch ein großes ABER. Verwende ich den Schnipsel, so kommt auch der Browser nicht mit zurecht. Copy und Paste des Strings resultiert in einem umgedrehten Text in der Zwischenablage und mindert somit die Usability der Webseite. Ist es das Wert? Wahrscheinlich nicht, denn es gibt andere Möglichkeiten seine Adresse zu schützen.

Ich werde hier gerne noch mal ein paar andere vorstellen. Auch welche, die die User-Experience nicht beinträchtigen. Ich finde den Trick trotzdem ziemlich nett und ich habe mal wieder ein paar neue Features von CSS kennengelernt. Vielleicht will man ja andere Dinge so verschlüsseln, dass sie von Bots nicht gelesen werden können. Gibt bestimmt viele schöne Anwendungsgebiete. Denkt aber immer dran google ist auch ein bot und wird die Texte nicht indizieren.

Kleine Geschichtsstunde.

Ich bin so frei und übernehme den Text des Wikipedia Artikels:

CREATE TABLE IF NOT EXISTS `users` (
`id` int(11) NOT NULL auto_increment,
`firstnames` varchar(200) NOT NULL,
`lastname` varchar(200) NOT NULL,
PRIMARY KEY  (`id`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=22 ;

CREATE TABLE IF NOT EXISTS `links` (
`link_id` int(11) NOT NULL auto_increment,
`fromid` int(11) NOT NULL,
`toid` int(11) NOT NULL,
PRIMARY KEY  (`link_id`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=11 ;

private function _fetchUser(){
  $m_user = new UserModel();
  $this->_users = $m_user->fetchAll();
  $this->_longestPath = $this->_users->count()+1;
}

private function _buildSkel($fromid){
  if(!$this->_users){
    $this->_fetchUser();
  }

  foreach($this->_users as $user){
	$this->_nodes[]=$user->id;
	$this->_dist[$user->id]=$this->_longestPath;
	$this->_previous[$user->id]=-1;
  }

  if($fromid>0)
	$this->_dist[$fromid]=0;
  }

private function _findPath($toid){
  $Q = $this->_nodes;
  while(count($Q)>0){
	$qsize=count($Q);
	$unode = $this->_findMin($Q);

	if($unode == $toid){
        	break; // We have found ToId
	}

	$u = array_search($unode, $Q);
	$Q[$u]=false;

	$Q = array_filter($Q);

	if($qsize == count($Q)){
	  throw new Exception("Qsize doesnt shrink!");
	}

	$m_link = new LinksModel();

	$invitees = $m_link->fetchAll("fromid='$unode'");
	$inviters = $m_link->fetchAll("toid='$unode'");

	if($invitees->count()>0)
	$this->_relaxNeighbors($unode,$invitees,'toid');

	if($inviters->count()>0)
	  $this->_relaxNeighbors($unode,$inviters,'fromid');
  }
}

private function _relaxNeighbors($unode,$neighbors,$col){
	foreach($neighbors as $neighbor){
		$this->_relax($unode,$neighbor->$col);
	}
}

private function _relax($u,$v){
	if($this->_dist[$v] > $this->_dist[$u]+1){
		$this->_dist[$v]=$this->_dist[$u]+1;
		$this->_previous[$v] = $u;
	}
}

private function _findMin($nodes){
	$keys = array_keys($nodes);
	$minid = $nodes[$keys[0]];
	$mindist = $this->_dist[$minid];
	foreach ($keys as $key){
		$tnode = $nodes[$key];
		if($this->_dist[$tnode] < $mindist){
			$mindist = $this->_dist[$tnode];
			$minid=$tnode;
		}
	}

	return $minid;
}

Aber vielleicht reiße ich nochmal schnell unsere Vorgehensweise und die Problemstellung an. Wir haben also einen User und wollen ihm anzeigen, welche andere User in 50km Umkreis wohnen. Klingt ja ganz einfach. Fangen wir also an. Zuerst benötigen wir die PLZ des Benutzers, was nicht wirklich ein Problem sein sollte, denn in unserer Community können wir ja selbst bestimmen, welche Daten der User beim Anmelden hinterlegen muss. Schritt Zwei wäre alle Postleitzahlen zu suchen, die nicht weniger als 50km entfernt sind. Im dritten und letzten Schritt suchen wir uns die User raus, die in diesem PLZ Bereich wohnen. Tadaaa wir sind fertig. Natürlich kann man noch irgendwelche Heuristiken einführen, es darf z.B. die erste Stelle der PLZ nur um eine Zahl abweichen oder ähnliches. Hier ist der Kreativität keine Grenze gesetzt. Wir bleiben aber bei unserem einfachen Beispiel und der nicht ganz so performanten Methode. Wer von euch das ganze verbessern will kann dies natürlich tun, werde dann hier auch drüber berichten.

Eigentlich hatte ich mir hier vorgenommen noch ein paar SQL Anfragen zu posten, mit denen man z.B. den Abstand zwischen Karlsruhe und Berlin ausrechen kann. Da ich aber gerade nicht so viel Zeit habe und die GeoDB ca. 50 MB groß ist und ich mich da erstmal wieder einarbeiten muss, werde ich das ganze einfach auf eine andere Session verschieben. Natürlich könnt ihr das auch über positives Feedback beschleunigen. Wenn ihr Beispiel habt, dann könnt ihr die hier auch posten.

So das war auch schon wieder meine kleine Einführung in die Umkreissuche. Ich hoffe, dass ich wenigstens einigen von euch einen Einblick geben konnte und ihm/ihr auch die Angst davor genommen habe. Spielt einfach ein wenig mit rum und ihr werdet sehen, dass es gar nicht so schwer ist,

Fangen wir also an, wir brauchen eine Datenbank, die Postleitzahlen (PLZ) in Geo-Koordinaten umsetzt, eine Datenbank mit vielen Usern und den Orten (PLZ) in denen sie wohnen und den Satz des Pythagoras. Fangen wir mit dem einfachsten an, der Datenbank mit PLZ und ihren Koordinaten. Natürlich ist dies auch gleichzeitig der komplexeste Teil, aber dank eines Open Source Projektes wurde uns diese Arbeit schon abgenommen. Die OpenGeoDB ist der Versuch eine möglichst vollständige Datenbank zu allen Orten und Postleitzahlen im europäischen Raum (A, B, CH. DE und FL) aufzubauen. Und diese werden wir einfach für unsere Zwecke verwenden. Wer will kann gleich auch die GeoClassPHP mit runterladen, die einem viele Aufgaben bereits abnimmt. Da wir aber auch hierbei noch etwas lernen wollen, machen wir das jetzt einfach selber. Normalerweise bin ich aber ein Freund des “Rad-nicht-neu-Erfindens”.

Der zweite Punkt, den wir benötigen sind viele User in unsere Community. Natürlich klappt das alles auch mit zwei Leuten, macht aber viel weniger Spaß. Also alle Freunde einladen, die beste Community aller Zeiten bauen und schon sind wir am Ziel. Ein paar Millionen User sollten es schon sein – StudiVZ hat es ja schließlich auch geschafft. Ok wir haben jetzt also unsere Datenbank und eine Million Mitglieder. Es kann also losgehen. Ach ja den Satz des Pythagoras.

Der Satz des Pythagoras ist einer der fundamentalen Sätze der euklidischen Geometrie. Er besagt, dass in allen ebenen rechtwinkligen Dreiecken die Summe der Flächeninhalte der Kathetenquadrate gleich dem Flächeninhalt des Hypotenusenquadrates ist.

Ah ich liebe die Mathematik. Hab ich mal erwähnt, dass Mathe mein Nebenfach beim Studium war? Weiß auch nicht wirklich warum, aber ich hab es sogar bestanden (danke Annette!). Ich will niemanden unterstellen, dass er den Satz nicht verstanden hat, aber ich versuche es einfach nochmal in meinem eigenen Worte zu fassen. Wir haben also ein rechwinkeliges Dreieck (ein Winkel 90°), dort gibt es eine lange Seite, die Hypotenuse und zwei kurze Seiten, die Katheten. Quadriert man nun die Länge der Hypotenuse, so ist das Ergebnis genau so groß wie die Summe der beiden Kathetenquadrate. Wenn ich mir meine Erklärung so durchlesen fällt mir auf, dass sie auch nicht viel besser ist. Aber egal. Vielleicht sind zwei schlechte Erläuterungen ja so gut wie eine gute. Wir merken uns also a² + b² = c²

Kommen wir nochmal zurück zu den Geo-Koordinaten. Da wir hier keine super komplizierte Formel haben wollen, um den Abstand zwischen zwei Orten auszurechnen, nehmen wir einfach an, dass die Erde flach ist. Im Atlas geht das ja auch. Wir legen jetzt also durch unsere Deutschlandkarte ein Koordinatensystem. Eigentlich machen diese Geo-Koordinaten ja nichts anderes, der Breitengrad ist unsere Y-Achse, der Längengrad die X-Achse. Eigentlich müssen wir jetzt nur noch den Abstand zweier Punkte berechnen. Dafür nehmen wir den Satz des Pythagoras.

Hier mal eine kleine Grafik um den Zusammenhang zwischen dem Abstand zwischen zwei Punkten und den Satz des Pythagoras zu verdeutlichen. Wir nehmen also die X-Koordinaten der beiden Punkte und ziehen sie voneinander ab und schon haben wir die Länge der ersten Kathede, das gleiche mit den Y-Koordinaten, dann nur noch quadrieren und fertig.

So mehr möchte ich für heute auch nicht erzählen, da es wohl sonst zu viel für einen Tag wird.