Modul 11: Anlage 14: Clientseitige Datenweitergabe und - speicherung : Cookies und Alternativen

von Reinhold Leinfelder

Häufig werden beim Websurfen Daten an Server weitergeben und dort agespeichert. Dies geschieht immer dann, wenn Sie z.B. online-Bestellungen tätigen, an Webumfragen teilnehmen oder auf Diskussionsforen und online-Kalendern Eintragungen machen. Hierbei werden via die vom Benutzer in Formulare eingegebenen Daten via cgi- bzw. Serverplugin-Programmen oder via serverseitiger Skriptsprachen (z.B. php, asp, jsp, vgl. Kursmodul 9) auf dem Server gespeichert. In der Regel sind dies Daten, die der Server eingegeben hat, sie können jedoch auch (vom Webbenutzer unbemerkt) ergänzt werden durch Angaben des verwendeten Browsers, der IP-Nummer des Nutzers oder einiger anderen Charakteristika seiner Hardware.

Interessanterweise sind die Sicherheitsbedenken bei der Verwendung von Cookies sehr viel größer, obwohl zumindest clientseitige Cookies unbedenklich sind. Clientseitige Cookies können einen kleinen Datensatz in der sog. Cookie-Datei des Browsers ablegen. Dies können z.B. Datum eines Seitenbesuchs sein. Bei einem erneuten Seitenbesuch nach nur kurzer Zeit kann der Webbenutzer ggf. gleich auf eine neue Seite umgeleitet werden oder einfach freundlich begrüßt werden. Besonders angenehm ist es, wenn Anmeldedaten für Sitezugänge in einem Cookie abgespeichert werden. Tatsächlich schreibt also der Browser eine kleine Datei an eine definierte Stelle auf der Festplatte des Nutzers. Diese Datei kann aber von außen keinesfalls ausgelesen werden. Auch können keinerlei weitere Daten an anderer Stelle der Festplatte des Nutzers geschrieben oder gar gelöscht werden (siehe hierzu auch Kursmodul 7.1).

Tipp: ich empfehle das automatische Zulassen von clientseitigen Cookies, jedoch das Abschalten bzw. Nachfragen beim Versuch, serverseitige Cookies anzulegen. Im NN 6 finden Sie dies unter Bearbeiten/Einstellungen/Erweitert/Cookies: wählen Sie dort 'nur an die ursprüngliche Seite gesendete Cookies akzeptieren'. Beim IE gibt es leider keine derartige Option. Hier können Sie nur wählen unter 'nie nachfragen', 'für jede Site nachfragen', 'für jedes Cookies nachfragen', 'nie annehmen'. Sie können die Einstellung unter Bearbeiten/Optionen/Dateien empfangen/Cookies vornehmen.

Trotz dieser Unbedenklichkeit haben viele Webbenutzer das Empfangen von Cookies deaktiviert; Sie können also nicht ohne weiteres davon ausgehen, dass Cookies verwendet werden können. Bevor wir also Cookies, welche in der Regel via JavaScript angelegt werden (- auch Formularcgis können ggf. Cookies setzen - ), näher behandeln, wollen wir kurz zuvor eine Alternative erläutern.

---

Clientseitige Datenweitergabe ohne Cookies

Häufig genügt es, einige Daten, wie z.B. Benutzernamen, ggf. auch Passwörter oder andere Daten während des Blätterns eines Benutzers in der Website zu speichern. Dies können wir auch ohne Cookies, und dennoch rein client-seitig erreichen. Wenn Sie Anlage 13 durchgearbeitet haben, können Sie sich wahrscheinlich bereits vorstellen, wie dies funktioniert: wir speichern die entsprechenden, weiterzugebenden Daten in einer Variablen, machen aus ihr einen Suchstring durch Voranstellen eines Fragezeichens und geben diese Daten als Anhang an einen aufzurufenden Link weiter.

Hierzu zwei Beispiele. Der entsprechende Quellcode ist auf den Beispielseiten angegeben und erläutert.

Beispiel 1 - Weitergabe einer Benutzereingabe zur nächsten Seite: hier wird eine Benutzereingabe (ein Name) zur nächsten Seite weitergegeben und auf der nächsten Seite wieder eingelesen.

