Abschnitt 7 · Lektion 7
Über Objekte laufen
for (const eintrag of wetter) bricht bei einem Objekt mit TypeError: wetter is not iterable ab. Über eine Liste läuft for...of ohne Umstände, über ein Objekt nicht. Ein Objekt ist eine Sammlung benannter Werte und keine Reihe, also musst du sagen, wonach du fragst.
Namen, Werte oder beides
<h1>Ausgabe</h1>
<p>Was dieses Beispiel tut, steht in der Console.</p> const wetter = { stadt: "Leipzig", grad: 7, regen: false };
// Die Namen.
console.log("keys:", Object.keys(wetter));
// Die Werte.
console.log("values:", Object.values(wetter));
// Beides als Paare. Jeder Eintrag ist eine kleine Liste
// aus Name und Wert.
console.log("entries:", Object.entries(wetter));
// Alle drei geben ein Array zurück. Also geht auch das hier.
console.log("Anzahl Eigenschaften:", Object.keys(wetter).length);
console.log("Erstes Paar:", Object.entries(wetter)[0]); Für die drei möglichen Fragen gibt es drei Funktionen. Object.keys liefert die Namen, Object.values die Werte und Object.entries beides als Paare.
Ein Paar ist eine kleine Liste mit genau zwei Einträgen. An Position 0 steht der Name, an Position 1 der Wert. Deshalb passt das Destructuring so gut dazu, und in echtem Code steht es fast immer daneben.
In der Eingabezeile der Console probierst du die drei schneller aus, als man sie beschreiben kann. Object.entries(wetter) antwortet mit einer Liste aus Listen. Mit dem Pfeil davor klappst du die Paare einzeln auf.
Alle drei geben ein Array zurück. Damit kannst du ab jetzt alles aus Abschnitt 6 auch auf Objekte anwenden, und die drei Funktionen sind vor allem eine Brücke dorthin. Die einfachste Anwendung steht schon im Beispiel. Object.keys(wetter).length ist die Anzahl der Eigenschaften, denn ein Objekt hat kein length, eine Liste schon.
Was die Brücke wert ist
<h1>Ausgabe</h1>
<p>Was dieses Beispiel tut, steht in der Console.</p> const punkte = { Ida: 98, Ben: 91, Mila: 87 };
// Durchlaufen mit for...of, und das Paar gleich zerlegen.
for (const [name, wert] of Object.entries(punkte)) {
console.log(`${name} hat ${wert} Punkte`);
}
// Umformen mit map.
const zeilen = Object.entries(punkte).map(
([name, wert]) => `${name}: ${wert}`
);
console.log("Mit map:", zeilen);
// Filtern.
const gut = Object.entries(punkte).filter(([, wert]) => wert >= 90);
console.log("Ab 90:", gut);
// Zusammenfassen.
const summe = Object.values(punkte).reduce((a, b) => a + b, 0);
console.log("Summe:", summe); Ist aus dem Objekt erst mal eine Liste geworden, gilt der ganze Werkzeugkasten. for...of läuft über die Paare. Zerlegst du das Paar gleich in der Kopfzeile, stehen Name und Wert einzeln da. map formt jedes Paar in etwas anderes um, filter wirft welche weg, und reduce fasst alles zu einem Wert zusammen.
Beim filter steht im Beispiel ([, wert]) => ..., und das verwirrt beim ersten Lesen. Es ist das Überspringen beim Destructuring, hier für die erste Stelle. Den Namen braucht niemand, also fällt er weg, und nur das Komma bleibt stehen.
Für die Summe reicht Object.values. Wo ich die Namen nicht brauche, hole ich sie auch nicht. Wer den Code liest, sieht dann an Object.values gleich, dass sie hier egal sind.
Der alte Weg
<h1>Ausgabe</h1>
<p>Was dieses Beispiel tut, steht in der Console.</p> const kurs = { titel: "JavaScript", stunden: 47 };
// Der alte Weg. Die Schleifenvariable ist der Schlüssel,
// an den Wert kommt man mit eckigen Klammern.
for (const schluessel in kurs) {
console.log(schluessel, kurs[schluessel]);
}
// Und jetzt der Grund, warum man ihn meidet.
const basis = { geerbt: "kommt von oben" };
const abgeleitet = Object.create(basis);
abgeleitet.eigen = "steht wirklich drin";
console.log("Mit for...in:");
for (const schluessel in abgeleitet) {
console.log(" ", schluessel);
}
console.log("Mit Object.keys:", Object.keys(abgeleitet)); for...in läuft direkt über die Schlüssel eines Objekts, ohne den Umweg über eine Liste. Die Schleifenvariable ist der Schlüssel, und an den Wert kommst du mit eckigen Klammern.
Das ist kürzer. Es hat aber einen Haken. for...in nimmt auch geerbte Eigenschaften mit. In JavaScript kann ein Objekt Eigenschaften von einem anderen bekommen, und diese Vererbung sieht man dem Objekt nicht an. Im Beispiel legt Object.create(basis) so ein Objekt an, das von basis erbt. Object.keys liefert nur, was wirklich im Objekt selbst steht.
Vererbung kommt in Abschnitt 18, und bis dahin begegnet sie dir kaum. Ich nehme trotzdem Object.keys oder Object.entries. Sie tun das, was man erwartet, sie geben ein Array zurück, und es bleibt kein Sonderfall, den man im Kopf behalten muss.
Zurück und wieder her
<h1>Ausgabe</h1>
<p>Was dieses Beispiel tut, steht in der Console.</p> const wetter = { stadt: "Leipzig", grad: 7, regen: false };
// Von Paaren zurück zum Objekt.
const paare = Object.entries(wetter);
console.log("Zurück:", Object.fromEntries(paare));
// Damit lassen sich Objekte filtern, was es sonst nicht gibt.
const nurTexte = Object.fromEntries(
Object.entries(wetter).filter(([, wert]) => typeof wert === "string")
);
console.log("Nur Texte:", nurTexte);
// Und jetzt die Reihenfolge. Textschlüssel behalten ihre.
console.log("Eingefügt:", Object.keys({ b: 1, a: 2, c: 3 }));
// Schlüssel, die wie ganze Zahlen aussehen, nicht.
console.log("Mit Zahlen:", Object.keys({ 10: "x", 2: "y", b: 1, 1: "z" }));
// Deshalb sieht ein umgedrehtes Objekt manchmal sortiert aus.
const umgedreht = Object.fromEntries(
Object.entries(wetter).map(([name, wert]) => [wert, name])
);
console.log("Umgedreht:", umgedreht); Object.fromEntries ist die Umkehrung von Object.entries. Aus einer Liste von Paaren wird wieder ein Objekt. Damit schließt sich der Kreis, und du kannst plötzlich Dinge tun, die es für Objekte eigentlich gar nicht gibt.
Ein Objekt filtern zum Beispiel. Ein Object.filter gibt es nicht. Aber entries, dann filter, dann fromEntries tut dasselbe, und nach dem zweiten Mal liest du die drei Zeilen flüssig. In der nächsten Lektion wird auf diese Art mit reduce gruppiert.
Bei der Reihenfolge der Schlüssel wartet eine Überraschung. Textschlüssel behalten die Reihenfolge, in der sie eingefügt wurden. Schlüssel, die wie eine ganze Zahl aussehen, stehen dagegen immer vorn und immer aufsteigend sortiert, egal wie sie hineingekommen sind.
Gemeint sind Schlüssel, die als Text eine nicht-negative ganze Zahl sind. "2" gehört dazu, "01" und "2.5" nicht. Die beiden behalten ihre Reihenfolge, und das wird in der nächsten Lektion noch wichtig, denn dort werden Monate als "01" bis "03" gruppiert.
So steht es in der Spezifikation, und es bleibt auch so, weil zu viel Code darauf aufbaut. Im letzten Block steht deshalb ein umgedrehtes Objekt, das anders sortiert dasteht, als es geschrieben wurde.
In der Aufgabe gehen drei Funktionen über eine Liste an ein Objekt heran. Die letzte dreht Schlüssel und Werte um.
Zum Mitnehmen
Object.keys, Object.values und Object.entries machen aus einem Objekt eine Liste, und darauf läuft alles aus Abschnitt 6. Object.fromEntries macht daraus wieder ein Objekt, und auf die Reihenfolge der Schlüssel verlasse ich mich nicht.
Jetzt du
Basis Konto, kostenlosZu 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 4 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe im Editor, direkt im Browser geprüft
Öffnet sich mit dem Basis Konto.