‫Jonas: In dieser Vorlesung
‫möchte ich dir verschiedene Dinge mit Modulen zeigen.
‫Und ich möchte Ihnen zunächst grundsätzlich beweisen, dass Node
‫den Code in unseren Modulen tatsächlich in eine Wrapper-Funktion verpackt,
‫wie ich Ihnen in
‫der letzten Vorlesung gezeigt habe.
‫Erstellen wir also wieder eine neue Datei, module. js, und
‫das sind Module, wie diese.
‫Okay, und was ich
‫hier tun werde, ist, die Argumente in die Konsole zu protokollieren, okay?
‫arguments ist also ein Array in JavaScript, und dieses
‫Array enthält alle Werte,
‫die an eine Funktion übergeben wurden.
‫Wenn ich also dieses Argumentarray in der Konsole protokolliere
‫und wir dort tatsächlich einige Werte
‫sehen, bedeutet dies, dass wir uns wirklich in einer Funktion befinden, okay?
‫Lassen Sie uns also Module ausführen.
‫Und tatsächlich haben wir hier den Code in unseren Argumenten.
‫Erinnern wir uns also an die
‫fünf Argumente der Wrapper-Funktion.
‫Der erste ist der Export, also dieser, der
‫derzeit leer
‫ist, weil wir nichts exportieren.
‫Die zweite ist die require-Funktion, also sehen
‫wir, dass
‫wir hier tatsächlich die require-Funktion haben.
‫Dann heißt das dritte Modul, okay.
‫Und im Modul haben wir dann Modul-Exporte, über die wir
‫in der letzten Vorlesung noch einmal gesprochen haben.
‫Und was wir hier haben, ist nicht so wichtig, ich
‫wollte Ihnen nur
‫zeigen, dass wir uns gerade in einer Funktion befinden,
‫sodass der gesamte Code, den wir
‫in diesem Modul haben, tatsächlich in diese Wrapper-Funktion verpackt ist, okay ?
‫Dann sind Nummer drei und Nummer vier der
‫Dateiname und der Verzeichnisname.
‫Und tatsächlich ist dies der Name des Moduls, in dem wir uns gerade
‫befinden, also Module. js.
‫Und dann haben wir hier den Verzeichnisnamen.
‫Also bin ich
‫auf meinem Desktop, und dann in diesem Node-Arbeitsordner.
‫So ähnlich wie
‫hier, aber dann hat dieser den Modulnamen durchgestrichen, okay?
‫Das beweist uns, dass tatsächlich
‫der gesamte Code in einem Modul
‫eingeschlossen ist und dass wir Zugriff auf all diese
‫Variablen haben, also diese Argumente, okay?
‫Ich finde das einfach ein interessantes Experiment, das
‫wir machen können.
‫Und wir können tatsächlich noch eine andere coole Sache machen.
‫Um Ihnen die Wrapper-Funktion
‫tatsächlich zu zeigen, können wir das Modulmodul benötigen, okay.
‫Es gibt also ein Modul
‫namens module, das wir eigentlich nie verwendet haben, aber intern verwendet es Node.
‫Und da drin haben wir die Hülle.
‫Und das ist eigentlich diese Eigenschaft
‫ist eigentlich die Wrapper-Funktion.
‫Das können wir uns jetzt also anschauen.
‫Und wo ist das, ah, ja.
‫Also hier, hier ist es tatsächlich.
‫Dies ist also die Wrapper-Funktion.
‫Und so sehen Sie tatsächlich
‫Export, Anforderung, Modul, Dateiname und Verzeichnisname und
‫dann den Funktionsrumpf.
‫Und das ist es, was Node
‫intern verwendet, also im Grunde dieses Template hier, es
‫verwendet es und füllt dann den Body dieser Funktion mit unserem Code.
‫Okay, also nochmal, nur ein interessantes Experiment hier.
‫Das Wichtigste, was ich Ihnen
‫hier zeigen möchte, ist, wie wir Daten von einem
‫Modul in das andere exportieren und importieren können.
‫Beginnen wir also mit der Erstellung eines neuen Moduls
‫hier, in dem ich einen Taschenrechner erstellen
‫werde, ähnlich wie ich im letzten Video erwähnt habe.
‫Nennen wir das einfach Testmodul-1, denn wir werden
‫ein paar davon haben.
‫Und hier werde ich eine Taschenrechnerklasse erstellen.
‫Dies ist also wieder die
‫ES6-Syntax zum Schreiben von Klassen in JavaScript.
‫Also fügen wir hier ein paar Methoden hinzu, also
‫addieren wir a und b, gibt natürlich a
‫plus b zurück, also sehr einfache Sachen, multiplizieren a, b, gibt a
‫mal b zurück, und dann lass uns
‫einfach auch
‫dividieren, nur der Vollständigkeit halber hier, a, b, so.
‫Speichern Sie es, es formatiert es schön, und
‫jetzt können wir das Modul erstellen. Exporte, genau wie wir im
‫letzten Video gelernt
‫haben, und exportieren unseren Rechner, okay?
‫Also verwenden wir wieder das Modul. exports, wenn
‫wir einen einzelnen Wert exportieren möchten.
‫Und in diesem Fall ist
‫unser einziger Wert hier die Rechnerklasse.
‫Also Modul. exports ist genau das,
‫was von einem Modul zurückgegeben wird, also wird
‫alles, was wir dort ablegen, automatisch exportiert, oder?
‫Wir können den exportierten Wert dann
‫beim Importieren in einer Variablen speichern, also machen wir das jetzt.
‫Und jetzt können wir ihm hier tatsächlich jeden beliebigen Namen geben.
‫Der Name, den wir auf der anderen Seite exportieren, also in
‫diesem anderen Modul, spielt keine Rolle.
‫Wir können es hier nennen, wie wir wollen.
‫In diesem Sinne ist es wie eine normale Funktionsrückgabe, richtig,
‫also können wir immer jede Variable zurückgeben,
‫aber dann anders nennen, wenn
‫wir das Ergebnis einer Funktion im Grunde in einer
‫Variablen speichern, oder?
‫Da es sich um unser
‫eigenes Modul handelt, müssen wir den Schrägstrich verwenden, also das, was ich gerade
‫hier gemacht habe, und dann test-module-1.
‫Und der JS, denk dran, wir können das einfach fallen
‫lassen, es ist nicht nötig, okay?
‫Also diese C-Variable hier, die groß geschrieben
‫ist, weil wir für Klassen normalerweise immer Großbuchstaben verwenden.
‫Und denken Sie daran, dass wir hier tatsächlich eine Klasse exportieren.
‫Okay, wir können diese Klasse jetzt verwenden, um einige Berechnungen durchzuführen.
‫Lassen Sie uns also zuerst einen neuen
‫Taschenrechner erstellen, einen Taschenrechner, denn später werden
‫wir einen anderen haben, okay?
‫Und so erstellen wir jetzt eine neue Instanz eines solchen
‫Taschenrechners, und dies sollte
‫an dieser Stelle für Sie nichts Neues sein.
‫Und dann lassen Sie uns das Ergebnis der tatsächlichen
‫Verwendung über die Konsole protokollieren.
‫Also berechne1. hinzufügen, und sagen wir zwei und fünf.
‫Speichern Sie es und lassen Sie uns diese beiden auskommentieren.
‫Speichern Sie es erneut und dann Node-Module, und hier
‫haben wir das Ergebnis sieben.
‫Das ist also zwei plus fünf, also funktioniert es, oder?
‫Und hier in unserem
‫Testmodul könnten wir es tatsächlich eleganter machen.
‫Wir könnten diese Klasse hier also direkt
‫dem Modul zuordnen. Exporte, oder?
‫Im Moment haben wir also eine Klassendeklaration, das
‫ist also ein bisschen wie
‫eine Funktionsdeklaration, bei der wir Funktionsrechner sagen, und dann dies,
‫und hier sagen wir Klasse, okay?
‫Aber wir könnten es auch mit einem Klassenausdruck machen.
‫Und so verwenden wir den Rechnernamen sowieso
‫einfach nicht.
‫Also kopieren Sie es, kommentieren Sie es aus.
‫Okay, also einfach so.
‫Also sagen wir einfach, dass dies eine
‫Klasse ist, und weisen sie dann einer Variablen zu.
‫Und das ist jetzt ein Ausdruck.
‫Also lass uns das nochmal
‫laufen lassen und wir sehen natürlich wieder unsere Sieben, okay?
‫Auch dies dient nur dazu, den Wert, den wir modulieren
‫möchten, sofort zuzuweisen. exportiert, und das
‫spart uns dann einige Codezeilen und
‫lässt unseren Code wahrscheinlich ein bisschen besser aussehen.
‫Okay, so exportieren wir also Sachen mit dem Modul. exports, und jetzt wollen wir
‫sehen, wie und wann wir die Export-Kurzform verwenden können,
‫die ich auch im vorherigen Video
‫erwähnt habe.
‫Lassen Sie uns hier einfach einen einfachen Kommentar erstellen, Modul. Exporte.
‫Dann hier nur Exporte.
‫Also ein neuer Modultest und nochmal Modul-2. js.
‫Und damit die Alternative zum Do-Modul. exports besteht
‫darin, dem exports-Objekt selbst Eigenschaften hinzuzufügen.
‫Wir könnten es also
‫so machen und wieder das Rechnerbeispiel von vorhin verwenden,
‫wir könnten es so machen.
‫So können wir dem Exportobjekt einfach Eigenschaften hinzufügen.
‫Also geben a und b a plus
‫b, Exporte, zurück. multiplizieren Sie a, b wird a
‫mal b zurückgeben,
‫und jetzt lassen Sie uns der Vollständigkeit halber noch einmal duplizieren, und okay.
‫Wir haben hier also im Wesentlichen drei
‫anonyme Funktionen erstellt, diese
‫drei, und sie drei Eigenschaften von Exporten zugewiesen.
‫Und wenn wir nun dieses Modul auf der anderen Seite
‫exportieren, also in Module. js erhalten wir
‫grundsätzlich Zugriff auf dieses Exportobjekt.
‫Also lass mich dir das zeigen.
‫Nehmen wir an, const calc2 ist erforderlich.
‫Vergessen Sie auch hier nicht Punkt und Schrägstrich, da es
‫sich um unser eigenes Modul handelt.
‫Okay, und nun ist dieser calc2 hier das Exportobjekt.
‫Okay, dann lass mich dir das zeigen.
‫Konsole. log, calc2. hinzufügen, zwei und fünf.
‫Das sollte uns also genau das gleiche Ergebnis liefern wie zuvor.
‫Und tatsächlich, hier ist unsere Sieben, genau wie zuvor.
‫Und wenn
‫wir multipliziert haben, dann sollte das natürlich 10 sein.
‫Also ja, wir haben hier sieben aus der Addition hier,
‫und dann ergibt diese Multiplikation 10.
‫Ich hoffe also, dass dies wirklich einen
‫Unterschied zwischen den Modulen macht. Exporte und Exporte klar.
‫Und wieder, wenn wir einfache Exporte verwenden,
‫können wir diesem Objekt Sachen hinzufügen, also im Grunde Eigenschaften, und
‫wenn wir das dann importieren,
‫also wenn wir dieses Modul benötigen,
‫erhalten wir
‫als Ergebnis ein Objekt mit all diese Eigenschaften.
‫Und da wir ein
‫Objekt bekommen, können wir hier im Grunde die Kraft
‫der ES6-Destrukturierung nutzen, um coole Magie zu vollbringen.
‫Lassen Sie mich diesen also loswerden oder tatsächlich
‫duplizieren, diesen auskommentieren, und so können wir die Destrukturierung
‫verwenden, um das Objekt zu destrukturieren, das wir erhalten, okay?
‫Und es funktioniert so, also verwenden wir die geschweiften Klammern
‫und erstellen dann einfach
‫Variablennamen für die Eigenschaften in diesem Objekt.
‫Lassen Sie uns also wieder Addieren, Multiplizieren und Dividieren verwenden.
‫Das sind also die Namen, die wir tatsächlich
‫für dieses Exportobjekt haben.
‫Also addiere, multipliziere und dividiere,
‫und diese müssen tatsächlich genau den gleichen
‫Namen haben wie im Originalobjekt, okay?
‫Im Grunde wird
‫dadurch eine Variable namens einfach
‫multiplizieren erstellt.
‫Und so ist hier tatsächlich unser Ergebnis.
‫Und wir können eigentlich nur die importieren, die wir wollen.
‫Nehmen wir also an, wir wollen nur addieren und multiplizieren, okay?
‫Und so erhalten wir nur auf diese
‫beiden Zugriff, anstatt alles aus dem Modul zu importieren.
‫Dies ist ein recht häufiges Muster,
‫das Sie in Node sehen werden, und
‫wir werden dies auch während des gesamten Projekts tun.
‫Okay, in diesem Video
‫haben wir hier über die Wrapper-Funktion gesprochen,
‫dann haben wir über das Exportieren
‫und Importieren mit Modulen gesprochen. Exporte und die Kurzform der Exporte.
‫Und jetzt zum
‫Schluss noch einmal kurz über das Caching.
‫Okay, also erstellen wir hier test-module-3.
‫Und was ich hier tun werde, ist eine Konsole zu erstellen. log, also im Grunde
‫genommen ein Code der obersten Ebene in diesem Modul.
‫Hallo aus dem Modul, okay, und dann möchte
‫ich auch noch eine Funktion exportieren.
‫Nur eine einzige Funktion, also Modul. exports
‫equals function ohne Argumente, die sich einfach
‫in der Konsole
‫protokollieren: log diesen schönen Text.
‫Nur ein paar kleine Emojis, damit es ein bisschen knallt.
‫Okay, also fordern wir jetzt dieses Testmodul an.
‫Test-Modul-3, und ich speichere es in keiner Variablen.
‫Stattdessen rufe ich die Funktion sofort auf, ohne
‫sie in einer Variablen zu speichern.
‫Das könnten wir natürlich machen,
‫dann hätten wir die Funktion in einer Variablen und
‫könnten sie dann aufrufen.
‫Aber das ist genau
‫dasselbe, denn dies wird diese Funktion zurückgeben, die wir
‫definiert haben, also diese hier, richtig?
‫Es wird dies zurückgeben, weil wir module verwenden. exports, und
‫dann rufen wir diese Funktion gleich hier auf, okay?
‫Und so machen wir das tatsächlich dreimal.
‫Und denken Sie daran, dass wir Caching in Node. js-Module, was wird Ihrer
‫Meinung nach passieren, wenn wir diesen Code ausführen?
‫Okay, also lass uns das laufen lassen und sehen, was passieren wird.
‫Hier haben wir das Ergebnis, hallo aus
‫dem Modul, und loggen dann dreimal diesen schönen Text ein.
‫Wir haben diese Protokollierung hier also dreimal, weil
‫wir dieselbe Funktion dreimal aufgerufen haben.
‫Aber hallo aus dem Modul haben wir nur einmal, okay?
‫Und das liegt am Caching.
‫Technisch gesehen wurde dieses Modul also nur einmal
‫geladen und der darin enthaltene Code wurde auch nur einmal ausgeführt.
‫Und deshalb wurde diese Codezeile
‫hier, diese Protokollierung nur einmal ausgeführt, okay?
‫Und so kamen diese beiden anderen Protokolle hier, nun
‫ja, sie kamen aus dem Cache, also wurden sie irgendwo
‫im Prozess-Cache des Knotens gespeichert.
‫Und als wir die Funktion hier zum zweiten Mal
‫aufgerufen haben, wurde sie einfach
‫von dort abgerufen, anstatt das Modul erneut zu laden, okay?
‫Also ich bin sicher, das macht für Sie sehr viel Sinn.
‫Und das war eigentlich unser Vortrag.
‫Bei Fragen könnt ihr diese natürlich
‫wie immer im Q&A posten und dort wird euch geholfen.
‫Damit ist dieser gesamte Abschnitt abgeschlossen.
‫Ich weiß, dass es eine ziemliche Fahrt war, bis wir an diesem Punkt
‫ankamen, also eine Menge Dinge zu beachten.
‫Und wenn Sie alles zu 100 %
‫korrigiert haben, machen Sie sich keine
‫allzu großen Sorgen,
‫denn im Laufe des Kurses werden die meisten Dinge irgendwann klar, okay?
‫Machen Sie sich also keine Sorgen, machen Sie einfach im Kurs weiter
‫und wir sehen uns im nächsten Abschnitt.