mitmario.dev

Methoden und this

JavaScript Im Browser 3 Min Lesezeit 4 BeispieleLektion 3 von 9

termin.info() soll „Zahnarzt um 09:30 Uhr“ liefern. Dafür muss die Funktion an titel und uhrzeit desselben Objekts herankommen. Eine Funktion, die als Eigenschaft in einem Objekt steht, heißt Methode, und an die anderen Eigenschaften kommt sie über this. Die offene Frage nach this aus der Lektion über Arrow Functions ist damit jetzt dran, denn ohne Objekt ließ sie sich nicht zeigen.

Eine Funktion als Eigenschaft

Eine Funktion als Eigenschaft
const termin = {
  titel: "Zahnarzt",
  uhrzeit: "09:30",

  // Die Kurzschreibweise: Name, Klammern, geschweifte Klammern.
  // Kein function, kein Doppelpunkt.
  info() {
    return `${this.titel} um ${this.uhrzeit} Uhr`;
  },

  // Eine Methode darf eine andere aufrufen, auch über this.
  kurzfassung() {
    return this.info().toUpperCase();
  },
};

console.log(termin.info());
console.log(termin.kurzfassung());

// Ausgeschrieben ginge es auch, es ist nur länger.
const alt = {
  titel: "Friseur",
  info: function () {
    return this.titel;
  },
};
console.log(alt.info());

Eine Funktion darf überall stehen, wo ein Wert erwartet wird. In einem Objekt ist das die rechte Seite eines Doppelpunkts. Das kommt so oft vor, dass es dafür eine eigene Methoden-Kurzschreibweise gibt. Name, runde Klammern, geschweifte Klammern, ohne function und ohne Doppelpunkt.

In der Methode führt this zu dem Objekt, zu dem sie gehört. this.titel liest also dieselbe Eigenschaft, die von außen termin.titel heißt.

Über this kann eine Methode auch eine andere Methode aufrufen. So setzt sich eine große Ausgabe aus kleinen Bausteinen zusammen, wie bei den Funktionen im Werkzeugkasten, die sich gegenseitig benutzen.

Woran this wirklich hängt

this zeigt auf das, was links vom Punkt steht
function wasBinIch() {
  return this;
}

// Dieselbe Funktion, zwei Objekten zugewiesen.
const a = { kennung: "A", frag: wasBinIch };
const b = { kennung: "B", frag: wasBinIch };

console.log("a.frag():", a.frag().kennung);
console.log("b.frag():", b.frag().kennung);

// Und ohne Punkt davor: this ist dann nicht das Objekt.
const losgeloest = a.frag;
console.log("Ohne Objekt:", losgeloest().kennung);

// Der klassische Fall dahinter: eine Methode wird weitergereicht
// und verliert dabei ihr this.
const kurs = {
  titel: "JavaScript",
  zeigen() {
    return this.titel;
  },
};
const zeigen = kurs.zeigen;
console.log("Weitergereicht:", zeigen());

this hängt am Aufruf, nicht an der Stelle, an der die Funktion steht. Es zeigt auf das, was beim Aufruf links vom Punkt stand. Gibst du dieselbe Funktion zwei Objekten, kommen deshalb zwei verschiedene Ergebnisse heraus. a.frag() bekommt a, b.frag() bekommt b.

Daraus folgt ein Fall, der im Alltag ständig vorkommt. Löst man eine Methode aus ihrem Objekt heraus und ruft sie ohne Punkt auf, steht links vom Punkt nichts mehr. Dann zeigt this nicht mehr auf das Objekt, und die Methode liefert still undefined statt des erwarteten Werts, ohne dass in der Console irgendwo ein Fehler auftaucht. Das gilt für ein Skript wie das dieser Lektion. In einer Klasse und in einem Modul aus Abschnitt 18 ist this dort undefined, und dieselbe Zeile wirft einen TypeError.

Worauf this stattdessen zeigt, siehst du in der Eingabezeile der Console. a.frag() antwortet mit {kennung: "A", frag: ƒ wasBinIch()}, also mit dem Objekt selbst. losgeloest() antwortet mit dem Fenster des Browsers, Window. Das Fenster hat keine Eigenschaft .kennung, also kommt undefined heraus. Beschwert hat sich niemand.

