infos24 JavaScript > JavaScript Handbuch Setzen von Cookies

Home / Tutorials / JavaScript Handbuch / Setzen von Cookies

Cookiess allgemein
Format eines Cookies
Internet Explorer
Netscape
Die Daten eines Cookies parsen
Mehrere Cookies auf einmal einrichten
Ermitteln, wie oft ein User schon auf der Seite war

Cookiess allgemein

nach oben

Cookies sind kleine Dateien, die auf dem Client, dem Zielrechner, abgespeichert werden und so bestimmte, clientspezifische Informationen halten können. Cookies kann man sowohl mittels einer serverseitig arbeitenden Programmiersprache siehe Cookies verwalten mit Perl, Cookies verwalten mit PHP wie auch mit einer clientseitig arbeitenden Programmiersprache, also mit JavaScript verwalten. Denkbar sind alle möglichen Effekte. Man könnte in einem Cookie speichern, wann der User zum letzten mal da war und ihn dann begrüssen, so nach dem Motto "Du warst am 12.03.2002 zum letzten mal hier, insgesamt warst Du schon 5 mal hier", man könnte bei einem Warenkorb die bestellten Waren in einem Cookie speichern, obwohl es hier Alternativen gibt, siehe Verbinden von clientseitiger und serverseitiger Programmierung, man könnte ermitteln, wieviele Seiten sich der User angeschaut hat und die Ergebnisse an den Fremdrechner schicken etc. etc. Die Aussage, dass man mit Cookies den Fremdrechner nicht ausspähen kann, ist wohl so absolut nicht richtig, denn nichts kann den Programmierer daran hindern, im Cookie Informationen zu speichern, wie lange er auf der Seite war, welche Seiten er sich angeschaut hat, wann er sie besucht hat etc, und diese Seiten durch den Aufruf eines serverseitig arbeitenden Skriptes an den Server zurückzuschicken. Das serverseitig arbeitende Programm kann dann noch ein paar Informationen zusätzlich ermitteln, z.B. die IP Adresse und alle Informationen dann abspeichern. Da über die IP Adresse kein Rückschluss auf den User möglich ist, könnte man auch bei Betreten der Website irgend etwas Identifierendes kreieren z.B. Datum plus vierstellige Zufallszahl und so eine Gesamtschau erhalten über die online Aktivitäten des Users. Rebus sic stantibus lösen viele Leute das Problem, indem sie Cookies schlicht nicht mehr zulassen (Beim Explorer geht das mit Extras->Internetoptionen->Datenschutz->Erweitert->Cookie sperren, bei Netscape mit Bearbeiten->Einstellungen->Erweitert->Doppelclick Privatsphäre und Sicherheit->Cookies->Cookies deaktivieren). Viele Informationen,die über Cookies gewonnen werden können, können aber auch genutzt werden, um die Angebote einer Website zu verbessern und so richtig einsehen, kann man unter Umständen auch nicht, wie man mit Cookies Informationen gewinnen soll, die dem User schaden. Wie dem aus sei, ein Beispiel für eine einfache Cookie Anwendung sieht so aus.

<html><head><title>Cookies</title></head>
<body>

function zeitansage()
{
zeit=new Date();
aktuellezeit=zeit.getDate()+"."+ zeit.getMonth()+"."+ zeit.getYear()+" "+ zeit.getHours()+":"+ zeit.getMinutes()+":"+zeit.getSeconds();

if(document.cookie)
{
document.getElementById("datum").innerHTML="Sie waren zum letzten Mal am "+document.cookie+" auf dieser Website";
document.cookie=aktuellezeit;
}
else
{
document.getElementById("datum").innerHTML="Sie waren noch nie auf dieser Website. Nochmal drücken";
document.cookie=aktuellezeit;
}

}
</script>
<body onload=zeitansage()>
<div id="datum"></div>
</body></html>

Wer wissen will, was passiert, der muss auf Zeitansage clicken.

Er erfährt dann, wann er zum letzten Mal auf Zeitansage geklickt hat. Würde man die Funktion Zeitansage über den event handler onload als Attribut des body tags aufrufen, dann würde der User erfahren, wann er zum letzten Mal auf der Seite war. Zu Details, wie das Datum ermittelt wird und wie man die Angaben formatiert Operationen mit Zeitangaben. Wird die Funktion zeitansage() aufgerufen, wird erstmal das aktuelle Datum ermittelt. Mit

