Clientseitige Speicherung
Moderne Webbrowser bieten Websites verschiedene Möglichkeiten, mit Zustimmung der Benutzer Daten auf deren Computern zu speichern und bei Bedarf wieder abzurufen. So lassen sich Daten langfristig aufbewahren, Websites oder Dokumente für die Offline-Nutzung speichern und benutzerspezifische Einstellungen für eine Website beibehalten. Dieser Artikel erklärt die Grundlagen dieser Verfahren.
| Voraussetzungen: | Vertrautheit mit HTML, CSS und JavaScript, insbesondere mit den Grundlagen von JavaScript-Objekten und grundlegenden APIs wie DOM-Scripting und Netzwerkanfragen. |
|---|---|
| Lernziele: |
|
Was ist clientseitige Speicherung?
An anderer Stelle im MDN-Lernbereich haben wir den Unterschied zwischen statischen Websites und dynamischen Websites besprochen. Die meisten großen modernen Websites sind dynamisch: Sie speichern Daten mithilfe einer Datenbank auf dem Server (serverseitige Speicherung). Anschließend rufen sie mit serverseitigem Code die benötigten Daten ab, fügen sie in statische Seitenvorlagen ein und liefern das resultierende HTML an den Client aus, damit es im Browser angezeigt wird.
Die clientseitige Speicherung funktioniert nach ähnlichen Prinzipien, dient aber anderen Zwecken. Sie umfasst JavaScript-APIs, mit denen Sie Daten auf dem Client, also auf dem Computer der Benutzer, speichern und bei Bedarf wieder abrufen können. Dafür gibt es viele Anwendungsfälle, beispielsweise:
- Einstellungen für eine Website personalisieren, etwa die Auswahl benutzerdefinierter Widgets, eines Farbschemas oder einer Schriftgröße.
- Frühere Aktivitäten auf einer Website beibehalten, etwa den Inhalt eines Warenkorbs aus einer vorherigen Sitzung speichern oder sich merken, ob jemand bereits angemeldet war.
- Daten und Ressourcen lokal speichern, damit eine Website schneller und möglicherweise kostengünstiger geladen werden kann oder ohne Netzwerkverbindung nutzbar ist.
- Von Webanwendungen erzeugte Dokumente lokal speichern, um sie offline zu verwenden.
Häufig werden clientseitige und serverseitige Speicherung gemeinsam eingesetzt. Beispielsweise könnten Sie mehrere Musikdateien herunterladen, die von einem Webspiel oder einer Musikplayer-Anwendung verwendet werden, sie in einer clientseitigen Datenbank speichern und bei Bedarf abspielen. Die Benutzer müssten die Musikdateien nur einmal herunterladen. Bei späteren Besuchen würden sie stattdessen aus der Datenbank abgerufen.
Hinweis: Die Datenmenge, die Sie mit APIs zur clientseitigen Speicherung speichern können, ist begrenzt – möglicherweise sowohl für einzelne APIs als auch insgesamt. Die genaue Grenze hängt vom Browser und gegebenenfalls von Benutzereinstellungen ab. Weitere Informationen finden Sie unter Speicherkontingente und Verdrängungskriterien von Browsern.
Der klassische Weg: Cookies
Das Konzept der clientseitigen Speicherung gibt es schon lange. Seit den Anfängen des Webs verwenden Websites Cookies, um Informationen zu speichern und die Nutzung einer Website zu personalisieren. Sie sind die älteste im Web verbreitete Form der clientseitigen Speicherung.
Heute stehen einfachere Verfahren zum Speichern clientseitiger Daten zur Verfügung. Deshalb erklären wir in diesem Artikel nicht, wie Sie Cookies verwenden. Das bedeutet allerdings nicht, dass Cookies im modernen Web überflüssig sind: Sie werden weiterhin häufig verwendet, um Daten zur Personalisierung und zum Benutzerzustand zu speichern, beispielsweise Sitzungs-IDs und Zugriffstoken. Weitere Informationen finden Sie in unserem Artikel HTTP-Cookies verwenden.
Der moderne Weg: Web Storage und IndexedDB
Die oben erwähnten „einfacheren“ Funktionen sind:
- Die Web Storage API bietet einen Mechanismus zum Speichern und Abrufen kleinerer Datenelemente, die jeweils aus einem Namen und einem zugehörigen Wert bestehen. Das ist nützlich, wenn Sie lediglich einfache Daten speichern müssen, etwa den Namen einer Person, ob sie angemeldet ist oder welche Hintergrundfarbe verwendet werden soll.
- Die IndexedDB API stellt dem Browser ein vollständiges Datenbanksystem zum Speichern komplexer Daten bereit. Damit lassen sich beispielsweise ganze Sammlungen von Kundendatensätzen oder komplexe Datentypen wie Audio- und Videodateien speichern.
Weiter unten erfahren Sie mehr über diese APIs.
Die Cache API
Die Cache API wurde entwickelt, um HTTP-Antworten auf bestimmte Anfragen zu speichern. Sie eignet sich besonders dafür, Ressourcen einer Website offline vorzuhalten, damit die Website anschließend ohne Netzwerkverbindung genutzt werden kann. Cache wird gewöhnlich zusammen mit der Service Worker API verwendet, muss es aber nicht.
Die Verwendung von Cache und Service Workern ist ein fortgeschrittenes Thema, das wir in diesem Artikel nicht ausführlich behandeln. Ein Beispiel zeigen wir jedoch weiter unten im Abschnitt Ressourcen für die Offline-Nutzung speichern.
Einfache Daten speichern – Web Storage
Die Web Storage API ist sehr einfach zu verwenden: Sie speichern einfache Daten als Name-Wert-Paare (beschränkt auf Zeichenfolgen, Zahlen usw.) und rufen die Werte bei Bedarf ab.
Grundlegende Syntax
So funktioniert es:
-
Öffnen Sie unsere leere Web-Storage-Vorlage auf GitHub in einem neuen Tab.
-
Öffnen Sie die JavaScript-Konsole der Entwicklerwerkzeuge Ihres Browsers.
-
Alle Ihre Web-Storage-Daten befinden sich in zwei objektähnlichen Strukturen im Browser:
sessionStorageundlocalStorage. Die erste speichert Daten, solange der Browser geöffnet ist; beim Schließen gehen sie verloren. Die zweite bewahrt Daten auch dann auf, wenn der Browser geschlossen und später erneut geöffnet wird. In diesem Artikel verwenden wir die zweite, da sie im Allgemeinen nützlicher ist.Mit der Methode
Storage.setItem()speichern Sie ein Datenelement. Sie erwartet zwei Parameter: den Namen und den Wert des Elements. Geben Sie Folgendes in Ihre JavaScript-Konsole ein (ersetzen Sie den Wert gern durch Ihren eigenen Namen):jslocalStorage.setItem("name", "Chris"); -
Die Methode
Storage.getItem()erwartet einen Parameter – den Namen des Datenelements, das Sie abrufen möchten – und gibt dessen Wert zurück. Geben Sie nun diese Zeilen in Ihre JavaScript-Konsole ein:jslet myName = localStorage.getItem("name"); myName;Nach Eingabe der zweiten Zeile sollten Sie sehen, dass die Variable
myNamejetzt den Wert des Datenelementsnameenthält. -
Die Methode
Storage.removeItem()erwartet einen Parameter – den Namen des zu entfernenden Datenelements – und entfernt dieses Element aus Web Storage. Geben Sie die folgenden Zeilen in Ihre JavaScript-Konsole ein:jslocalStorage.removeItem("name"); myName = localStorage.getItem("name"); myName;Die dritte Zeile sollte jetzt
nullzurückgeben: Das Elementnameist in Web Storage nicht mehr vorhanden.
Die Daten bleiben erhalten!
Eine wichtige Eigenschaft von Web Storage ist, dass die Daten beim erneuten Laden einer Seite erhalten bleiben – im Fall von localStorage sogar nach dem Schließen des Browsers. Sehen wir uns das praktisch an.
-
Öffnen Sie unsere leere Web-Storage-Vorlage erneut, diesmal aber in einem anderen Browser als dem, in dem Sie dieses Tutorial lesen. Das erleichtert die Arbeit.
-
Geben Sie diese Zeilen in die JavaScript-Konsole des Browsers ein:
jslocalStorage.setItem("name", "Chris"); let myName = localStorage.getItem("name"); myName;Der gespeicherte Name sollte zurückgegeben werden.
-
Schließen Sie nun den Browser und öffnen Sie ihn erneut.
-
Geben Sie die folgenden Zeilen noch einmal ein:
jslet myName = localStorage.getItem("name"); myName;Sie sollten sehen, dass der Wert weiterhin verfügbar ist, obwohl der Browser zwischenzeitlich geschlossen wurde.
Getrennter Speicher für jede Domain
Für jede Domain – also jede eigenständige Webadresse, die im Browser geladen wird – gibt es einen getrennten Datenspeicher. Wenn Sie zwei Websites laden, beispielsweise google.com und amazon.com, und auf einer davon ein Element speichern, ist es auf der anderen nicht verfügbar.
Das ist sinnvoll: Stellen Sie sich die Sicherheitsprobleme vor, die entstünden, wenn Websites gegenseitig auf ihre Daten zugreifen könnten!
Ein ausführlicheres Beispiel
Wenden wir das neu erworbene Wissen an und schreiben wir ein funktionierendes Beispiel für die Verwendung von Web Storage. In unserem Beispiel können Sie einen Namen eingeben. Daraufhin wird die Seite aktualisiert und zeigt eine persönliche Begrüßung an. Dieser Zustand bleibt auch beim erneuten Laden der Seite oder des Browsers erhalten, da der Name in Web Storage gespeichert wird.
Das HTML für dieses Beispiel finden Sie unter personal-greeting.html. Es enthält eine Website mit Kopfbereich, Inhalt und Fußbereich sowie einem Formular zur Eingabe Ihres Namens.