Beispiel 2 - Weiterangabe einer javascript-generierten Information über mehrere Seiten: hier wird das Datum des Seitenaufrufs der ersten Seite weitergegeben. Auf der zweiten Seite bemerkt man nichts von der Weitergabe, das Startdatum wird noch an die dritte Seite weitergegeben. Erst auf der dritten Seite wird das Startdatum wieder eingelesen.

Tipp für JavaScript-Freaks: Die Weitergabe von Daten via Suchstring kann auch via Absenden eines Formulars geschehen. Hierbei wird als Aktion eine andere html-Seite angesteuert, als Methode muss get verwendet werden, wodurch alle Formulardaten als Suchstring an den aufzurufenden Pfad angeheftet werden. Allerdings bedeutet das Zerteilen des Querystrings ggf. viel Arbeit und Können. Sie müssen wahrscheinlich substring, substr, slice, charAt, indexOf, match und andere Methoden gemeinsam verwenden, um den übergebenen String wieder korrekt zu zerteilen. Leider funktioniert die Weitergabe von Formularangaben via Suchstrings anscheinend nicht unter Netscape.

Sehen Sie zur Erläuterung Beispiel 3 - clientseitige Weitergabe einer Benutzereingabe via Abschicken eines Formulars.

---

Verwenden von Cookies:

Bevor wir auf die Syntax von Cookies näher eingehen, erst mal zwei Beispiele zur Erläuterung der Möglichkeiten:

Beispiel Cookies 1: Alternativer Seitenaufruf bei wiederholtem Besuch. Beim Aufruf einer Seite wird ein Cookie erstellt, ruft man die Seite ein zweites Mal auf (auch nachdem der Computer ausgeschaltet war und beliebig viele Tage verflossen sind) kommt man sofort auf ne alternative Seite. War man auch da schon, wird man auf eine dritte Seite umgeleitet. Auf der dritten Seite gibt es eine Option, die Cookies zu löschen, um bei einem weiteren Besuch wieder die ersten beiden Seiten (auf denen aktuelle News oder spezielle Sonderangebote sein könnten) zu sehen.

Die Skripte wurden von GoLive automatisch generiert und sind äußerst komplex, außerdem beinhalten sie GoLive-Code, der ausschließlich zum Editieren der Seiten mit GoLive verwendbar ist und im Web nicht angezeigt wird. Der Code wird deshalb hier nicht kommentiert, aber probieren Sie es mal aus (rufen Sie das Beispiel am besten mehrfach auf, um die Wirkung der Cookies besser zu verstehen).

Beispiel Cookie 2: Letzter Besuch, Anzahl Ihrer Besuche

Zwei Cookies werden bei jedem Besuch beim Benutzer gesetzt bzw. geändert. Diese halten fest, wann der Besucher die Seite beim letzten Mal besucht hat und wie oft er bereits da war. Wichtig: es handelt sich nicht um einen allgemeinen Seitenzähler, es wird nur gezählt, wie oft der jeweilige Nutzer bereits auf der Seite war. Kein anderer, auch kein Webmaster oder Provider bekommt diese Zahlen mit. Nur wenn gleichzeitig Formulare abgeschickt würden, könnten derartige Angaben ggf. in sog. versteckten Eingabefeldern mit übermittelt werden.

Das Beispiel stammt aus der Pagespinner-Distribution, einem shareware-Webeditor für den Mac.

---

Wie funktionieren Cookies?

Die nachfolgenden Informationen stammen wieder einmal überwiegend aus dem sehr empfehlenswerten JavaScript-Buch von M.Seeboerger, welches auch dem Kursleiter das Verständnis der Cookie-Programmierung ermöglicht hat. Die Beispiele habe ich teilweise etwas abgeändert.

Wird ein Cookie gesetzt, werden sieben Eintträge in ein Cookie-File geschrieben (zumindest so bei Netscape, die Datei heißt bei NC Magic Cookie, bei NN6 cookie.txt. Beim IE wird eine Datei pro Cookie angelegt, aber die Einträge sind entsprechend). Folgende Einträge werden gemacht:

1. Domainnamen bzw. IP-Nummer der aufgerufenen Seite
2. Cookieverfügbarkeit über gesamte Domain ja/nein
3. Verzeichnis, in welchem das Cookie gesetzt wurde.
4. Erlaubnis, Cookie via shttp-Verbindung (sicher) weiterzuübertragen ja/nein
5. Ablaufsdatum des Cookies
6. Cookie-Name
7. Wert des Cookies (das was wirklich gespeichert werden soll)

1 und 3 wird automatisch gesetzt; 4 soll uns hier nicht interessieren (default ist nein). Cookies sind per default nur in dem Ordner verfügbar, über welchen das Cookie angelegt wurde, ansonsten muss dies extra definiert werden. Der Name ist wichtig, um das Cookie wieder auslesen, ändern und löschen zu können, das Ablaufdatum sollte auch gesetzt werden und am wichtigsten ist natürlich der Wert des Cookies in Form eines Strings (also z.B. der zu speichernde Benutzername, das Passwort, ein Datum, die Anzahl der Aufrufe der Seite durch einen bestimmten Benutzer usw.).

So wird ein Cookie via JavaScript angelegt:

function nochnenkeks(name, wert, ablaufsdatum)

window.document.cookie = name + "=" + escape (wert) + "; expires=" ablaufsdatum.toGMTString();

Es gibt also eine Eigenschaft cookie des Objekts document, welches gleichzeitig ein Unterobjekt des window-Objekts ist. Cookie wird ein etwas kompliziert gestalteter String als Wert zu geordnet der, etwa folgendermaßen aussieht:
mycookie=Leinfelder; expires=3929283829;
wobei mycookie der Cookienamen wäre, Leinfelder der Wert (in escape-Modus geschrieben), und 3929283829 ein konkretes Ablaufsdatum, welches mit der Methode toGMTString in eine vielstellige Zahlumgewandelt wurde (Millisekunden seit einem bestimmten, mir gerade nicht geläufigen Stichtag).

Die notwendigen Werte werden bei Funktionsaufruf übergeben, z.B. via onload-, onclick, oder onunload-Eventhandler:

z.B. <body onload=nochnenkeks('mycookie'; besuchername, new Date(2002, 10, 1))"

Im diesem Beispiel ist Besuchername eine Variable, der ein Wert etwa durch Eingabe in ein Formularfeld oder ein Prompt-Feld zugewiesen wurde (z.B. Leinfelder). Das Verfallsdatum muss jeweils über new Date generiert werden. Hier wurde der 1. September 2002 angegeben (in JavaScript beginnen die Monate mit 0).

Anwendungsbeispiel hierzu siehe unten.

Cookie wieder löschen:

Dies ist ein kleines Problem. Cookies löschen sich von selbst, wenn das Ablaufsdatum überschritten ist. Wir können Cookies nicht direkt löschen, jedoch das Verfallsdatum auf das aktuelle Datum oder noch beser ein früheres Datum setzen (für den Fall, dass der Benutzer ein falsches Datum in seinem Computer eingestellt hat), wodurch der Browser sie umgehend löscht. Wir können dazu obige Funktion verwenden und nur im Eventhandler das neue Datum angeben:

<body onunload=nochnenkeks('mycookie'; besuchername, new Date(1970, 0, 1))"

Damit ist das Cookie wieder weg. Funktioniert nur, wenn der cookie-Name identisch ist und das Cookie vom gleichen Verzeichnis aus gelöscht wird, wovon es auch angelegt wurde.

Anwendungsbeispiel hierzu siehe unten

Cookies auslesen und ändern:

Dies ist wohl das Wichtigste im Umgang mit Cookies. Wir benötigen hierzu eine zweite function (Erläuterungen in blau)

Das Beispiel stellt eine kleine Modifikation eines Skriptes von M. Seeboerger (s.o.) dar. Insbesondere haben ich die Variablennamen so gestaltet, dass sie deren Funktion möglichst veranschaulichen. Außerdem lassen wir auch den Wert des Cookies darstellen.

<script language="JavaScript">

