mitmario.dev

Objekte speichern

JavaScript Im Browser 4 Min Lesezeit 3 BeispieleLektion 2 von 5

Eine Notizliste soll das Neuladen überleben, aber der Speicher kann nur Text. Alles, was mehr ist als ein einzelner Wert, muss also erst Text werden.

Was passiert, wenn man es einfach versucht

Das Objekt direkt hineinschreiben
const notiz = { id: 1, text: "Einkaufen", erledigt: false };

// Kein Fehler, keine Warnung. setItem wandelt still in Text um.
localStorage.setItem("merkzettel:notiz", notiz);

const zurueck = localStorage.getItem("merkzettel:notiz");
console.log("Gespeichert:", zurueck);
console.log("Typ:", typeof zurueck);
console.log("Der Text ist da:", zurueck.length, "Zeichen");

// Und der Inhalt ist weg.
console.log("id:", zurueck.id);

// Bei einem Array sieht es anders aus und ist genauso kaputt.
localStorage.setItem("merkzettel:liste", [1, 2, 3]);
console.log("Liste:", localStorage.getItem("merkzettel:liste"));
console.log("Erster Eintrag:", localStorage.getItem("merkzettel:liste")[0]);

setItem beschwert sich nicht über ein Objekt. Es wandelt es still in Text um, auf dem Weg, den JavaScript für jedes Objekt nimmt, das zu Text werden soll, und heraus kommt [object Object].

Es wirft nichts, und es warnt nicht. Im Speicher liegt danach etwas, das aussieht wie ein Wert und keinen enthält.

Bei einem Array ist es tückischer, denn dort sieht das Ergebnis fast richtig aus. Aus [1, 2, 3] wird 1,2,3. Die Zahlen erkennst du wieder, und trotzdem ist es ein Text, aus dem niemand mehr ein Array macht, ohne ihn selbst zu zerlegen.

In der Eingabezeile der Console antwortet localStorage.getItem("merkzettel:notiz") mit [object Object], localStorage.getItem("merkzettel:liste") mit 1,2,3 und typeof localStorage.getItem("merkzettel:liste") mit string. Die dritte Antwort ist der Grund für die ersten beiden.

Der Umweg über JSON

Mit stringify und parse
const notizen = [
  { id: 1, text: "Einkaufen", erledigt: false },
  { id: 2, text: "Kurs weiterschreiben", erledigt: true },
];

// Beim Schreiben: stringify.
localStorage.setItem("merkzettel:notizen", JSON.stringify(notizen));

console.log("Im Speicher liegt Text:", typeof localStorage.getItem("merkzettel:notizen"));
console.log("Und zwar dieser:", localStorage.getItem("merkzettel:notizen"));

// Beim Lesen: parse.
const zurueck = JSON.parse(localStorage.getItem("merkzettel:notizen"));

console.log("Zurück ist es ein Array:", Array.isArray(zurueck));
console.log("Zweiter Text:", zurueck[1].text);
console.log("Offen:", zurueck.filter((n) => !n.erledigt).length);

Damit wird Lektion 16.1 hier zum Handwerk. Beim Schreiben steht JSON.stringify, beim Lesen JSON.parse. Was im Speicher liegt, ist danach ein JSON-Text. Zurück kommt wieder ein Array oder ein Objekt, und damit funktionieren filter, map und der Punktzugriff.

Nach dem zweiten Beispiel antwortet localStorage.getItem("merkzettel:notizen") in der Eingabezeile mit dem vollständigen JSON-Text, und JSON.parse(localStorage.getItem("merkzettel:notizen"))[1].text daneben mit Kurs weiterschreiben. Im Kasten liegt Text, im Programm wieder ein Array.

Was JSON unterwegs verliert, verliert es auch hier. Ein Date kommt als Text zurück und nicht als Datum. Zeitpunkte legst du deshalb am besten gleich als Zahl ab, mit Date.now(), und machst beim Lesen wieder ein Datum daraus.

Warum das Lesen ins try/catch gehört

Beim Schreiben kann nichts schiefgehen, beim Lesen schon. Und der Grund ist unangenehmer, als er klingt.

