Express Tutorial Teil 2: Erstellung einer Grundstruktur für eine Website

Dieser Artikel zeigt, wie Sie eine "Skelett"-Website mit dem Express Application Generator-Tool erstellen können, die Sie dann mit seiten-spezifischen Routen, Ansichten/Vorlagen und Datenbankaufrufen füllen können. In diesem Fall werden wir das Tool verwenden, um das Framework für unsere Local Library Website zu erstellen, zu der wir später all den anderen vom Standort benötigten Code hinzufügen werden. Der Prozess ist extrem einfach und erfordert nur, dass Sie den Generator in der Befehlszeile mit einem neuen Projektnamen aufrufen, wobei Sie optional auch die Template-Engine und den CSS-Generator der Website angeben können.

Die folgenden Abschnitte zeigen Ihnen, wie Sie den Anwendungs-Generator aufrufen und bieten eine kleine Erläuterung zu den verschiedenen View/CSS-Optionen. Wir werden auch erklären, wie die Skelett-Website strukturiert ist. Am Ende zeigen wir, wie Sie die Website ausführen können, um zu überprüfen, ob sie funktioniert.

Der Generator sollte bereits als Teil des Einrichtens einer Node-Entwicklungsumgebung installiert worden sein. Zur schnellen Erinnerung, Sie installieren das Generator-Tool systemweit mit dem npm-Paketmanager, wie gezeigt:

npm install express-generator -g

Der Generator hat eine Reihe von Optionen, die Sie in der Befehlszeile mit dem --help (oder -h) Befehl ansehen können:

> express --help

    Usage: express [options] [dir]

  Options:

        --version        output the version number
    -e, --ejs            add ejs engine support
        --pug            add pug engine support
        --hbs            add handlebars engine support
    -H, --hogan          add hogan.js engine support
    -v, --view <engine>  add view <engine> support (dust|ejs|hbs|hjs|jade|pug|twig|vash) (defaults to jade)
        --no-view        use static html instead of view engine
    -c, --css <engine>   add stylesheet <engine> support (less|stylus|compass|sass) (defaults to plain CSS)
        --git            add .gitignore
    -f, --force          force on non-empty directory
    -h, --help           output usage information

Sie können express angeben, ein Projekt im aktuellen Verzeichnis mit der Jade View-Engine und einfachem CSS zu erstellen (wenn Sie einen Verzeichnisnamen angeben, dann wird das Projekt in einem Unterordner mit diesem Namen erstellt).

express

Sie können auch eine View-Engine (Vorlagen-Engine) mit --view und/oder eine CSS-Generations-Engine mit --css wählen.

Der Express Application Generator erlaubt es Ihnen, eine Reihe von populären View/Templating-Engines zu konfigurieren, darunter EJS, Hbs, Pug (Jade), Twig und Vash, obwohl er standardmäßig Jade wählt, wenn Sie keine View-Option angeben. Express selbst kann auch eine große Anzahl anderer Templating-Sprachen out of the box unterstützen.

Allgemein gesprochen sollten Sie eine Templating-Engine auswählen, die alle Funktionen bietet, die Sie benötigen, und es Ihnen ermöglicht, schneller produktiv zu sein – mit anderen Worten, auf die gleiche Weise, wie Sie jede andere Komponente auswählen! Einige der Überlegungen bei der Auswahl von Template Engines sind:

• Zeit bis zur Produktivität — Wenn Ihr Team bereits Erfahrung mit einer Templating-Sprache hat, wird es wahrscheinlich schneller produktiv mit dieser Sprache sein. Wenn nicht, sollten Sie die relative Lernkurve für die in Frage kommenden Templating-Engines berücksichtigen.

• Popularität und Aktivität — Überprüfen Sie die Popularität der Engine und ob sie eine aktive Community hat. Es ist wichtig, Unterstützung zu bekommen, wenn während der Lebensdauer der Website Probleme auftreten.

• Stil — Einige Template Engines verwenden bestimmte Markup, um eingefügten Inhalt innerhalb von "gewöhnlichem" HTML anzuzeigen, während andere das HTML mit einer anderen Syntax konstruieren (zum Beispiel durch die Verwendung von Einrückungen und Blocknamen).

• Performance/Rendering-Zeit.