if(document.cookie)

prüfen wir, ob bereits ein Cookie geschrieben wurde, was ja nicht der Fall ist, wenn die Seite zum erstenmal aufgerufen wird. Wir schicken den User dann in den else Zweig und fordern ihn auf, nochmal zu clicken. Der oben genannte Cookie ist didaktisch nicht sinnvoll, da keine Zeitangabe mitgeliefert wird, ist es ein temporärer Cookie, der nur solange gültig ist, wie der Browser nicht geschlossen wird. Meistens will man den Cookie aber eine bestimmte zeitlang speichern, insbesondere würde das Beispiel oben nur funktionnieren, wenn der Cookie gespeichert wird, da sonst der Cookie nicht mehr da wäre, wenn der User das nächste mal die Website betritt. Wir modifizieren unser Programm so, dass der Cookie gespeichert wird.

<html><head><title>Cookies</title></head>
<body>
<script language="javascript">
jetzt=new Date();
laufzeit=new Date(jetzt.getTime() + 1000*60*60*24*365);
function zeitansage()
{
zeit=new Date();
aktuellezeit=zeit.getDate()+"."+ zeit.getMonth()+"."+ zeit.getYear()+" "+ zeit.getHours()+":"+ zeit.getMinutes()+":"+zeit.getSeconds();

if(document.cookie)
{
//alert(laufzeit);
alert(laufzeit.toGMTString());
document.getElementById("datum").innerHTML="Sie waren zum letzten Mal am "+document.cookie+" auf dieser Website";
document.cookie=aktuellezeit+";expires="+laufzeit.toGMTString();
}
else
{
document.getElementById("datum").innerHTML="Sie waren noch nie auf dieser Website. Nochmal drücken";
document.cookie=aktuellezeit;
}

}
</script>
<body onload=zeitansage()>
<div id="datum"></div>
</body></html>