var wert;
//wir definieren nur eine globale Variable, die später den Wert des ausgelesenen
//Cookies zugeordnet bekommt.

//nun beginnt die Funktion, der beim Aufruf als Parameter ein
//Wert für die Variable name übergeben wird.

    function schaumermal(name)
    {
     name=name+"=";
//das Anhängen des = Zeichens macht es später einfacher den Cookie-Wert auszulesen.
//Das Hauptproblem beim Auffinden von Cookies ist, dass alle auf dem Benutzercomputer
//gespeicherten Cookies gecheckt werden müssen.
     var kekse=window.document.cookie;

//dazu legen wir eine neue Variable kekse an, die dem Cookie-Objekt entspricht.
//Wichtig: Das Cookie-Objekt beinhaltet alle vorhandenen Cookies in einem einzigen String.

     var a=0;
     while (a < kekse.length)
//kekse.length gibt die Anzahl aller vorhandenen Zeichen im Gesamt-Cookie-String
// an. Wir zählen in der while-Schleife für jedes Zeichen um 1 hoch, so dass nacheinander alle
//Zeichen bis zur maximalen Länge des Gesamtcookiestrings, d.h. kekse.length -1, durchgesehen werden.
//Wir suchen nun im Gesamtcookiestring nach unserem übergebenen Cookie-Namen, z.B.
//mycookie. Dabei muss die Länge des übergebenen Cookienamens berücksichtigt werden.
// dies geschicht durch die Variable b, die als Zeichenposition definiert wird,
// dessen Position die Summe von a (die vorherige Zeichenposition) plus Anzahl der
//Zeichen unseres Cookienamens (incl. angefügtem Gleichheitszeichen) darstellt.
//Nun können wir nach einem Substring in der Länge unseres gesuchten Namens
// (in der if-Abfrage suchen), der bei Position a beginnt und bei Position b
//endet und mit unserem an die Funktion übergebenen Cookienamen übereinstimmen soll.
//Nicht zu vergessen ist, dass wir unseren Namen ja mit angefügtem Gleichheitszeichen
//suchen, also z.B. mycookie= . Dies ist deshalb sinnvoll, weil alle Cookienamen
//von einem derartigen Zeichen beendet werden, welches zum Cookie-Wert überleitet.
      {
       var b = a + name.length;
       if (kekse.substring (a, b) == name)

//Voilà, hier haben wir nun unseren Cookienamen im Gesamtcookie-String gefunden.
//Würde nichts gefunden, wird an die While-Schleife der Wert Null zurückgegeben
//(steht ganz unten an der Funktion).
//Nehmen wir an, das gesuchte Cookie ist aber da, damit geht es nun folgendermaßen weiter:
//In der neuen Variable keksende suchen wir nun nach dem Wert unseres Cookies.
//Dazu sehen wir, ob an Position b, d.h. auf die Stelle nach dem Namen und
//Gleichheitszeichen unseres gefundenen Cookies
//ein Strichpunkt folgt. Solange die Methode indexOf das Zeichen nicht findet, ergibt
//dies den Wert -1. Gesucht wird übrigens nach dem Strichpunkt erst ab dem Zeichen b. Die Angabe einer
//Startposition, ab welcher gesucht werden soll, ist eine zusätzliche Parameteroption
//für die Stringmethode indexOf. Wird der erste Strichpunkt gefunden, bricht die Methode die Suche ab.
//Solange der Bindestrich nicht gefunden wird, bekommt keksende als Wert die Zeichenlänge
// des gesamten Cookiestrings (d.h. aller vorhandenen Cookies) kekse.Wird der Strichpunkt
//nach etlichen Durchläufen gefunden, wird die Schleife abgebrochen und als Ergebnis
//aus dem gesamten Cookiestring ein
//Substring herausgeschnitten, der bei b (also dem Zeichen nach dem Cookienamen) beginnt und
//bei der nun gefundenen keksende-Position, d.h. vor dem Strichpunkt endet. Dies entspricht
//dem Wert des gesuchten Cookies. Wir ordnen unserer globalen Variablen wert diesen
//Cookiewert zu. Dabei wird der Wert noch via unescape-Methode
//decodiert, um Leer- und Sonderzeichen korrekt darzustellen. Außerdem geben wir via Return //diesen Variablenwert zurück, damit er ggf. noch weiterverabeitet werden kann.
//Danach wird die while-Schleife via break abgebrochen, damit wir nicht in einer Dauerschleife enden.
//Der Return-Wert ist nun im Browserspeicher als unsere Variable wert und anderweitig verwendet werden kann. Wir haben ja zuvor bereits den Wert. via document.writeln-
//Methode ausgegeben. Er könnte aber auch in einer weiteren if Abfrage etwa
//für eine location.href -Anweisung weiterververwendet werden.
//Wenn das gesuchte Cookie überhaupt nicht vorhanden war, wird als Returnwert
//null zurückgegeben.        {
         var keksende = kekse.indexOf(";", b);
         if (keksende == -1)
          {
           keksende = kekse.length;
           wert= unescape (kekse.substring (b, keksende));
           document.writeln("<b>Sch&ouml;n, dass Sie wieder da sind. Gleich geht es weiter zu der von Ihnen zuletzt aufgesuchten Seite</b>");
           return wert;
           break;
          }
        }
     }
    return null;
   }