Wir bauen das Beispiel Schritt für Schritt auf, damit Sie verstehen, wie es funktioniert.
-
Erstellen Sie zunächst in einem neuen Verzeichnis auf Ihrem Computer eine lokale Kopie unserer Datei personal-greeting.html.
-
Beachten Sie, dass das HTML mit einer Zeile wie
<script src="index.js" defer></script>auf eine JavaScript-Datei namensindex.jsverweist. Diese Datei müssen wir erstellen und unseren JavaScript-Code darin schreiben. Erstellen Sie im selben Verzeichnis wie Ihre HTML-Datei eine Datei namensindex.js. -
Zunächst erstellen wir Referenzen auf alle HTML-Bestandteile, die wir in diesem Beispiel verändern müssen. Da sich diese Referenzen während der Laufzeit der Anwendung nicht ändern müssen, deklarieren wir sie als Konstanten. Fügen Sie Ihrer JavaScript-Datei die folgenden Zeilen hinzu:
js// create needed constants const rememberDiv = document.querySelector(".remember"); const forgetDiv = document.querySelector(".forget"); const form = document.querySelector("form"); const nameInput = document.querySelector("#entername"); const submitBtn = document.querySelector("#submitname"); const forgetBtn = document.querySelector("#forgetname"); const h1 = document.querySelector("h1"); const personalGreeting = document.querySelector(".personal-greeting"); -
Als Nächstes benötigen wir einen kleinen Event Listener, der verhindert, dass das Formular beim Drücken der Submit-Schaltfläche tatsächlich abgesendet wird. Das ist hier nicht erwünscht. Fügen Sie unter Ihrem bisherigen Code Folgendes hinzu:
js// Stop the form from submitting when a button is pressed form.addEventListener("submit", (e) => e.preventDefault()); -
Nun fügen wir einen Event Listener hinzu, dessen Handler-Funktion ausgeführt wird, wenn auf die Schaltfläche „Say hello“ geklickt wird. Die Kommentare erklären die einzelnen Schritte ausführlich. Im Wesentlichen lesen wir den Namen aus dem Texteingabefeld aus und speichern ihn mit
setItem()in Web Storage. Anschließend rufen wir die FunktionnameDisplayCheck()auf, die den sichtbaren Text der Website aktualisiert. Fügen Sie Folgendes am Ende Ihres Codes hinzu:js// run function when the 'Say hello' button is clicked submitBtn.addEventListener("click", () => { // store the entered name in web storage localStorage.setItem("name", nameInput.value); // run nameDisplayCheck() to sort out displaying the personalized greetings and updating the form display nameDisplayCheck(); }); -
Außerdem benötigen wir einen Event Handler, der beim Klicken auf die Schaltfläche „Forget“ eine Funktion ausführt. Diese Schaltfläche wird erst angezeigt, nachdem auf „Say hello“ geklickt wurde; die beiden Formularzustände wechseln einander ab. In dieser Funktion entfernen wir mit
removeItem()das Elementnameaus Web Storage und rufen anschließend erneutnameDisplayCheck()auf, um die Anzeige zu aktualisieren. Fügen Sie Folgendes am Ende hinzu:js// run function when the 'Forget' button is clicked forgetBtn.addEventListener("click", () => { // Remove the stored name from web storage localStorage.removeItem("name"); // run nameDisplayCheck() to sort out displaying the generic greeting again and updating the form display nameDisplayCheck(); }); -
Jetzt definieren wir die Funktion
nameDisplayCheck()selbst. MitlocalStorage.getItem('name')prüfen wir in einer Bedingung, ob der Name in Web Storage gespeichert wurde. Ist er gespeichert, wird dieser Ausdruck alstrueausgewertet; andernfalls alsfalse. Beitruezeigen wir eine persönliche Begrüßung und den Formularbereich „Forget“ an und blenden den Bereich „Say hello“ aus. Beifalsezeigen wir eine allgemeine Begrüßung an und verfahren mit den Formularbereichen umgekehrt. Fügen Sie wiederum den folgenden Code am Ende hinzu:js// define the nameDisplayCheck() function function nameDisplayCheck() { // check whether the 'name' data item is stored in web Storage if (localStorage.getItem("name")) { // If it is, display personalized greeting const name = localStorage.getItem("name"); h1.textContent = `Welcome, ${name}`; personalGreeting.textContent = `Welcome to our website, ${name}! We hope you have fun while you are here.`; // hide the 'remember' part of the form and show the 'forget' part forgetDiv.style.display = "block"; rememberDiv.style.display = "none"; } else { // if not, display generic greeting h1.textContent = "Welcome to our website "; personalGreeting.textContent = "Welcome to our website. We hope you have fun while you are here."; // hide the 'forget' part of the form and show the 'remember' part forgetDiv.style.display = "none"; rememberDiv.style.display = "block"; } } -
Zu guter Letzt müssen wir die Funktion
nameDisplayCheck()beim Laden der Seite ausführen. Andernfalls würde die persönliche Begrüßung nach einem erneuten Laden nicht angezeigt. Fügen Sie Folgendes am Ende Ihres Codes hinzu:jsnameDisplayCheck();
Ihr Beispiel ist fertig – gut gemacht! Jetzt müssen Sie nur noch Ihren Code speichern und die HTML-Seite im Browser testen. Sie können sich auch unsere fertige Version live ansehen.
Hinweis: Ein weiteres, etwas komplexeres Beispiel finden Sie unter Die Web Storage API verwenden.
Hinweis:
In der Zeile <script src="index.js" defer></script> im Quelltext unserer fertigen Version legt das Attribut defer fest, dass der Inhalt des <script>-Elements erst ausgeführt wird, nachdem die Seite vollständig geladen wurde.
Komplexe Daten speichern – IndexedDB
Die IndexedDB API, manchmal als IDB abgekürzt, ist ein vollständiges Datenbanksystem im Browser. Darin können Sie komplexe, miteinander verknüpfte Daten speichern, deren Typen nicht auf einfache Werte wie Zeichenfolgen oder Zahlen beschränkt sind. Eine IndexedDB-Instanz kann Videos, Bilder und nahezu alles andere enthalten.
Mit der IndexedDB API können Sie eine Datenbank erstellen und darin Object Stores anlegen. Object Stores ähneln Tabellen in einer relationalen Datenbank; jeder Object Store kann mehrere Objekte enthalten. Weitere Informationen zur IndexedDB API finden Sie unter IndexedDB verwenden.
Diese Möglichkeiten haben allerdings ihren Preis: IndexedDB ist deutlich komplexer zu verwenden als die Web Storage API. In diesem Abschnitt können wir ihre Möglichkeiten nur anreißen, vermitteln Ihnen aber genug Wissen für den Einstieg.
Ein Beispiel zum Speichern von Notizen durcharbeiten
Wir führen Sie durch ein Beispiel, mit dem Sie Notizen im Browser speichern und jederzeit anzeigen oder löschen können. Sie bauen es selbst auf und lernen dabei die wichtigsten Grundlagen von IDB kennen.
Die Anwendung sieht ungefähr so aus:

Jede Notiz hat einen Titel und einen Textkörper, die jeweils einzeln bearbeitet werden können. Der JavaScript-Code, den wir im Folgenden durchgehen, enthält ausführliche Kommentare, damit Sie nachvollziehen können, was geschieht.
Erste Schritte
- Erstellen Sie zunächst in einem neuen Verzeichnis auf Ihrem Computer lokale Kopien der Dateien
index.html,style.cssundindex-start.js. - Sehen Sie sich die Dateien an. Das HTML definiert eine Website mit Kopf- und Fußbereich sowie einem Hauptbereich, in dem Notizen angezeigt und über ein Formular neue Notizen in die Datenbank eingegeben werden können. Das CSS gestaltet die Seite, damit die Abläufe besser erkennbar sind. Die JavaScript-Datei enthält fünf deklarierte Konstanten mit Referenzen auf das
<ul>-Element, in dem die Notizen angezeigt werden, die<input>-Elemente für Titel und Text, das<form>selbst und das<button>. - Benennen Sie Ihre JavaScript-Datei in
index.jsum. Nun können Sie beginnen, Code hinzuzufügen.
Die Datenbank einrichten
Sehen wir uns an, was wir zunächst tun müssen, um die Datenbank einzurichten.
-
Fügen Sie unter den Konstantendeklarationen die folgenden Zeilen hinzu:
js// Create an instance of a db object for us to store the open database in let db;Hier deklarieren wir eine Variable namens
db. Sie wird später ein Objekt enthalten, das unsere Datenbank repräsentiert. Da wir sie an mehreren Stellen verwenden, deklarieren wir sie der Einfachheit halber im globalen Gültigkeitsbereich. -
Fügen Sie als Nächstes Folgendes hinzu:
js// Open our database; it is created if it doesn't already exist // (see the upgradeneeded handler below) const openRequest = window.indexedDB.open("notes_db", 1);Diese Zeile erstellt eine Anfrage, um Version
1einer Datenbank namensnotes_dbzu öffnen. Falls sie noch nicht existiert, wird sie durch den nachfolgenden Code erstellt. Dieses Muster mit Anfragen begegnet Ihnen in IndexedDB häufig. Datenbankoperationen benötigen Zeit. Während Sie auf ein Ergebnis warten, soll der Browser nicht blockiert werden. Deshalb erfolgen Datenbankoperationen asynchron: Sie werden nicht sofort abgeschlossen, sondern zu einem späteren Zeitpunkt, und Sie erhalten eine Benachrichtigung, sobald sie beendet sind.Dafür erstellen Sie in IndexedDB ein Anfrageobjekt. Sie können es beliebig benennen; hier heißt es
openRequest, damit sein Zweck erkennbar ist. Anschließend verwenden Sie Event Handler, um Code auszuführen, wenn die Anfrage erfolgreich abgeschlossen wird, fehlschlägt usw. Wie das funktioniert, sehen Sie gleich.Hinweis: Die Versionsnummer ist wichtig. Um einen Object Store oder seine Indizes zu ändern, öffnen Sie die Datenbank mit einer höheren Versionsnummer und nehmen die Änderungen im Handler für
upgradeneededvor (siehe unten). Das Aktualisieren von Datenbanken behandeln wir in diesem Tutorial nicht. -
Fügen Sie direkt unter dem bisherigen Code die folgenden Event Handler hinzu:
js// error handler signifies that the database didn't open successfully openRequest.addEventListener("error", () => console.error("Database failed to open"), ); // success handler signifies that the database opened successfully openRequest.addEventListener("success", () => { console.log("Database opened successfully"); // Store the opened database object in the db variable. This is used a lot below db = openRequest.result; // Run the displayData() function to display the notes already in the IDB displayData(); });Der Event Handler für
errorwird ausgeführt, wenn das System meldet, dass die Anfrage fehlgeschlagen ist. So können Sie auf das Problem reagieren. In unserem Beispiel geben wir lediglich eine Meldung in der JavaScript-Konsole aus.Der Event Handler für
successwird ausgeführt, wenn die Anfrage erfolgreich war und die Datenbank geöffnet wurde. In diesem Fall steht unter der EigenschaftopenRequest.resultein Objekt zur Verfügung, das die geöffnete Datenbank repräsentiert und mit dem wir sie bearbeiten können. Wir speichern es für die spätere Verwendung in der zuvor erstellten Variablendb. Außerdem rufen wir die FunktiondisplayData()auf, die die Daten aus der Datenbank im<ul>anzeigt. Wir rufen sie bereits jetzt auf, damit vorhandene Notizen beim Laden der Seite sofort erscheinen. Die Definition vondisplayData()folgt später. -
Zum Abschluss dieses Abschnitts fügen wir den wohl wichtigsten Event Handler für die Einrichtung der Datenbank hinzu:
upgradeneeded. Dieser Handler wird ausgeführt, wenn die Datenbank noch nicht eingerichtet wurde oder wenn sie mit einer höheren Versionsnummer als die bereits gespeicherte Datenbank geöffnet wird, also bei einem Upgrade. Fügen Sie unter dem vorherigen Handler folgenden Code hinzu:js// Set up the database tables if this has not already been done openRequest.addEventListener("upgradeneeded", (e) => { // Grab a reference to the opened database db = e.target.result; // Create an objectStore in our database to store notes and an auto-incrementing key // An objectStore is similar to a 'table' in a relational database const objectStore = db.createObjectStore("notes_os", { keyPath: "id", autoIncrement: true, }); // Define what data items the objectStore will contain objectStore.createIndex("title", "title", { unique: false }); objectStore.createIndex("body", "body", { unique: false }); console.log("Database setup complete"); });In diesem Handler erstellen wir den Object Store und seine Indizes. Zunächst erhalten wir eine Referenz auf die vorhandene Datenbank über die Eigenschaft
resultdes Event Targets (e.target.result), also desrequest-Objekts. Das entspricht der Zeiledb = openRequest.result;im Event Handler fürsuccess. Hier müssen wir es jedoch separat tun, weil der Event Handler fürupgradeneededgegebenenfalls vor dem fürsuccessausgeführt wird. Andernfalls wäre der Wert vondbnoch nicht verfügbar.Anschließend erstellen wir mit
IDBDatabase.createObjectStore()in unserer geöffneten Datenbank einen neuen Object Store namensnotes_os. Der Store verwendetidals Schlüsselpfad und aktiviertautoIncrement, sodass IndexedDB neuen Datensätzen ohne angegebenen Schlüssel automatisch einen Schlüssel zuweist. Daidder Schlüssel ist, dient dieses Feld dazu, Datensätze eindeutig zu identifizieren, beispielsweise beim Löschen oder Anzeigen.Mit
IDBObjectStore.createIndex()erstellen wir Indizes fürtitleundbody. Über diese Indizes können Sie Notizen anhand der Werte dieser Eigenschaften suchen. Beide Indizes verwendenunique: false, sodass mehrere Notizen denselben Titel oder Textkörper haben können. Ein Datensatz darf auch Eigenschaften enthalten, für die kein Index existiert.
Das Formular in diesem Beispiel liefert die Eigenschaften title und body. Mit der automatisch erzeugten id sieht eine gespeicherte Notiz so aus:
{
"title": "Buy milk",
"body": "Need both cows milk and soy.",
"id": 8
}
Daten zur Datenbank hinzufügen
Sehen wir uns nun an, wie wir Datensätze zur Datenbank hinzufügen. Dazu verwenden wir das Formular auf unserer Seite.
Fügen Sie unter dem bisherigen Event Handler die folgende Zeile hinzu. Sie richtet einen Event Handler für submit ein, der beim Absenden des Formulars die Funktion addData() ausführt. Das geschieht, wenn das Submit-<button> gedrückt wird und das Formular erfolgreich abgesendet werden kann:
// Create a submit event handler so that when the form is submitted the addData() function is run
form.addEventListener("submit", addData);
Definieren wir nun die Funktion addData(). Fügen Sie sie unter der vorherigen Zeile hinzu:
// Define the addData() function
function addData(e) {
// prevent default - we don't want the form to submit in the conventional way
e.preventDefault();
// grab the values entered into the form fields and store them in an object ready for being inserted into the DB
const newItem = { title: titleInput.value, body: bodyInput.value };
// open a read/write db transaction, ready for adding the data
const transaction = db.transaction(["notes_os"], "readwrite");
// call an object store that's already been added to the database
const objectStore = transaction.objectStore("notes_os");
// Make a request to add our newItem object to the object store
const addRequest = objectStore.add(newItem);
addRequest.addEventListener("success", () => {
// Clear the form, ready for adding the next entry
titleInput.value = "";
bodyInput.value = "";
});
// Report on the success of the transaction completing, when everything is done
transaction.addEventListener("complete", () => {
console.log("Transaction completed: database modification finished.");
// update the display of data to show the newly added item, by running displayData() again.
displayData();
});
transaction.addEventListener("error", () =>
console.log("Transaction not opened due to error"),
);
}
Das ist recht komplex. Im Einzelnen tun wir Folgendes:
- Wir rufen
Event.preventDefault()für das Event-Objekt auf, damit das Formular nicht auf herkömmliche Weise abgesendet wird. Das würde die Seite neu laden und die Nutzung beeinträchtigen. - Wir erstellen ein Objekt für den Datensatz, der in die Datenbank eingefügt werden soll, und füllen es mit den Werten aus den Formulareingaben. Einen Wert für
idmüssen wir nicht ausdrücklich angeben: Wie oben erklärt, wird er automatisch ergänzt. - Wir öffnen mit der Methode
IDBDatabase.transaction()einereadwrite-Transaktion für den Object Storenotes_os. Das Transaktionsobjekt ermöglicht uns den Zugriff auf den Object Store, um beispielsweise einen neuen Datensatz hinzuzufügen. - Wir greifen mit der Methode
IDBTransaction.objectStore()auf den Object Store zu und speichern das Ergebnis in der VariablenobjectStore. - Wir fügen den neuen Datensatz mit
IDBObjectStore.add()zur Datenbank hinzu. Dabei wird, wie bereits zuvor, ein Anfrageobjekt erstellt. - Wir fügen den Objekten
requestundtransactionmehrere Event Handler hinzu, um an wichtigen Punkten ihres Ablaufs Code auszuführen. Sobald die Anfrage erfolgreich war, leeren wir die Formulareingaben für die nächste Notiz. Sobald die Transaktion abgeschlossen ist, rufen wir erneutdisplayData()auf, um die angezeigten Notizen zu aktualisieren.
Daten anzeigen
Wir haben in unserem Code bereits zweimal auf displayData() verwiesen. Jetzt sollten wir die Funktion definieren. Fügen Sie sie unter der vorherigen Funktionsdefinition ein:
// Define the displayData() function
function displayData() {
// Here we empty the contents of the list element each time the display is updated
// If you didn't do this, you'd get duplicates listed each time a new note is added
while (list.firstChild) {
list.removeChild(list.firstChild);
}
// Open our object store and then get a cursor - which iterates through all the
// different data items in the store
const objectStore = db.transaction("notes_os").objectStore("notes_os");
objectStore.openCursor().addEventListener("success", (e) => {
// Get a reference to the cursor
const cursor = e.target.result;
// If there is still another data item to iterate through, keep running this code
if (cursor) {
// Create a list item, h3, and p to put each data item inside when displaying it
// structure the HTML fragment, and append it inside the list
const listItem = document.createElement("li");
const h3 = document.createElement("h3");
const para = document.createElement("p");
listItem.appendChild(h3);
listItem.appendChild(para);
list.appendChild(listItem);
// Put the data from the cursor inside the h3 and para
h3.textContent = cursor.value.title;
para.textContent = cursor.value.body;
// Store the ID of the data item inside an attribute on the listItem, so we know
// which item it corresponds to. This will be useful later when we want to delete items
listItem.setAttribute("data-note-id", cursor.value.id);
// Create a button and place it inside each listItem
const deleteBtn = document.createElement("button");
listItem.appendChild(deleteBtn);
deleteBtn.textContent = "Delete";
// Set an event handler so that when the button is clicked, the deleteItem()
// function is run
deleteBtn.addEventListener("click", deleteItem);
// Iterate to the next item in the cursor
cursor.continue();
} else {
// Again, if list item is empty, display a 'No notes stored' message
if (!list.firstChild) {
const listItem = document.createElement("li");
listItem.textContent = "No notes stored.";
list.appendChild(listItem);
}
// if there are no more cursor items to iterate through, say so
console.log("Notes all displayed");
}
});
}
Gehen wir auch diesen Code Schritt für Schritt durch:
- Zunächst leeren wir den Inhalt des
<ul>-Elements, bevor wir es mit den aktualisierten Inhalten füllen. Ohne diesen Schritt würde bei jeder Aktualisierung eine immer längere Liste doppelter Einträge entstehen. - Danach erhalten wir wie in
addData()mitIDBDatabase.transaction()undIDBTransaction.objectStore()eine Referenz auf den Object Storenotes_os. Hier verketten wir die Aufrufe allerdings in einer Zeile. - Anschließend öffnen wir mit der Methode
IDBObjectStore.openCursor()eine Anfrage für einen Cursor. Mit einem Cursor können wir die Datensätze in einem Object Store durchlaufen. Um den Code kürzer zu halten, verketten wir am Ende dieser Zeile einen Event Handler fürsuccess: Sobald der Cursor erfolgreich bereitgestellt wurde, wird der Handler ausgeführt. - Mit
const cursor = e.target.resulterhalten wir eine Referenz auf den Cursor selbst, einIDBCursor-Objekt. - Als Nächstes prüfen wir, ob der Cursor einen Datensatz aus dem Datenspeicher enthält (
if (cursor){ }). Falls ja, erstellen wir ein DOM-Fragment, füllen es mit den Daten des Datensatzes und fügen es innerhalb des<ul>-Elements in die Seite ein. Außerdem fügen wir eine Schaltfläche zum Löschen hinzu. Ein Klick darauf ruft die FunktiondeleteItem()auf und löscht die betreffende Notiz. Diese Funktion betrachten wir im nächsten Abschnitt. - Am Ende des
if-Blocks bewegen wir den Cursor mit der MethodeIDBCursor.continue()zum nächsten Datensatz im Datenspeicher. Danach wird der Inhalt desif-Blocks erneut ausgeführt. Gibt es einen weiteren Datensatz, wird er dadurch in die Seite eingefügt. Anschließend wird wiedercontinue()ausgeführt und so weiter. - Sind keine weiteren Datensätze vorhanden, liefert
cursorden Wertundefined. Deshalb wird statt desif-Blocks derelse-Block ausgeführt. Er prüft, ob Notizen in das<ul>eingefügt wurden. Falls nicht, fügt er eine Meldung ein, dass keine Notiz gespeichert ist.
Eine Notiz löschen
Wie oben beschrieben, wird eine Notiz gelöscht, wenn Sie auf ihre Schaltfläche zum Löschen klicken. Das übernimmt die Funktion deleteItem(), die so aussieht:
// Define the deleteItem() function
function deleteItem(e) {
// retrieve the name of the task we want to delete. We need
// to convert it to a number before trying to use it with IDB; IDB key
// values are type-sensitive.
const noteId = Number(e.target.parentNode.getAttribute("data-note-id"));
// open a database transaction and delete the task, finding it using the id we retrieved above
const transaction = db.transaction(["notes_os"], "readwrite");
const objectStore = transaction.objectStore("notes_os");
const deleteRequest = objectStore.delete(noteId);
// report that the data item has been deleted
transaction.addEventListener("complete", () => {
// delete the parent of the button
// which is the list item, so it is no longer displayed
e.target.parentNode.parentNode.removeChild(e.target.parentNode);
console.log(`Note ${noteId} deleted.`);
// Again, if list item is empty, display a 'No notes stored' message
if (!list.firstChild) {
const listItem = document.createElement("li");
listItem.textContent = "No notes stored.";
list.appendChild(listItem);
}
});
}
- Der erste Teil bedarf einer Erklärung: Mit
Number(e.target.parentNode.getAttribute('data-note-id'))lesen wir die ID des zu löschenden Datensatzes aus. Zur Erinnerung: Beim ersten Anzeigen wurde die ID des Datensatzes in einem Attributdata-note-idam<li>gespeichert. Wir müssen den Attributwert allerdings mit dem globalen, integriertenNumber()-Objekt umwandeln. Er ist nämlich eine Zeichenfolge, während die Datenbank eine Zahl erwartet. - Anschließend erhalten wir nach dem bereits bekannten Muster eine Referenz auf den Object Store und löschen den Datensatz mit der Methode
IDBObjectStore.delete(), der wir die ID übergeben. - Sobald die Datenbanktransaktion abgeschlossen ist, entfernen wir das
<li>der Notiz aus dem DOM. Danach prüfen wir erneut, ob das<ul>nun leer ist, und fügen gegebenenfalls eine entsprechende Meldung ein.
Das war’s! Ihr Beispiel sollte jetzt funktionieren.
Falls Sie Schwierigkeiten haben, können Sie es mit unserem Live-Beispiel vergleichen. Sehen Sie sich dazu auch den Quellcode an.
Komplexe Daten mit IndexedDB speichern
Wie bereits erwähnt, kann IndexedDB mehr als nur Zeichenfolgen speichern. Sie können nahezu alles darin ablegen, auch komplexe Objekte wie Video- oder Bild-Blobs. Das ist kaum schwieriger als das Speichern anderer Datentypen.
Um dies zu demonstrieren, haben wir ein weiteres Beispiel namens IndexedDB-Videospeicher erstellt. Sie können es sich auch live ansehen. Beim ersten Ausführen lädt das Beispiel alle Videos aus dem Netzwerk herunter, speichert sie in einer IndexedDB-Datenbank und zeigt sie anschließend in <video>-Elementen der Benutzeroberfläche an. Beim zweiten Ausführen findet es die Videos in der Datenbank und ruft sie von dort ab, bevor es sie anzeigt. Dadurch benötigen spätere Ladevorgänge deutlich weniger Zeit und Bandbreite.
Gehen wir die interessantesten Teile des Beispiels durch. Wir betrachten nicht alles: Vieles ähnelt dem vorherigen Beispiel, und der Code ist gut kommentiert.
-
Für dieses Beispiel haben wir die Namen der abzurufenden Videos in einem Array aus Objekten gespeichert:
jsconst videos = [ { name: "crystal" }, { name: "elf" }, { name: "frog" }, { name: "monster" }, { name: "pig" }, { name: "rabbit" }, ]; -
Sobald die Datenbank erfolgreich geöffnet wurde, führen wir zunächst eine Funktion
init()aus. Sie durchläuft die verschiedenen Videonamen und versucht, aus der Datenbankvideosjeweils einen Datensatz abzurufen, der durch den Namen identifiziert wird.Wenn ein Video in der Datenbank gefunden wird – dazu prüfen wir, ob
request.resultalstrueausgewertet wird; fehlt der Datensatz, ist der Wertundefined–, werden seine Videodateien, die als Blobs gespeichert sind, und sein Name direkt andisplayVideo()übergeben, damit es in der Benutzeroberfläche erscheint. Andernfalls wird der Videoname anfetchVideoFromNetwork()übergeben, um das Video aus dem Netzwerk abzurufen.jsfunction init() { // Loop through the video names one by one for (const video of videos) { // Open transaction, get object store, and get() each video by name const objectStore = db.transaction("videos_os").objectStore("videos_os"); const request = objectStore.get(video.name); request.addEventListener("success", () => { // If the result exists in the database (is not undefined) if (request.result) { // Grab the videos from IDB and display them using displayVideo() console.log("taking videos from IDB"); displayVideo( request.result.mp4, request.result.webm, request.result.name, ); } else { // Fetch the videos from the network fetchVideoFromNetwork(video); } }); } } -
Der folgende Ausschnitt stammt aus
fetchVideoFromNetwork(). Hier rufen wir mit zwei getrenntenfetch()-Anfragen eine MP4- und eine WebM-Version des Videos ab. Anschließend extrahieren wir mit der MethodeResponse.blob()den Inhalt jeder Antwort als Blob. So erhalten wir eine Objektrepräsentation der Videos, die wir später speichern und anzeigen können.Dabei gibt es ein Problem: Beide Anfragen sind asynchron, aber wir möchten erst versuchen, das Video anzuzeigen oder zu speichern, wenn beide Promises erfüllt sind. Glücklicherweise gibt es dafür eine integrierte Methode:
Promise.all(). Sie erwartet ein Argument – ein Array mit Referenzen auf alle einzelnen Promises, auf deren Erfüllung Sie warten möchten – und gibt ein Promise zurück, das erfüllt wird, sobald alle einzelnen Promises erfüllt sind.Im
then()-Handler dieses Promise rufen wir wie zuvordisplayVideo()auf, um die Videos in der Benutzeroberfläche anzuzeigen. Zusätzlich rufen wirstoreVideo()auf, um sie in der Datenbank zu speichern.js// Fetch the MP4 and WebM versions of the video using the fetch() function, // then expose their response bodies as blobs const mp4Blob = fetch(`videos/${video.name}.mp4`).then((response) => response.blob(), ); const webmBlob = fetch(`videos/${video.name}.webm`).then((response) => response.blob(), ); // Only run the next code when both promises have fulfilled Promise.all([mp4Blob, webmBlob]).then((values) => { // display the video fetched from the network with displayVideo() displayVideo(values[0], values[1], video.name); // store it in the IDB using storeVideo() storeVideo(values[0], values[1], video.name); }); -
Betrachten wir zuerst
storeVideo(). Die Funktion folgt weitgehend dem Muster, das Sie im vorherigen Beispiel zum Hinzufügen von Daten zur Datenbank kennengelernt haben: Wir öffnen einereadwrite-Transaktion, erhalten eine Referenz auf unseren Object Storevideos_os, erstellen ein Objekt für den einzufügenden Datensatz und fügen es mitIDBObjectStore.add()hinzu.js// Define the storeVideo() function function storeVideo(mp4, webm, name) { // Open transaction, get object store; make it a readwrite so we can write to the IDB const objectStore = db .transaction(["videos_os"], "readwrite") .objectStore("videos_os"); // Add the record to the IDB using add() const request = objectStore.add({ mp4, webm, name }); request.addEventListener("success", () => console.log("Record addition attempt finished"), ); request.addEventListener("error", () => console.error(request.error)); } -
Schließlich gibt es
displayVideo(). Diese Funktion erstellt die DOM-Elemente, die zum Anzeigen des Videos in der Benutzeroberfläche nötig sind, und fügt sie in die Seite ein. Besonders interessant sind die unten gezeigten Teile: Um unsere Video-Blobs in einem<video>-Element anzuzeigen, müssen wir mit der MethodeURL.createObjectURL()Objekt-URLs erstellen. Das sind interne URLs, die auf die im Arbeitsspeicher befindlichen Video-Blobs verweisen. Anschließend können wir diese Objekt-URLs als Werte dersrc-Attribute unserer<source>-Elemente verwenden.js// Define the displayVideo() function function displayVideo(mp4Blob, webmBlob, title) { // Create object URLs out of the blobs const mp4URL = URL.createObjectURL(mp4Blob); const webmURL = URL.createObjectURL(webmBlob); // Create DOM elements to embed video in the page const article = document.createElement("article"); const h2 = document.createElement("h2"); h2.textContent = title; const video = document.createElement("video"); video.controls = true; const source1 = document.createElement("source"); source1.src = mp4URL; source1.type = "video/mp4"; const source2 = document.createElement("source"); source2.src = webmURL; source2.type = "video/webm"; // Embed DOM elements into page section.appendChild(article); article.appendChild(h2); article.appendChild(video); video.appendChild(source1); video.appendChild(source2); }
Ressourcen für die Offline-Nutzung speichern
Das vorherige Beispiel zeigt bereits, wie Sie eine Anwendung erstellen, die große Ressourcen in einer IndexedDB-Datenbank speichert, sodass sie nicht mehrfach heruntergeladen werden müssen. Das verbessert die Nutzererfahrung erheblich. Allerdings fehlt noch etwas: Die Hauptdateien für HTML, CSS und JavaScript müssen bei jedem Aufruf der Website erneut heruntergeladen werden. Ohne Netzwerkverbindung funktioniert sie daher nicht.

Hier kommen Service Worker und die eng damit verbundene Cache API ins Spiel.
Ein Service Worker ist eine JavaScript-Datei, die beim Aufruf durch einen Browser für einen bestimmten Origin registriert wird – eine Website oder einen Teil einer Website unter einer bestimmten Domain. Nach der Registrierung kann er Seiten dieses Origins kontrollieren. Dazu befindet er sich zwischen der geladenen Seite und dem Netzwerk und fängt Netzwerkanfragen ab, die an diesen Origin gerichtet sind.
Mit einer abgefangenen Anfrage kann er auf verschiedene Weise umgehen (siehe Ideen für Anwendungsfälle). Das klassische Beispiel besteht darin, Netzwerkantworten offline zu speichern und bei späteren Anfragen statt einer Antwort aus dem Netzwerk die gespeicherte Antwort bereitzustellen. So kann eine Website vollständig offline funktionieren.
Die Cache API ist ein weiterer Mechanismus zur clientseitigen Speicherung, allerdings mit einem besonderen Zweck: Sie ist auf das Speichern von HTTP-Antworten ausgelegt und funktioniert daher sehr gut mit Service Workern.
Ein Service-Worker-Beispiel
Sehen wir uns ein Beispiel an, damit Sie eine Vorstellung davon bekommen, wie das aussehen kann. Wir haben eine weitere Version des Videospeichers aus dem vorherigen Abschnitt erstellt. Sie funktioniert genauso, speichert aber mithilfe eines Service Workers zusätzlich HTML, CSS und JavaScript über die Cache API. Dadurch kann das Beispiel offline ausgeführt werden.
Sehen Sie sich den IndexedDB-Videospeicher mit Service Worker live an und werfen Sie einen Blick auf den Quellcode.
Den Service Worker registrieren
Zunächst fällt ein zusätzlicher Codeabschnitt in der Hauptdatei für JavaScript auf (siehe index.js). Als Erstes prüfen wir mittels Feature Detection, ob das Mitglied serviceWorker im Navigator-Objekt verfügbar ist. Ist das Ergebnis wahr, wissen wir, dass der Browser zumindest die grundlegenden Funktionen von Service Workern unterstützt. Anschließend registrieren wir mit der Methode ServiceWorkerContainer.register() einen Service Worker aus der Datei sw.js für den Origin, unter dem er sich befindet. So kann er Seiten im selben Verzeichnis und in dessen Unterverzeichnissen kontrollieren. Sobald das zugehörige Promise erfüllt ist, gilt der Service Worker als registriert.
// Register service worker to control making site work offline
if ("serviceWorker" in navigator) {
navigator.serviceWorker
.register(
"/learning-area/javascript/apis/client-side-storage/cache-sw/video-store-offline/sw.js",
)
.then(() => console.log("Service Worker Registered"));
}
Hinweis:
Der angegebene Pfad zur Datei sw.js bezieht sich auf den Origin der Website, nicht auf die JavaScript-Datei, die diesen Code enthält. Der Service Worker befindet sich unter https://mdn.github.io/learning-area/javascript/apis/client-side-storage/cache-sw/video-store-offline/sw.js. Der Origin ist https://mdn.github.io; deshalb muss der angegebene Pfad /learning-area/javascript/apis/client-side-storage/cache-sw/video-store-offline/sw.js lauten. Wenn Sie dieses Beispiel auf einem eigenen Server bereitstellen möchten, müssen Sie den Pfad entsprechend ändern. Das mag verwirrend sein, ist aber aus Sicherheitsgründen notwendig.
Den Service Worker installieren
Wenn beim nächsten Mal eine Seite unter der Kontrolle des Service Workers aufgerufen wird, etwa beim erneuten Laden des Beispiels, wird der Service Worker für diese Seite installiert und beginnt, sie zu kontrollieren. Dabei wird auf dem Service Worker ein install-Event ausgelöst. Sie können im Service Worker selbst Code schreiben, der auf die Installation reagiert.
Sehen wir uns ein Beispiel in der Datei sw.js, also im Service Worker, an. Der Listener für install ist auf self registriert. Mit dem Schlüsselwort self können Sie innerhalb der Service-Worker-Datei auf den globalen Gültigkeitsbereich des Service Workers verweisen.
Im Handler für install verwenden wir die auf dem Event-Objekt verfügbare Methode ExtendableEvent.waitUntil(). Damit signalisieren wir dem Browser, dass er die Installation des Service Workers erst abschließen soll, nachdem das übergebene Promise erfolgreich erfüllt wurde.
Hier sehen wir die Cache API in Aktion. Mit der Methode CacheStorage.open() öffnen wir ein neues Cache-Objekt, in dem Antworten gespeichert werden können, ähnlich einem IndexedDB Object Store. Das Promise wird mit einem Cache-Objekt erfüllt, das den Cache video-store repräsentiert. Anschließend rufen wir mit der Methode Cache.addAll() mehrere Ressourcen ab und fügen ihre Antworten dem Cache hinzu.
self.addEventListener("install", (e) => {
e.waitUntil(
caches
.open("video-store")
.then((cache) =>
cache.addAll([
"/learning-area/javascript/apis/client-side-storage/cache-sw/video-store-offline/",
"/learning-area/javascript/apis/client-side-storage/cache-sw/video-store-offline/index.html",
"/learning-area/javascript/apis/client-side-storage/cache-sw/video-store-offline/index.js",
"/learning-area/javascript/apis/client-side-storage/cache-sw/video-store-offline/style.css",
]),
),
);
});
Damit ist die Installation vorerst abgeschlossen.
Auf weitere Anfragen antworten
Der Service Worker ist jetzt registriert und für unsere HTML-Seite installiert; außerdem liegen alle relevanten Ressourcen im Cache. Wir sind fast fertig. Es fehlt nur noch Code, der auf weitere Netzwerkanfragen antwortet.
Das übernimmt der zweite Codeabschnitt in sw.js. Wir fügen dem globalen Gültigkeitsbereich des Service Workers einen weiteren Listener hinzu. Er führt die Handler-Funktion aus, wenn das fetch-Event ausgelöst wird. Das geschieht immer dann, wenn der Browser eine Ressource aus dem Verzeichnis anfordert, für das der Service Worker registriert ist.
Im Handler protokollieren wir zunächst die URL der angeforderten Ressource. Anschließend stellen wir mit der Methode FetchEvent.respondWith() eine eigene Antwort auf die Anfrage bereit.
Innerhalb dieses Blocks prüfen wir mit CacheStorage.match(), ob sich in einem der Caches eine passende Anfrage befindet, deren URL also übereinstimmt. Falls ein Treffer gefunden wird, wird das Promise mit der passenden Antwort erfüllt; andernfalls mit undefined.
Bei einem Treffer geben wir die gespeicherte Antwort zurück. Andernfalls rufen wir die Antwort mit fetch() aus dem Netzwerk ab und geben stattdessen diese zurück.
self.addEventListener("fetch", (e) => {
console.log(e.request.url);
e.respondWith(
caches.match(e.request).then((response) => response || fetch(e.request)),
);
});
Damit ist unser Service Worker fertig. Mit Service Workern lässt sich noch viel mehr machen. Ausführlichere Informationen finden Sie im Service-Worker-Kochbuch. Vielen Dank an Paul Kinlan für seinen Artikel Adding a Service Worker and Offline into your Web App, der dieses Beispiel inspiriert hat.
Das Beispiel offline testen
Um unser Service-Worker-Beispiel zu testen, müssen Sie es einige Male laden, damit der Service Worker sicher installiert ist. Danach können Sie:
- Ihre Netzwerkverbindung trennen oder WLAN ausschalten.
- In Firefox Datei > Offline arbeiten auswählen.
- In Chrome die Entwicklerwerkzeuge öffnen, Application > Service Workers auswählen und das Kontrollkästchen Offline aktivieren.
Wenn Sie die Beispielseite erneut laden, sollte sie weiterhin problemlos angezeigt werden. Alles ist offline gespeichert: die Seitenressourcen in einem Cache und die Videos in einer IndexedDB-Datenbank.
Zusammenfassung
Das war’s fürs Erste. Wir hoffen, dass Ihnen dieser Überblick über Technologien zur clientseitigen Speicherung geholfen hat.