Was haben wir geändert ? Damit ein Cookie auf der Festplatte gespeichert wird und nicht nur als temporärer Cookie sein ephemeres Dasein fristet muss die Zeit, bis zu der er gültig sein soll mit übergeben werden. Man tut dies, indem man "expires=Zeit in der er abläuft" mit übergibt. Genau das wird im Skript oben gemacht. Unser Problem besteht hierbei darin, dass wir den Zeitpunkt ermitteln müssen, ab dem unser Cookie nicht mehr gültig sein soll, und dass diese Zeit in einem bestimmten Format übergeben werden muss, nämlich im GMT (Greenwich Mean Time) Format übergeben werden muss. Selbiges hat eine solche Struktur: Mon, 28-Apr-2003 00:00:00 GMT. Aus didaktischen Gründen haben wir es im Skript oben aufgeblendet. Wer also den Skript kopiert und auslöst, wird sich davon überzeugen können, dass das GMT Format so aussieht. Das ganze Verfahren sieht nun so aus. Zuerst kreieren wir eine Instanz der Klasse Datum (siehe Operationen mit Zeitangaben.

jetzt=new Date();

Mit jetzt.getTime können wir die Anzahl der Millisekunden ermittelt, die seit dem 1. Januar 1970 bis zum Aufruf des Skriptes verflossen sind. Zu dieser Zeit zählen wir dann die Anzahl der Millisekunden hinzu, die dem gewünschten Zeitraum entspricht. Wir kreieren dann eine neue Instanz der Klasse Date und übergeben als Parameter die Summe dieser beiden Werte. Übergeben wir die Anzahl der Millisekunden zwischen dem 1.Januar 1970 und dem Verfallsdatum des Cookies an den Konstruktor der Klasse Date, erhalten wir als Ergebnis das Datum und die Uhrzeit, wann unser Cookie nicht mehr gültig sein soll.

laufzeit=new Date(jetzt.getTime() + 1000*60*60*24*365);

Dieses Datum konvertieren wir dann noch in das GMT Format. Wir haben dann eine Datumsangabe, die wir an unser Cookie übergeben können.

Format eines Cookies

nach oben

Im Prinzip kann man einem Cookie in einer Zeichenkette (max 4000 Zeichen) so ziemlich alles übergeben, was einem Spass macht, man kann auch etwas in dem Format eines Query Strings übergeben (hobby=schwimmen&Lieblingsfarbe=rot&Haarfarbe=blond etc. etc. ). Das sieht dann so aus.

document.cookie="Name_des_Cookies=Variable_1=Wert_1&Variable_=Wert_2;
expires=Verfallsdatum;
path=Informationen zum Pfad;
domain=Domain_Name;
secure=Informationen ob SSL Verbindung oder nicht";

Alle Variablen, die wir speichern wollen, deklarieren wir als Wert von Name_des_Cookies. Wenn wir mehrere Variable/Werte Paare haben, dann tun wir gut daran, sie in irgendeiner Struktur abzuspeichern, so dass wir sie nachher wieder zerhacken können. Dann haben wir noch ein Paar Variablen, die fest sind, nämlich expires, path, domain, secure. Diese können wir belegen, müssen aber nicht. Man beachte, dass jedes Name / Wert Paar vom anderen durch ein Semikolon getrennt ist. Alle Variablen, über die wir frei verfügen können, sind also direkt nach dem Namen des Cookies zu schreiben. Haben wir mehrere davon, müssen wir uns eine Struktur ausdenken, die es uns erlaubt, hinterher Routinen zu programmieren, die uns den Zugriff auf den Wert einer Variablen erlauben (siehe Arbeiten mit Zeichenketten). Schreiben wir einen kleinen Skript, der die Zusammenhänge verdeutlicht.

<html><head><title>Cookies</title></head>
<body>
<script language="javascript">
jetzt=new Date();
laufzeit=new Date(jetzt.getTime() + 1000*60*60*24*7);
function zeitansage2()
{
zeit=new Date();
aktuellezeit=zeit.getDate()+"."+ zeit.getMonth()+"."+ zeit.getYear()+" "+ zeit.getHours()+":"+ zeit.getMinutes()+":"+zeit.getSeconds();
if(document.cookie)
{
document.getElementById("datum").innerHTML="Sie waren zum letzten Mal am "+document.cookie+" auf dieser Website";
document.cookie=
"zeit="+aktuellezeit+"&hobby=schwimmen&Augenfarbe=blau"+";expires="+laufzeit.toGMTString();
}
else
{
document.getElementById("datum2").innerHTML="Sie waren noch nie auf dieser Website. Nochmal drücken";
document.cookie=
"zeit="+aktuellezeit+"&hobby=schwimmen&Augenfarbe=blau"+";expires="+laufzeit.toGMTString();
}
}
</script>
<body onload=zeitansage2()>
<div id="datum2"></div>
</body></html>

Schauen wir uns an, was passiert, indem wir hier clicken.

Hm ?! Das ist nicht gerade das, was wir uns erhofft hatten. Wir erhalten einfach den gesamten Cookie. Das einzige was wir nicht erhalten, ist expires, denn JavaScript erkennt das als eine Angabe, die nur intern verwendet werden soll. Wir machen jetzt folgendes. Wir machen uns erstens klar, wie der Cookie im Explorer und in Netscape abgespeichert wird. Anschliessend modifizieren wir unseren Skript so, dass wir etwas "Vernünftiges" erhalten.

Internet Explorer

nach oben

Mit dem Internet Exploder wird der Skript in das Verzeichnis c:/windows/cookies ein File mit dem Namen name_des_rechners@irgendeine_domain.txt geschrieben. Für alle Cookies einer Domain wird eine eigene Cookie Datei gebildet. Öffnet man diese, sieht man etwas in der Art.

zeit
16.4.2003 17:51:48&hobby=schwimmen&Augenfarbe=blau
~~local~~/C:\javascript_handbuch\
1088
786968704
29565251
253921472
29563843

* Genau genommen steht anstatt de \n\r (was den Umbruch auf die nächste Zeile bewirkt) eine Hyroglyphe, wenn man es aber in Wordpad kopiert, sieht es aus wie oben. Wir erhalten also für jeden Cookie, den wir produzieren, eine Zeichenkette. (Später schreiben wir einen Skript, der mehrere Cookies einrichtet.) Die einzelnen Werte haben hierbei folgende Bedeutung.

1	zeit	Name des Cookies
2	16.4.2003 17:51:48&hobby=schwimmen&Augenfarbe=blau	Wert des Cookies
3	~~local~~/C:\javascript_handbuch\	Die Domain, für die der Cookie gültig ist
4	1088	Klärt, ob es sich um einen "normalen" Cookie handelt, oder um einen, der über eine SSL Verbindung eingerichtet wurde. Ist dem so erhalten wir 1025
5	786968704	Angabe, wie lange der Cookie gültig ist
6	29565251	Nummerierung der Cookies
7	253921472	??
8	29563843	??

Wie deutlich zu erkennen, erhalten wir mit document.cookie nur die ersten beiden Werte, nämlich den Namen des Cookies und dessen Wert. Alle anderen Variablen (expires, path etc.) dienen nur der internen Steuerung des Cookies, wir haben folglich über document.cookie keinen Zugriff keinen lesenden Zugriff, weil das auch nicht sinnvoll wäre.

Netscape

nach oben

Bei Netscape hängt es ab von der Browser Version, wo sich der Cookie befindet. Bei Netscape 7 findet man ihn unter

C:\WINDOWS\Anwendungsdaten\Mozilla\Profiles\default\io9fsk3g.slt\cookie.txt

bei Netscape 6 unter

C:\Programme\Netscape\Users\default\cookie.txt

Bei Netscape stehen in dieser einen Datei alle Cookies.

HTTP Cookie File
# http://www.netscape.com/newsref/std/cookie_spec.html
# This is a generated file! Do not edit.
# To delete cookies, use the Cookie Manager.

FALSE /C:/javascript_handbuch FALSE 1053722987 zeit 16.4.103 22:50:7&hobby=schwimmen&Augenfarbe=blau<br>

Hierbei sind die letzten beiden Werte selbsterklärend. Der erste zeigt die Domain, der dritte Wert zeigt an, ob der Cookie von einer ssl Verbindung erzeugt wurde, der zweite Wert zeigt an, ob ein Pfad angegeben wurde. Die Angabe eines Pfades bewirkt, dass ein Cookie nur gelesen werden darf, wenn der Skript, der ihn lesen will, im selben Ordner liegt wie der Skript, der ihn aufgerufen hat.

Die Daten eines Cookies parsen

nach oben

Wie oben plastisch zu sehen, nützt es uns wenig, wenn wir einfach nur den Cookie auslesen. Wir hätten gerne einen isolierten Zugriff auf die einzelnen Wert der Variablen. Folglich müssen wir den Cookie weiterverabeiten. Wenn wir also den Wert der Variablen hobby und die Augenfarbe aufblenden wollen, müssen wir etwas in der Art machen.

<html><head><title>Cookie auslesen</title>
<script language="javascript">
aprikose=new Array();
kirsche=new Array();
melone=new Array();
jetzt=new Date();
laufzeit=new Date(jetzt.getTime() + 1000*60*60*24*7);
function zeitansage3()
{
zeit=new Date();
aktuellezeit=zeit.getDate()+"."+ zeit.getMonth()+"."+ zeit.getYear()+" "+ zeit.getHours()+":"+ zeit.getMinutes()+":"+zeit.getSeconds();
if(document.cookie)
{
aprikose=document.cookie.split("\&");

for(i=0;i<aprikose.length;i++)
{
kirsche=aprikose[i].split("\=");

melone[kirsche[0]]=kirsche[1];
}

document.getElementById("datum4").innerHTML="Sie waren zum letzten Mal am "+melone['zeit']+" auf dieser Website.Ihr Hobby ist "+melone['hobby']+" und die Augenfarbe "+melone['Augenfarbe'];
document.cookie=
"zeit="+aktuellezeit+"&hobby=schwimmen&Augenfarbe=blau"+";expires="+laufzeit.toGMTString();
}
else
{
document.getElementById("datum4").innerHTML="Sie waren noch nie auf dieser Website. Nochmal drücken";
document.cookie=
"zeit="+aktuellezeit+"&hobby=schwimmen&Augenfarbe=blau"+";expires="+laufzeit.toGMTString();
}
}
</script>
</head>
<body>
<div id="datum4"></div>
</body>
</html>

Schauen wir uns an, was passiert, indem wir hier clicken.

Wie deutlich zu sehen, haben wir jetzt jeden Wert einzeln. Die Logik dahinter ist relativ simpel. Zu Beginn des Skriptes definieren wir drei Arrays

aprikose=new Array();
kirsche=new Array();
melone=new Array();

Den Cookie, der im Format variable1=wert1&variable2=wert2 etc. vorliegt, knacken wir auf.
Zuerst am kaufmännischen und (&) Zeichen.

aprikose=document.cookie.split("\&");

Wir erhalten einen Array, der alle Variablename/Werte Paare speichert. aprikose[0] ist also zeit=17.4.2003 3:18:3, aprikose[1] ist hobby=schwimmen, aprikose[2] ist Augenfarbe=blau etc. Diesen Array durchlaufen wir in einer for Schleife und splitten wieder und übergeben die Werte an einen Hash.

for(i=0;i {
kirsche=aprikose[i].split("\=");
melone[kirsche[0]]=kirsche[1];
}

Alles klar ? Wir knacken die Einzelteile (Augenfarbe=blau etc.) am Gleichheitzeichen auf. Haben dann in kirsche[0] Augenfarbe und in Kirsche[1] blau (mutatis mutandis für hobby=schwimmen etc). Mit den Einzelteilen bauen wir dann den Hash, dabei ist Kirsche[0], was ja Augenfarbe ist, der Schlüssel des Hash und Kirsche[1] der Wert. Zur Verdeutlichung mal ausgeschrieben.

melone['Augenfarbe']='blau';

Wir können also jetzt auf jede Variable isoliert zugreifen. Das lassen wir uns dann drucken.

document.getElementById("datum4").innerHTML="Sie waren zum letzten Mal am "+melone['zeit']+" auf dieser Website.Ihr Hobby ist "+melone['hobby']+" und die Augenfarbe "+melone['Augenfarbe'];

Mehrere Cookies auf einmal einrichten

nach oben

Wenn es einen Cookie mit einem bestimmten Namen schon gibt, dann wird der alte Cookie überschrieben, wie dieses Beispiel zeigt.

<html><head><title>Cookies</title></head>
<body>
<script language="javascript">
jetzt=new Date();
laufzeit=new Date(jetzt.getTime() + 1000*60*60*24*7);
zahl=0;
function zeitansage7()
{
zahl++;
if(document.cookie)
{
document.getElementById("datum4").innerHTML="Wert für Zahl: "+document.cookie;
document.cookie="Zahl="+zahl+";expires="+laufzeit.toGMTString();
}
else
{
document.getElementById("datum4").innerHTML="Wert für Zahl: "+document.cookie;
document.cookie="Zahl="+zahl+";expires="+laufzeit.toGMTString();
}
}
</script>
<body>
<A href=javascript:zeitansage7()>hier</A>
<div id="datum4" style="font-family:Arial, Helvetica, sans-serif; color:#006666; font-size:12px; font-weight:bold"></div>
</body></html>

Wie deutlich zu sehen, wird hier derselbe Cookie so oft geschrieben, mit einem jeweils unterschiedlichen Wert, wie der User auf hier clickt. Der Unterschied Wert ist durch die Tatsache bedingt, dass der Wert der Variable Zahl jedesmal um eins erhöht wird. Das es funktionniert kann man prüfen, indem man hier clickt.

Die spannendere Frage ist nun, was passiert, wenn man von einer Seite aus mehrere Cookies mit unterschiedlichen Namen einrichtet, also so was in der Art macht.

<html><head><title>Cookies</title></head>
<body>
<script language="javascript">
jetzt=new Date();
laufzeit=new Date(jetzt.getTime() + 1000*60*60*24*7);

Wie deutlich zu sehen, richten wir zwei Cookies ein, einen mit Namen Name und einen mit Namen Test. Lösen wir mal den Skript aus, indem wir hier clicken und schauen uns anschliessend an, wie der Cookie aussieht, der abgespeichert wird.

(Am besten vorher alle cookies löschen und dann zweimal clicken.) Wir sehen also, dass wir beide Cookies erhalten und zwar einfach hintereinander weg. Öffnet man den Cookie, den der Internet Explorer produziert (in der Datei c:\windows\cookies), dann sieht das so aus.

Name
Andres Ehmann&hobby=schwimmen
~~local~~/C:\javascript_handbuch\
1088
3584621440
29565485
2927074208
29564077
*
Test
irgendwas&Augenfarbe=blau
~~local~~/C:\javascript_handbuch\
1088
3584621440
29565485
2927074208
29564077
*

Wir haben also das gleiche wie oben, nur halt doppelt. Stellt sich die Frage, wie wir es in dieser Situation schaffen, auf die einzelnen Werte zuzugreifen. Wie schon erwähnt, stellt uns JavaScript keine speziellen Funktionen zur Verfügung, man muss es also wieder "von Hand machen" also irgendwie sowas in der Art.

<html><head><title>Cookies</title></head>
<body>
<script language="javascript">
jetzt=new Date();
laufzeit=new Date(jetzt.getTime() + 1000*60*60*24*7);
birne=new Array();
aprikose=new Array();
kirsche=new Array();
melone=new Array();

function zeitansage()
{
if(document.cookie)
{
birne=document.cookie.split(";");

for(i=0;i<birne.length;i++)
{
aprikose=birne[i].split("\&");

for(e=0;e<aprikose.length;e++)
{
kirsche=aprikose[e].split("\=");
melone[kirsche[0]]=kirsche[1];
}
}
document.getElementById("datum4").innerHTML="Das Hobby von "+melone["Name"]+" ist "+melone["hobby"]+" er macht "+melone[" Test"]+" und die Augenfarbe ist "+melone["Augenfarbe"];
document.cookie="Name=Andres Ehmann&hobby=schwimmen"+";expires="+laufzeit.toGMTString();
document.cookie="Test=irgendwas&Augenfarbe=blau"+";expires="+laufzeit.toGMTString();
}
else
{
document.getElementById("datum4").innerHTML="Gibt noch keinen Cookie. Drück nochmal drauf";
document.cookie="Name=Andres Ehmann&hobby=schwimmen"+";expires="+laufzeit.toGMTString();
document.cookie="Test=irgendwas&Augenfarbe=blau"+";expires="+laufzeit.toGMTString();
}
}
</script>
<body onload=zeitansage()>
<div id="datum4" style="font-family:Arial, Helvetica, sans-serif; color:#006666; font-size:12px; font-weight:bold"></div>
</body></html>

Wir haben nicht viel getan, wir haben lediglich die Routine, die wir schon oben verwendet haben, um eine for Schleife erweitert. Das heisst, wir splitten zusätzlich noch am Semikolon, weil das ja den einen Cookie vom anderen trennt. Wer jetzt wissen will, was dieser Skript macht, muss hier clicken.

Ermitteln, wie oft ein User schon auf der Seite war

nach oben

Es ist nicht besonders schwierig, ein Programm zu schreiben, dass dem User beim Betreten der Seite mitteilt, wie oft er schon auf der Seite war. Der Websitebetreiber wird dadurch aber auch nicht schlauer, denn er erfährt es trotzdem nicht. Würde man aber die Daten aus dem Cookie an ein serverseitig arbeitendes Programm übertragen, und dort in eine Datenbank packen, so könnte man anschliessend ein Programm schreiben, dass die Daten auswertet. Man muss jetzt sehen, dass dies etwas anderes ist, als den Logfile auswerten. Der Logfile kann einen User aber nur aufgrund der IP Adresse erkennen, die kann aber bei jeder Einwahl ins Internet für den gleichen User anders sein. Einen Cookie nahmen können wir selbst vergeben, er ist dann immer gleich, bis der User halt alle Cookies löscht, was die meisten User ja leider ständig machen. Das heisst, auch dieses Verfahren ist nicht präzise, aber unter Umständen präziser als die Auswertung des Logfiles. Unser Programm besteht nun aus zwei Teilen. Dem JavaScript, der den Cookie setzt und hochzählt und einem serverseitig arbeitenden Programm, in unserem Falle Perl, dass den Cookie abspeichert und von unserem JavaScript aufgerufen wird. Hierbei haben wir nun ein Problem, das darin besteht, dass wenn wir mit JavaScript via location.href=http://www.el-dominio.de/cgi-bin/banane.pl?user=XXXX einen Perlsript aufrufen und diesem via Query String Werte übergeben, eben dieser Perl Skript etwas zurückgeben will, bzw. er soll in eine Seite aufrufen. Wir wollen aber keine Seite aufrufen, der Perl Skript soll nichts zurückliefern. Das ist aber nicht möglich. Das einzige, was wir in dieser Situation tun können, ist die Rückgabe des Perl Skriptes in einen nicht sichtbaren Frame zu schicken, also etwas in der Art zu machen: nicht_sichtbarer_frame.location.href=http://www.el-dominio.de/cgi-bin/banane.pl?user=XXXX . Die Website, die diesen Skript einsetzt, braucht also einen Frame, der nicht sichtbar ist. Der JavaScript, der das alles bewerkstelligt, sieht dann so aus.

<html><head><title>Operationen mit Zeitangaben</title>
</head>
<script language="javascript">
kirsche=new Array();
birne=new Array();
apfel=new Array();

jetzt=new Date();
laufzeit=new Date(jetzt.getTime() + 1000*60*60*24*5);
wieoft=1;
function wie_oft()
{
if(document.cookie)
{

$gesamter_cookie=document.cookie;
kirsche=document.cookie.split("&");
for(i=0;i<kirsche.length;i++)
{
birne=kirsche[i].split("=");
apfel[birne[0]]=birne[1];
}
apfel["wieoft"]++;
document.getElementById("datum2").innerHTML="Ihre zufällig generierte Besucherkennung ist "+apfel['besucher']+". Sie waren bereits "+apfel['wieoft']+" auf dieser Website.";
document.cookie="besucher="+apfel['besucher']+"&wieoft="+apfel['wieoft']+";expires="+laufzeit.toGMTString();
parent.unsichtbar.location.href="http://www.infos24.de/cgi-bin/besucher.pl?besucher="+apfel['besucher']+"&wieoft="+apfel['wieoft'];
}
else
{
besucher=Math.round(Math.random()*10000000);
document.getElementById("datum2").innerHTML="Sie waren noch nie auf dieser Website. Nochmal drücken";
document.cookie="besucher="+besucher+"&wieoft="+wieoft+";expires="+laufzeit.toGMTString();
parent.unsichtbar.location.href="http://www.infos24.de/cgi-bin/besucher.pl?besucher="+apfel['besucher']+"&wieoft="+apfel['wieoft'];
}
}
window.onload=wie_oft;
</script>
<body>
<div id="datum2"></div>
Betreten Sie diese Website zum zweiten Mal, erkennt JavaScript, dass für Sie bereits ein Cookie gesetzt wurde. Sie werden also "wiedererkannt". Ihr neuer Besuch wird registriert und an den Fremdrechner übermittelt. Ihre Besucherkennung und die Anzahl Ihrer Besuche auf dieser Seite werden gespeichert.
Da Ihre Benutzerkennung immer gleich ist, kann ermittelt werden, wie oft Sie schon auf dieser Seite waren. Allerdings funktionniert das Spiel nur, wenn Sie Ihre Cookies nicht löschen.
</body>
</html>

Der JavaScript schiebt in dieser Zeile

parent.unsichtbar.location.href="http://www.infos24.de/cgi-bin/besucher.pl?besucher="+apfel['besucher']+"&wieoft="+apfel['wieoft'];

einen Perl Skript an, der die Daten auf der Platte speichert. Dieser Perl Skript sieht so aus.

#!/usr/bin/perl

print "Content-type:text/html\n\n";

$frage=$ENV{'QUERY_STRING'};
@frage=split(/&/,$frage);

foreach $i(0..$#frage)
{
($key,$value)=split(/=/,$frage[$i],2);
$value=~s/%(..)/pack("c",hex($1))/ge;
$Frage{$key}=$value;
}
##############################################################

if(!$Frage{modul})
{
open(KIRSCHE,">>besucher.txt");
print KIRSCHE "$ENV{REMOTE_ADDR} $Frage{'besucher'} $Frage{'wieoft'}\n";
close(KIRSCHE);
}
else
{
open(KIRSCHE,"besucher.txt");
@aprikose=<KIRSCHE>;
close(KIRSCHE);
foreach $banane(@aprikose)
{
($besucher,$wieoft)=split(" ",$banane);
print "Besucherkennung: $besucher   Anzahl der Besuche: $wieoft <br>";
}
}

Wer diesen Perl Skript nicht versteht, der kann zum Perl Handbuch hopsen und sich ein bisschen einlesen. Wer die gesamte Anwendung jetzt life sehen will, der muss hier clicken. Dies dürfte wohl, mit der oben genannten Einschränkung, die einzige Möglichkeit sein, genau zu ermitteln, wie oft ein Besucher schon auf der Website war.

vorhergehendes Kapitel	nach oben	nächstes Kapitel