• Funktionen — Sie sollten prüfen, ob die von Ihnen betrachteten Engines die folgenden Funktionen anbieten:

  • Layoutvererbung: Erlaubt es Ihnen, eine Basisvorlage zu definieren und dann nur die Teile davon zu "erben", die für eine bestimmte Seite anders sein sollen. Dies ist typischerweise ein besserer Ansatz als das Erstellen von Vorlagen durch die Einbeziehung einer Reihe von erforderlichen Komponenten oder das Erstellen einer Vorlage von Grund auf jedes Mal.
  • "Include"-Unterstützung: Erlaubt es Ihnen, Vorlagen durch die Einbeziehung anderer Vorlagen zu erstellen.
  • Prägnante Syntax für Variablen- und Schleifensteuerung.
  • Fähigkeit, Variablenwerte auf Template-Level zu filtern, z.B. Variablen groß zu schreiben oder ein Datumswert zu formatieren.
  • Fähigkeit, andere Ausgabeformate als HTML zu generieren, wie JSON oder XML.
  • Unterstützung für asynchrone Operationen und Streaming.
  • Client-seitige Funktionen. Wenn eine Templating-Engine auf dem Client verwendet werden kann, ermöglicht dies die Möglichkeit, das gesamte oder meiste Rendering client-seitig durchzuführen.

Für dieses Projekt werden wir die Pug Templating-Engine verwenden (dies ist die kürzlich umbenannte Jade-Engine), da dies eine der beliebtesten Express/JavaScript Templating-Sprachen ist und vom Generator unterstützt wird.

Der Express Application Generator erlaubt es Ihnen, ein Projekt zu erstellen, das darauf konfiguriert ist, die gebräuchlichsten CSS Stylesheet-Engines zu verwenden: LESS, SASS, Stylus.

Wie bei Templating-Engines sollten Sie die Stylesheet-Engine verwenden, die es Ihrem Team ermöglicht, am produktivsten zu sein. Für dieses Projekt verwenden wir Vanilla CSS (die Standardeinstellung), da unsere CSS-Anforderungen nicht kompliziert genug sind, um etwas anderes zu rechtfertigen.

Der generierte Code verwendet/enthält keine Datenbanken. Express Apps können jeden Datenbankmechanismus verwenden, der von Node unterstützt wird (Express selbst definiert kein spezielles zusätzliches Verhalten/Anforderungen für das Datenbankmanagement).

Wir werden in einem späteren Artikel darüber sprechen, wie man mit einer Datenbank integriert.

Für die Beispielanwendung Local Library, die wir erstellen werden, erstellen wir ein Projekt mit dem Namen express-locallibrary-tutorial unter Verwendung der Pug Template-Bibliothek und keiner CSS-Engine.

Zunächst navigieren Sie zu dem Ort, an dem Sie das Projekt erstellen möchten, und führen Sie dann den Express Application Generator im Eingabeaufforderungsterminal wie gezeigt aus:

express express-locallibrary-tutorial --view=pug

Der Generator erstellt (und listet) die Dateien des Projekts auf.

   create : express-locallibrary-tutorial\
   create : express-locallibrary-tutorial\public\
   create : express-locallibrary-tutorial\public\javascripts\
   create : express-locallibrary-tutorial\public\images\
   create : express-locallibrary-tutorial\public\stylesheets\
   create : express-locallibrary-tutorial\public\stylesheets\style.css
   create : express-locallibrary-tutorial\routes\
   create : express-locallibrary-tutorial\routes\index.js
   create : express-locallibrary-tutorial\routes\users.js
   create : express-locallibrary-tutorial\views\
   create : express-locallibrary-tutorial\views\error.pug
   create : express-locallibrary-tutorial\views\index.pug
   create : express-locallibrary-tutorial\views\layout.pug
   create : express-locallibrary-tutorial\app.js
   create : express-locallibrary-tutorial\package.json
   create : express-locallibrary-tutorial\bin\
   create : express-locallibrary-tutorial\bin\www

   change directory:
     > cd express-locallibrary-tutorial

   install dependencies:
     > npm install

   run the app (Bash (Linux or macOS))
     > DEBUG=express-locallibrary-tutorial:* npm start

   run the app (PowerShell (Windows))
     > $ENV:DEBUG = "express-locallibrary-tutorial:*"; npm start

   run the app (Command Prompt (Windows)):
     > SET DEBUG=express-locallibrary-tutorial:* & npm start

