Object Methods (Video Version)

Im letzten Talk-Through haben wir gelernt, wie wir einen Objekttyp für unsere beiden Winston-ähnlichen Objekte erstellen

und diese dann mit den Konstruktoren initialisieren.

Nun muss ein Objekttyp nicht nur mit Eigenschaften verbunden sein.

Er kann auch mit Funktionalität verbunden werden. Denke an die Welt und all die Objekttypen in ihr

wie uns Menschen. Wir alle haben Größe und Alter, aber wir haben auch Dinge, die wir tun können, wie schlafen, essen und programmieren.

Und wir wollen diese Funktionen mit diesen Objekttypen assoziieren.

In diesem Programm, das genau gleich ist, wie wir beim letzten Mal aufgehört haben, haben wir hier eine Funktion,

drawWinston, die wir für beide Winston Objekte aufrufen. Wäre es nicht toll, wenn wir diese Funktion einfach

mit dem Objekttyp Winston verbinden könnten? Nun, das können wir, und es ist einfach zu machen.

Also schreiben wir unter unseren Konstruktor Winston - großes W - Punkt -prototyp

Der Prototyp, das ist ein neues Wort, das du wahrscheinlich noch nicht gesehen hast.

Der Prototyp ist diese Eigenschaft eines Objekts, an die wir Funktionen anhängen können

und das bedeutet, dass jedes Objekt, das eine Instanz dieses Objekts ist, dann diese Funktionen hat.

Wir können also sagen: "dot prototype" und dann "dot", und dann den Namen der Funktion, also sagen wir "draw,

equals, und dann können wir unseren drawWinston Code nehmen und ihn einfach

hierher verschieben. Was wir hier gemacht haben ist, dass wir eine Zeichenfunktion an unseren Winston Prototyp angehängt haben.

Und das bedeutet, dass wir in der Lage sein sollten, draw() für jedes Objekt vom Typ Winston aufzurufen

Wir sollten also in der Lage sein, draw() für winstonTeen oder winstonAdult aufzurufen.

Wenn wir eine Funktion wie diese haben, die wir auf ein Objekt anwenden können,

nennen wir das eigentlich eine "Methode", also hörst du mich jetzt vielleicht "Methode" sagen.

Sagen wir also, das ist "die Methode draw()". Okay.

So, jetzt löschen wir dies, und wir löschen das, und jetzt schauen wir, ob wir draw() aufrufen können?

winstonTeen.draw()

Ok. Wir haben einen Fehler, wir haben diese Fehlermeldung hier, sie sagt "winstObject ist nicht definiert"

Okay. Also, vorher haben wir dieses Argument an drawWinston übergeben, welches das Winston Objekt war

aber jetzt übergeben wir es nicht mehr. Ähm, also könnten wir dies ändern, um es zu übergeben

und dann, mal sehen, was würden wir hier übergeben? Wir müssten winstonTeen übergeben. Aha.

Das hat funktioniert, aber das scheint auch wirklich dumm zu sein. Ich rufe bereits draw auf dem Objekt selbst auf.

Ich sollte nicht auch noch das Objekt übergeben müssen. Das scheint überflüssig zu sein.

Und das stimmt, wir sollten das nicht tun müssen, also lass uns das hier löschen, und jetzt lass uns nachdenken.

Wenn wir innerhalb des Objekts sind, was könnten wir benutzen, um auf die Eigenschaften des Objekts zuzugreifen?

Nun, du siehst dir vielleicht unseren Konstruktor an und erinnerst dich an das spezielle Schlüsselwort "this" und denkst "ahh"

"Was, wenn wir dies einfach in this ändern!" Also ändern wir winstObject in "this".

Denn wir befinden uns gerade innerhalb des Objekts. Diese Funktion wird im Objekt ausgewertet

also bezieht sich das "this" auf das aktuelle Objekt.

Auf diese Weise können wir einfach "this" sagen und erhalten Zugriff auf alle Eigenschaften des aktuellen Objekts.

Und das funktioniert perfekt, siehst du? Ist das nicht cool?

Jetzt können wir also sagen winstonAdult.draw()

Tada! Und es wird auf die Eigenschaften von winstonAdult zugreifen, weil das das Objekt ist, für das es aufgerufen wird.

Das ist also das wirklich coole an dem Schlüsselwort "this", auch wenn es manchmal etwas verwirrend sein kann.

Alles klar, das war echt Cool, also lass uns eine weitere Methode hinzufügen. Okay, also, was könnte Winston noch tun?

Vielleicht wird er reden. Also machen wir eine Winston.prototype.talk, damit wir so viele Methoden an den Prototyp anhängen können, wie wir wollen.

Wir sagen also: "Ich bin Winston!"

Und dann sagen wir einfach this.x+20, und this.y+150.

Und dann, ist nichts passiert, aber das liegt natürlich daran, dass ich die Funktion noch nicht wirklich aufgerufen habe.

Also, lassen wir den Teenager sprechen, winstonTeen.talk(), er redet die ganze Zeit

Ich bin Winston, tada! Und dann winstonAdult.talk()

Tada! Alles klar, jetzt haben wir also diesen Winston Objekttyp, der folgende Eigenschaften hat: Nickname,

Age, x, y; und er hat Funktionalität: Verhaltensweisen, Methoden; die abhängig von den Eigenschaften unterschiedlich agieren

und wir können so viele Instanzen von Winstons erstellen, wie wir wollen und jede dieser Methoden darauf aufrufen.

Das ist doch ziemlich cool!