//nun rufen wir unsere Funktion überhaupt erst einmal auf. Wir könnten dies via onload-handler machen, wir
//verwenden hier aber die (aus Kursmodul 7) bekannte Möglichkeit, eine definierte function (die obige function
//schaumermal() ) quasi als selbstgeschaffene Methode aufzurufen. Dazu schaffen wir eine Variable kekseda (quasi
//ein selbstgeschaffenes Objekt), welches seinen Wert durch die Methodenanwendung der function schaumermal()
//bekommt. schaumermal übergibt das gesuchte Wort, d.h. den Wert für die oben definierte Variable name (Beachten
//Sie, dass die Zeile von einem Semikolon abgeschlossen wird, da es sich ja um eine Methode handelt!)

var kekseda=schaumermal("mycookie");
//Der Rückgabewert der Funktion schaumermal (d.h. der Returnwert von oben) wird der Variablen
// kekseda zugeordnet. Hierbei gibt es die Möglichkeit null, wenn das Cookie nicht gefunden wurde, bzw. den Inhalt der Variablen wert, falls es gefunden wurde.

</script>

Wichtig: wenn Sie oben stehendes Skript mit Copy and Paste verwenden, müssen Sie alle Leerzeichen links vom Code entfernen. Es gibt ansonsten ggf. unsichtbare Zeichen, die das Funktionieren des Skripts verhindern. Besser ist es, das Skript von den u.a. Beispielen aus dem Quellcode zu kopieren.

Raucht Ihnen auch der Kopf? Dann sind wir zumindest zwei. Um obiges zu verstehen, sollten Sie in der Regel schon unser komplettes JavaScript-Modul 7 durchgearbeitet haben (es sei denn, Sie sind ein Informatik-Ass, dann habe ich Sie mit obigem sicherlich sehr gelangweilt).

Ich will versuchen, das Prinzip des Cookie-Auslesens nochmals verkürzt darzustellen:

Alle Cookies auf einem Computer sind in einem einzigen Cookie-String gespeichert, der via document.cookie angesprochen werden kann. Der wichtige Bestandteil eines einzelnen Cookies in einem Cookie-String ist z.B.
mycookie=Leinfelder; expires=3929283829; dazu gibt es noch weitere Werte, bis dann das nächste Cookie im gleichen String kommt, also etwa so:
mycookie=Leinfelder; expires=3929283829; superkeks=index2.html; expires=1283469807; path=/multimediakurs/javascript; usw.

Obiges Beispiel beinhaltet zwei Cookies, eins mit Namen mycookie und Wert Leinfelder, das zweite mit Namen superkeks und Wert index2.html. Im zweiten Cookie habe ich noch ein Pfadcharakteristikum eingetragen (vgl. Anlage 14b). Das wäre also ein von mir so genannter Gesamtcookiestring.

Um den Wert eines bestimmten Cookies auszulesen, benötigen wir eine Funktion, die den Namen des gesuchten Cookies übergibt.