Am Ende der Ausgabe gibt der Generator Anweisungen, wie die Abhängigkeiten (wie in der package.json Datei aufgelistet) installiert und die Anwendung auf verschiedenen Betriebssystemen ausgeführt werden kann.

An diesem Punkt haben wir ein vollständiges Skelettprojekt. Die Website tut tatsächlich noch sehr wenig, aber es lohnt sich, sie auszuführen, um zu zeigen, dass sie funktioniert.

1. Zuerst installieren Sie die Abhängigkeiten (der Befehl install ruft alle in der package.json Datei des Projekts aufgelisteten Abhängigkeitspakete ab).

   bash

   cd express-locallibrary-tutorial
   npm install
   

2. Dann führen Sie die Anwendung aus.

   • In der Windows CMD-Eingabeaufforderung verwenden Sie diesen Befehl:

     batch

     SET DEBUG=express-locallibrary-tutorial:* & npm start
     

   • In Windows PowerShell verwenden Sie diesen Befehl:

     powershell

     ENV:DEBUG = "express-locallibrary-tutorial:*"; npm start
     

     Hinweis: PowerShell-Befehle werden in diesem Tutorial nicht behandelt (Die bereitgestellten "Windows" Befehle setzen voraus, dass Sie die Windows CMD-Eingabeaufforderung verwenden).

   • Auf macOS oder Linux verwenden Sie diesen Befehl:

     bash

     DEBUG=express-locallibrary-tutorial:* npm start
     

3. Laden Sie dann http://localhost:3000/ in Ihrem Browser, um auf die App zuzugreifen.

Sie sollten eine Browser-Seite sehen, die so aussieht:

Herzlichen Glückwunsch! Sie haben nun eine funktionierende Express-Anwendung, die über Port 3000 zugänglich ist.

SET DEBUG=express-locallibrary-tutorial:* & npm start

> express-locallibrary-tutorial@0.0.0 start D:\github\mdn\test\exprgen\express-locallibrary-tutorial
> node ./bin/www

  express-locallibrary-tutorial:server Listening on port 3000 +0ms
GET / 304 490.296 ms - -
GET /stylesheets/style.css 200 4.886 ms - 111

Alle Änderungen, die Sie an Ihrer Express-Website vornehmen, sind derzeit nicht sichtbar, bis Sie den Server neu starten. Es wird schnell sehr ärgerlich, wenn Sie jedes Mal, wenn Sie eine Änderung vornehmen, den Server anhalten und neu starten müssen. Es lohnt sich daher, die Zeit zu investieren, um den Server bei Bedarf automatisch neu zu starten.

Ein praktisches Tool dafür ist nodemon. Dies wird normalerweise global installiert (da es ein "Tool" ist), aber hier werden wir es lokal als Entwicklerabhängigkeit installieren und verwenden, sodass jeder Entwickler, der mit dem Projekt arbeitet, es automatisch erhält, wenn er die Anwendung installiert. Verwenden Sie den folgenden Befehl im Stammverzeichnis des Skelettprojekts:

npm install --save-dev nodemon

Wenn Sie sich noch entscheiden, nodemon global auf Ihrer Maschine zu installieren und nicht nur in die package.json Datei Ihres Projekts:

npm install -g nodemon

Wenn Sie die package.json Datei Ihres Projekts öffnen, sehen Sie jetzt einen neuen Abschnitt mit dieser Abhängigkeit:

 "devDependencies": {
    "nodemon": "^3.1.3"
}

Da das Tool nicht global installiert ist, können wir es nicht über die Befehlszeile starten (es sei denn, wir fügen es dem Pfad hinzu), aber wir können es über ein npm-Skript aufrufen, weil npm alle installierten Pakete kennt. Finden Sie den scripts-Abschnitt Ihrer package.json. Zunächst enthält es eine Zeile, die mit "start" beginnt. Aktualisieren Sie es, indem Sie ein Komma am Ende dieser Zeile setzen und die "devstart" und "serverstart" Zeilen hinzufügen:

• Auf Linux und macOS sieht der Skriptabschnitt so aus:

  json

    "scripts": {
      "start": "node ./bin/www",
      "devstart": "nodemon ./bin/www",
      "serverstart": "DEBUG=express-locallibrary-tutorial:* npm run devstart"
    },
  