Absichtlich macht das kaum jemand, aus Versehen ständig. Wird eine Methode irgendwohin weitergereicht, ist sie schon herausgelöst. In Abschnitt 12 findet deshalb eine Funktion, die auf einen Klick antworten soll, plötzlich nichts mehr, und dort steht auch der Ausweg.

Warum eine Arrow Function hier nicht geht

Die Arrow Function als Methode
const kurs = {
  titel: "JavaScript",

  // Gewöhnliche Funktion: this ist das Objekt.
  richtig() {
    return this.titel;
  },

  // Arrow Function: this kommt von außen und ist hier nicht
  // das Objekt. Kein Fehler, nur undefined.
  falsch: () => this.titel,
};

console.log("richtig():", kurs.richtig());
console.log("falsch():", kurs.falsch());

// Wichtig: das liegt nicht an der Kürze der Schreibweise.
// Diese hier ist genauso kurz und funktioniert.
const kurz = {
  titel: "CSS",
  zeigen() {
    return this.titel;
  },
};
console.log("kurz.zeigen():", kurz.zeigen());

Eine Arrow Function hat kein eigenes this. Sie nimmt das this von der Stelle, an der sie im Code steht. Ein Objektliteral ist ein Objekt, das direkt in geschweiften Klammern hingeschrieben ist. Steht die Arrow Function dort drin, ist ihr this trotzdem nicht das Objekt, denn ein Objektliteral ist kein Gültigkeitsbereich. Sie bekommt das this von außerhalb, und da steht nichts Brauchbares.

Im Skript dieser Lektion kommt dabei undefined heraus, ohne jede Meldung. Das macht den Fall so unangenehm. Der Code sieht richtig aus, läuft durch und liefert Unsinn.

An der Kürze liegt es nicht. Die Methoden-Kurzschreibweise ist genauso kurz und funktioniert einwandfrei, es liegt also allein daran, woher die Arrow Function ihr this nimmt.

Methode und Callback

Arrow Function als Callback in einer Methode
const kurs = {
  titel: "JavaScript",
  themen: ["Objekte", "Arrays", "Events"],

  // Die Methode ist eine gewöhnliche Funktion, damit this stimmt.
  // Der Callback darin ist eine Arrow Function, damit dasselbe
  // this weiter gilt.
  liste() {
    return this.themen.map((thema) => `${this.titel}: ${thema}`);
  },

  // Mit einer gewöhnlichen Funktion als Callback geht das schief.
  listeKaputt() {
    return this.themen.map(function (thema) {
      return `${this.titel}: ${thema}`;
    });
  },
};

console.log(kurs.liste());
console.log(kurs.listeKaputt());

Ich nehme eine gewöhnliche Funktion als Methode und eine Arrow Function als Callback. Warum beides zusammengehört, zeigt das letzte Beispiel.

Die Methode liste ist eine gewöhnliche Funktion, also stimmt ihr this. Der Callback darin ist eine Arrow Function. Die bringt kein eigenes this mit, also gilt darin dasselbe this wie in der Methode. Beide Zugriffe finden das Objekt.

Bei listeKaputt ist der Callback eine gewöhnliche Funktion. Die bringt ihr eigenes this mit, und map ruft sie ohne Objekt auf, also ist das nicht der Kurs. Dieses Verhalten war einer der Gründe für die Arrow Function, die 2015 dazukam.

In der Aufgabe schreibst du zwei Methoden, die über this an die Werte ihres Objekts kommen. Eine dritte bleibt als Gegenbeispiel stehen.

Zum Mitnehmen

Eine Methode kommt mit this an ihr Objekt, und this ist das, was beim Aufruf links vom Punkt steht. Eine Arrow Function hat kein eigenes this und passt deshalb als Callback, aber nicht als Methode.

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 4 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe im Editor, direkt im Browser geprüft

    Öffnet sich mit dem Basis Konto.