Das Cookie wird nun prinzipiell folgendermaßen gesucht. Jedes Zeichen des Gesamtcookiestring wird also, beginnend mit dem Ersten angesteuert und eine Stringstelle definiert, die der Zeichenlänge unseres gesuchten Cookies entspricht (sowie einem zusätzlich angehängten =-Zeichen). Diese Stringstelle wird mit dem gesuchten Namen (incl. angehängten =-Zeichen) verglichen. War es beim ersten mal nichts, rutscht alles eine Stelle weiter und so fort, bis der Namen exakt gefunden wurde (die Stringstelle wird also quasi entlang des Gesamtstrings gescannt).

Wurde der Cookie-Name gefunden, wird nach dem darauffolgenden Strichpunkt gefahndet. Wurde dieser gefunden, wird alles zwischen dem auf den Cookienamen folgenden =-Zeichen und dem Strichpunkt herausgeschnitten. Der Rest des Gesamtstrings wird quasi aus dem Browserspeicher gelöscht (nicht von der Festplatte) und als Wert für weitere Anweisungen zur Verfügung gestellt.

Eigentlich doch einigermaßen einfach? Der Teufel steckt nur in der Detailumsetzung.

---

Beispiel Cookie 3: Speicherung des letzten Seitenbesuchs und automatischer redirect zur entsprechenden Seite bei erneutem Besuch.

Mit obigen Skripten können wir schon eine sehr nette Anwendung basteln.

Stellen wir uns eine Institutseingangsseite vor, die zu verschiedenen Unterseiten (Forschung, Lehre etc.) weiterführt. Via Cookie wird festgehalten, welche Unterseite zuletzt besucht wurde. Verlässt der Besucher dann die Seite von dieser Unterseite aus, wird er beim nächsten Aufruf der Eingangsseite automatisch zur letztbesuchten Seite umgeleitet.

Außerdem muss aber ein looping verhindert werden. Geht der Besucher von einer Unterseite direkt zur Eingangsseite zurück, würde er ja sofort wieder zur Unterseite zurückgeschickt. Zusammen mit dem Linkaufruf muss also das Cookie gelöscht werden.

Cool, nicht wahr? Aber schwierig? Nein, wir verwenden nur obige Skripte.

Insgesamt haben wir drei Seiten im Beispiel: eingang.html, forschung.html und lehre.html, die alle im gleichen Verzeichnis liegen.

Die Seite eingang.html beinhaltet exakt das obige lange Skript. Es prüft, ob ein Cookie namens mycookie vorhanden ist. Wenn nein, schreibt es eine kleine Begrüßungszeile ganz oben auf die Seite und stellt ansonsten den html-Seiteninhalt dar.

Die Seite forschung.html beinhaltet das oben angegebene Cookie-Anlegen-Skript. Die Funktion wird durch onload aufgerufen und legt ein cookie namens mycookie mit dem Wert forschung an.

Die Seite inhalt.html beinhaltet dasselbe Skript, mit dem einzigen Unterschied, dass zwar auch das Cookie namens mycookie angelegt wird (bzw. überschrieben wird), dieses jedoch den Wert lehre bekommt.

Sowohl auf der Seite forschung.html sowie lehre.html gibt es einen Link zur Eingangsseite zurück. Dieser hat einen onclick-handler, der die Cookie-Anlegefunktion nochnenkeks aufruft und dabei ein längst verfallenes Datum übergibt. Damit ist das Cookie verfallen und wird vom Browser gelöscht. Sieht so im Code aus:
<a href="inhalt.html" onclick="nochnenkeks('mycookie', 'forschung', new Date(1970, 0, 1))"> Inhaltsseite</a>

Sie sehen, dass Sie das Skript einfach auf die anderen Unterseiten kopieren können. Evtl. unterschiedliche Cookie-Werte werden einfach bei Aufruf der nochnenkeks-Funktion übergeben. Noch einfach ist es, wenn Sie das Skript als externes Skript auslagern.