• Auf Windows würde der "serverstart" Wert stattdessen so aussehen (bei Verwendung der Eingabeaufforderung):

  bash

  "serverstart": "SET DEBUG=express-locallibrary-tutorial:* & npm run devstart"
  

Wir können nun den Server fast genau wie zuvor starten, aber mit dem Befehl devstart.

Lassen Sie uns nun einen Blick auf das Projekt werfen, das wir gerade erstellt haben.

Das generierte Projekt, jetzt, da Sie Abhängigkeiten installiert haben, hat die folgende Dateistruktur (Dateien sind die Elemente, die nicht mit "/" vorangestellt sind). Die package.json Datei definiert die Anwendungsabhängigkeiten und andere Informationen. Sie definiert auch ein Startskript, das den Anwendungseinstiegspunkt aufruft, die JavaScript-Datei /bin/www. Diese richtet einige der Anwendungsfehlerbehandlungen ein und lädt dann app.js für den Rest der Arbeit. Die App-Routen sind in separaten Modulen im Verzeichnis routes/ gespeichert. Die Vorlagen sind im Verzeichnis /views gespeichert.

express-locallibrary-tutorial
    app.js
    /bin
        www
    package.json
    package-lock.json
    /node_modules
        [about 6700 subdirectories and files]
    /public
        /images
        /javascripts
        /stylesheets
            style.css
    /routes
        index.js
        users.js
    /views
        error.pug
        index.pug
        layout.pug

Die folgenden Abschnitte beschreiben die Dateien etwas genauer.

Die package.json Datei definiert die Anwendungsabhängigkeiten und andere Informationen:

{
  "name": "express-locallibrary-tutorial",
  "version": "0.0.0",
  "private": true,
  "scripts": {
    "start": "node ./bin/www"
  },
  "dependencies": {
    "cookie-parser": "~1.4.4",
    "debug": "~2.6.9",
    "express": "~4.16.1",
    "http-errors": "~1.6.3",
    "morgan": "~1.9.1",
    "pug": "2.0.0-beta11"
  },
  "devDependencies": {
    "nodemon": "^3.1.3"
  }
}

Der Skriptabschnitt definiert zuerst ein "start" Skript, das wir aufrufen, wenn wir npm start verwenden, um den Server zu starten (dieses Skript wurde vom Express Application Generator hinzugefügt). Aus der Skriptdefinition können Sie erkennen, dass dies tatsächlich die JavaScript-Datei ./bin/www mit node startet.

Wir haben diesen Abschnitt bereits in Ermöglichen des Serverneustarts bei Dateiänderungen geändert, indem wir die devstart und serverstart Skripte hinzugefügt haben. Diese können verwendet werden, um die gleiche ./bin/www Datei mit nodemon anstelle von node zu starten (diese Version der Skripte ist für Linux und macOS, wie oben diskutiert).

  "scripts": {
    "start": "node ./bin/www",
    "devstart": "nodemon ./bin/www",
    "serverstart": "DEBUG=express-locallibrary-tutorial:* npm run devstart"
  },

Die Abhängigkeiten beinhalten das express Paket und das Paket für unsere ausgewählte View-Engine (pug). Darüber hinaus haben wir die folgenden Pakete, die in vielen Webanwendungen nützlich sind:

• cookie-parser: Wird verwendet, um den Cookie-Header zu analysieren und req.cookies zu befüllen (bietet im Wesentlichen eine bequeme Methode zum Zugriff auf Cookie-Informationen).
• debug: Ein kleines Node-Debugging-Dienstprogramm, das nach dem Debugging-Ansatz des Node-Kerns modelliert ist.
• morgan: Ein HTTP-Anforderungslogger-Middleware für Node.
• http-errors: Erstellen von HTTP-Fehlern bei Bedarf (für Express-Fehlerbehandlung).

Die Standardversionen im generierten Projekt sind ein wenig veraltet. Ersetzen Sie den Abhängigkeitsabschnitt Ihrer package.json Datei durch den folgenden Text, der die neuesten Versionen dieser Bibliotheken zum Zeitpunkt des Schreibens angibt:

  "dependencies": {
    "cookie-parser": "^1.4.6",
    "debug": "^4.3.5",
    "express": "^4.19.2",
    "http-errors": "~2.0.0",
    "morgan": "^1.10.0",
    "pug": "3.0.3"
  },