Was in diesem Speicher liegt, weiß niemand sicher. Vielleicht hat es eine ältere Fassung der Anwendung geschrieben, mit einem anderen Aufbau. Vielleicht hat ein anderer Teil der Seite denselben Schlüssel für etwas ganz anderes benutzt. Oder jemand hat es von Hand hineingeschrieben, denn ein Eintrag lässt sich mit einer einzigen Zeile Code überschreiben.

JSON.parse wirft dann, und ohne try/catch bricht die Anwendung schon beim Start ab, und zwar genau bei dem Menschen, dessen Speicher betroffen ist. Der kann nichts tun außer die Browserdaten zu löschen, und dass er das müsste, sagt ihm niemand. Ein catch, das null zurückgibt, kostet drei Zeilen und verhindert das.

Im dritten Beispiel stehen beide Fälle nebeneinander. leseliste:gibtesnicht hat nie jemand geschrieben, getItem liefert null, und JSON.parse(null) ist wieder null, ganz ohne Fehler. leseliste:kaputt liegt dagegen da, ist aber kein JSON. Dort schlägt das catch zu, in der Console steht Unlesbarer Eintrag: leseliste:kaputt, der Aufrufer bekommt null, und die Datei läuft weiter.

Ohne das try/catch, mit nur return JSON.parse(localStorage.getItem(schluessel));, blieben von der Ausgabe die ersten beiden Zeilen übrig, und danach käme Uncaught SyntaxError: Expected property name or '}' in JSON at position 1 (line 1 column 2). Die Zeile mit Kaputt: käme nie, denn die Datei wäre an dieser Stelle zu Ende. So sieht es auch bei einem echten Besuch der Seite aus, nur dass dort die ganze Anwendung nicht startet.

Zwei Funktionen für den Speicher

Ein Paar aus lies und schreib
function schreib(schluessel, wert) {
  localStorage.setItem(schluessel, JSON.stringify(wert));
}

function lies(schluessel) {
  try {
    return JSON.parse(localStorage.getItem(schluessel));
  } catch (fehler) {
    // Was hier liegt, hat vielleicht eine ältere Fassung
    // der Anwendung geschrieben. Oder jemand von Hand.
    console.warn("Unlesbarer Eintrag:", schluessel);
    return null;
  }
}

schreib("leseliste:stand", { buch: "Momo", seite: 41 });
console.log("Gelesen:", JSON.stringify(lies("leseliste:stand")));

console.log("Nie geschrieben:", JSON.stringify(lies("leseliste:gibtesnicht")));

localStorage.setItem("leseliste:kaputt", "{das ist kein JSON");
console.log("Kaputt:", JSON.stringify(lies("leseliste:kaputt")));

Irgendwann hörst du auf, localStorage überall im Code zu verstreuen. schreib(schluessel, wert) und lies(schluessel) sind zusammen ein Dutzend Zeilen, und danach ruft der Rest des Codes nur noch diese beiden auf.

Kürzer wird es dadurch kaum. Aber drei Entscheidungen fallen genau einmal.

  • Wie umgewandelt wird, steht an einer Stelle.
  • Was bei kaputtem Inhalt passiert, steht an einer Stelle.
  • Zieht die Anwendung später vom Speicher auf einen Server um, ändern sich zwei Funktionen statt vierzig Aufrufe.

Im dritten Beispiel liefert lies für einen fehlenden und für einen unlesbaren Eintrag null. Das ist die einfachste Fassung, und sie schiebt eine Entscheidung nur weiter. Nur der Aufrufer weiß, ob ein fehlender Eintrag ein leeres Array bedeuten soll oder ein leeres Objekt, also muss er das mit null an vierzig Stellen selbst entscheiden. Mit einem zweiten Parameter für den Standardwert steht die Entscheidung wieder im Aufruf.

In der Aufgabe entsteht dieses Paar, mit dem Standardwert als zweitem Parameter.

Zum Mitnehmen

Ein Objekt geht als JSON-Text in den Speicher und kommt mit JSON.parse zurück. Das Lesen gehört in ein try/catch, denn was dort liegt, hat nicht unbedingt der eigene Code geschrieben.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

Was in dieser Lektion steckt

  • Artikel mit 3 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe im Editor, direkt im Browser geprüft

    Öffnet sich mit dem Basis Konto.