Das ist alles. Um das Ganze unten auszuprobieren, könnten Sie in den Optionen Ihres Browsers die Cookiewarnung einstellen (Nachfrage vor jedem Cookie, ob es angenommen werden soll). Ist zwar lästig, zeigt Ihnen aber besonders gut, wann Cookies angelegt bzw. überschrieben werden. Deaktivieren Sie aber hinterher wieder diese Warnung.

Beispiel Cookie 3

Hier noch ein wichtiger Hinweis fürs Programmieren und Testen von Cookies (nach dem Motto: Learning by doing durch den Kursleiter und einer schlaflosen Nacht später :-(

Sie können wunderbare Browserabstürze und Dauerloops verursachen, wenn Sie z.B. Beispiel 3 wechselweise offline und online testen. Wie Sie wissen (s.o.) wird bei einem Cookie ja auch gespeichert, von welchem Server es angelegt wurde. Sie bekommen damit gleichnamige Cookies, die einerseits von Ihrem Server (online-Betrieb), andererseits von Ihrem Rechner (local host, beim offline-Testen) angelegt werden. Wichtig ist auch zu wissen, dass manche Browser einen offline-Test von Cookies gar nicht erst zulassen (/z.B. Opera), was mich zuerst geärgert hat, nun aber beruhigend zu wissen ist, da damit der host-Konflikt gleichnamiger Cookies nicht auftreten kann.

Wenn Sie also Ihre Cookie-Programmierung erst offline und dann online testen wollen, löschen Sie alle Cookies von Ihrer Festplatte, nachdem Sie mit dem offline-Test fertig sind.

Wenn der Browser bei einer Cookie-Seite spinnt, gehen Sie genauso vor und entfernen insbesondere gleichnamige Cookies, die von unterschiedlichen Servern (bzw. Server und local host) angelegt wurden.

Sie wissen nicht, wie Sie Cookies löschen können? Die entsprechenden Optionen verstecken sich in den sog. Einstellungen bzw. Voreinstellungen bzw. Internetoptionen Ihres Browsers. Sehen Sie sich die Screenshots zum Löschen des Caches in Anlage 15 an; hier gelangen Sie in der Regel auch an die Cookies. Unter Netscape 4.x für Mac müssen Sie die sog. Magic Cookie-Datei in den Preferences des Systemordners löschen (bei der PC-Version bin ich da überfragt, aber suchen Sie auch mal nach ner Magic Cookie-Datei, die Sie dann löschen). Bei Opera stellen Sie die Art der Cookie-Akzeptanz unter Preferences/Privacy ein. Die Cookie-Datei heißt Opera-Cookies und liegt ebenfalls in den Preferences, löschen Sie diese. Bei der PC-Version sollte es vergleichbar sein.

Einschränkungen für Cookies:

Neben der Möglichkeit, dass der Benutzer für seinen Browser die Ablehnung von Cookies voreingestellt haben könnte (- womit Sie leben müssen -), gibt es noch weitere Einschränkungen (entnommen aus dem Buch von M. Seeboerger-Weichselbaum, gilt für NC und IE):

• max 300 Cookies sind möglich, mehr kann der Browser nicht verwalten.
• Pro Domain sind max. 20 Cookies erlaubt (also wie in unserem obigen Beispiel mit Cookies arbeiten, die den Namen beibehalten, aber ihre Werte ändern!)
• Die Größe eines Cookies darf 4 kByte nicht überschreiten.

Sind zu viele Cookies vorhanden, werden die zuletzt genutzten Cookies vom Browser gelöscht. Unangenehm ist, dass ein Cookiewert einfach gekappt wird, wenn er 4 kByte überschreitet.

Wenn Sie immer noch nicht genug von Cookies haben, können Sie in der Fortsetzung dieser Seite nachlesen wie obiges Ausleseskript vereinfacht werden kann, wie Sie mit einem Skript gleich mehrerer Cookies setzen können (incl. entsprechender Anwendungsbeispiele), sowie wie Sie Cookies auch lokal, d.h. nur für bestimmte Ordner gültig, anlegen können.

© R. Leinfelder und Paläontologie München, letzte Änderung 28.03.2003

---

Inhaltsseite

Anlagenverzeichnis