Aktualisieren Sie dann Ihre installierten Abhängigkeiten mit dem Befehl:

npm install

npm update --save

Die Datei /bin/www ist der Einstiegspunkt der Anwendung! Das Allererste, was dies tut, ist, die "echte" Anwendungseinstiegspunktdatei (app.js, im Projektstammverzeichnis) zu require()n, die die express() Anwendungsobjekt erstellt und zurückgibt. require() ist die CommonJS-Methode, um JavaScript-Code, JSON und andere Dateien in die aktuelle Datei zu importieren. Hier geben wir das app.js Modul mit einem relativen Pfad an und lassen die optionale (.js) Dateiendung weg.

#!/usr/bin/env node

/**
 * Module dependencies.
 */

const app = require("../app");

Der Rest des Codes in dieser Datei richtet einen Node HTTP-Server mit app ein, der auf einen bestimmten Port (definiert in einer Umgebungsvariablen oder 3000, wenn die Variable nicht definiert ist) gesetzt ist, und beginnt mit dem Zuhören und der Berichterstattung von Server-Fehlern und Verbindungen. Für den Moment müssen Sie über den Code nicht viel mehr wissen (alles in dieser Datei ist "Boilerplate"), aber fühlen Sie sich frei, es zu überprüfen, wenn Sie interessiert sind.

Diese Datei erstellt ein express Anwendungsobjekt (nach Konvention app genannt), richtet die Anwendung mit verschiedenen Einstellungen und Middleware ein und exportiert dann die App aus dem Modul. Der folgende Code zeigt nur die Teile der Datei, die das App-Objekt erstellen und exportieren:

const express = require("express");
const app = express();
// …
module.exports = app;

Im oben genannten www Einstiegspunkt-Datei wird dieses module.exports Objekt dem Aufrufer bereitgestellt, wenn diese Datei importiert wird.

Sehen wir uns die app.js Datei im Detail an. Zuerst importieren wir einige nützliche Node-Bibliotheken in die Datei mit require(), einschließlich http-errors, express, morgan und cookie-parser, die wir zuvor für unsere Anwendung mit npm heruntergeladen haben; und path, eine Core Node Bibliothek zum Parsen von Datei- und Verzeichnispfaden.

const createError = require("http-errors");
const express = require("express");
const path = require("path");
const cookieParser = require("cookie-parser");
const logger = require("morgan");

Dann require() wir Module aus unserem Routenverzeichnis. Diese Module/Dateien enthalten Code für die Verarbeitung bestimmter Sätze verwandter "Routen" (URL-Pathways). Wenn wir die Skelett-Anwendung erweitern, zum Beispiel um alle Bücher in der Bibliothek aufzulisten, werden wir eine neue Datei hinzufügen, die sich mit buchbezogenen Routen befasst.

const indexRouter = require("./routes/index");
const usersRouter = require("./routes/users");

Als nächstes erstellen wir das app Objekt mit unserem importierten express Modul und verwenden es dann, um die View (Vorlagen-) Engine einzurichten. Es gibt zwei Teile zur Einrichtung der Engine. Erstens setzen wir den Wert "views", um den Ordner anzugeben, in dem die Vorlagen gespeichert werden (in diesem Fall der Unterordner /views). Dann setzen wir den Wert "view engine", um die Template-Bibliothek anzugeben (in diesem Fall "pug").

const app = express();

// view engine setup
app.set("views", path.join(__dirname, "views"));
app.set("view engine", "pug");

Der nächste Satz von Funktionen ruft app.use() auf, um die oben importierten Middleware-Bibliotheken in die Anfrageverarbeitungskette hinzuzufügen. Zum Beispiel, express.json() und express.urlencoded() sind notwendig, um req.body mit den Formularfeldern zu befüllen. Nach diesen Bibliotheken verwenden wir auch die express.static Middleware, die Express alle statischen Dateien im /public Verzeichnis im Projektstammverzeichnis bereitstellt.

app.use(logger("dev"));
app.use(express.json());
app.use(express.urlencoded({ extended: false }));
app.use(cookieParser());

app.use(express.static(path.join(__dirname, "public")));

Nachdem alle anderen Middleware eingerichtet sind, fügen wir unseren (zuvor importierten) Routencode der Anfrageverarbeitungskette hinzu. Der importierte Code wird bestimmte Routen für die verschiedenen Teile der Website definieren:

app.use("/", indexRouter);
app.use("/users", usersRouter);

Die letzte Middleware in der Datei fügt Handler-Methoden für Fehler und HTTP 404-Antworten hinzu.

// catch 404 and forward to error handler
app.use((req, res, next) => {
  next(createError(404));
});

// error handler
app.use((err, req, res, next) => {
  // set locals, only providing error in development
  res.locals.message = err.message;
  res.locals.error = req.app.get("env") === "development" ? err : {};

  // render the error page
  res.status(err.status || 500);
  res.render("error");
});

Das Express-Anwendungsobjekt (app) ist jetzt vollständig konfiguriert. Der letzte Schritt besteht darin, es zu den Modulexporten hinzuzufügen (dies ist, was es ermöglicht, es von /bin/www zu importieren).

module.exports = app;

Die Routendatei /routes/users.js ist unten angezeigt (Routendateien haben eine ähnliche Struktur, deshalb müssen wir index.js nicht auch zeigen). Erstens, läd es das express Modul und verwendet es, um ein express.Router Objekt zu erhalten. Dann spezifiziert es eine Route auf diesem Objekt und schließlich exportiert es den Router aus dem Modul (dies ist, was es ermöglicht, die Datei in app.js zu importieren).

const express = require("express");
const router = express.Router();

/* GET users listing. */
router.get("/", (req, res, next) => {
  res.send("respond with a resource");
});

module.exports = router;

Die Route definiert einen Callback, der immer dann aufgerufen wird, wenn eine HTTP GET Anforderung mit dem richtigen Muster erkannt wird. Das passende Muster ist die beim Importieren des Moduls angegebene Route ("/users") plus das, was in dieser Datei definiert ist ("/"). Mit anderen Worten, diese Route wird verwendet, wenn eine URL von /users/ empfangen wird.

Eine interessante Sache oben ist, dass die Callback-Funktion das dritte Argument next hat und somit eine Middleware-Funktion anstelle eines einfachen Routencallbacks ist. Obwohl der Code das next-Argument derzeit nicht verwendet, könnte es in Zukunft nützlich sein, wenn Sie mehrere Routenhandler für den '/' Routenpfad hinzufügen möchten.

Die Ansichten (Vorlagen) sind im Verzeichnis /views gespeichert (wie in app.js angegeben) und haben die Dateiendung .pug. Die Methode Response.render() wird verwendet, um eine angegebene Vorlage zusammen mit den Werten der benannten Variablen, die in einem Objekt übergeben werden, zu rendern und dann das Ergebnis als Antwort zu senden. Im folgenden Code aus /routes/index.js können Sie sehen, wie diese Route eine Antwort mit der Vorlage "index" rendert und die Template-Variable "title" übergibt.

/* GET home page. */
router.get("/", (req, res, next) => {
  res.render("index", { title: "Express" });
});

Die entsprechende Vorlage für die obige Route ist unten angegeben (index.pug). Wir werden später mehr über die Syntax sprechen. Alles, was Sie jetzt wissen müssen, ist, dass die title-Variable (mit dem Wert 'Express') an den angegebenen Stellen in die Vorlage eingefügt wird.

extends layout

block content
  h1= title
  p Welcome to #{title}

Erstellen Sie eine neue Route in /routes/users.js, die den Text "You're so cool" bei der URL /users/cool/ anzeigt. Testen Sie es, indem Sie den Server ausführen und http://localhost:3000/users/cool/ in Ihrem Browser besuchen.

Sie haben nun ein Skelett-Website-Projekt für die Local Library erstellt und überprüft, dass es mit node läuft. Am wichtigsten ist jedoch, dass Sie auch verstehen, wie das Projekt strukturiert ist, sodass Sie eine gute Vorstellung davon haben, wo wir Änderungen vornehmen müssen, um Routen und Ansichten für unsere lokale Bibliothek hinzuzufügen.

Als Nächstes beginnen wir mit der Anpassung des Skeletts, sodass es als Bibliotheks-Website funktioniert.

• Express application generator (Express-Dokumentation)
• Verwenden von Template Engines mit Express (Express-Dokumentation)

• Zurück
• Übersicht: Express-Webframework (Node.js/JavaScript)
• Weiter