Express-Tutorial Teil 2: Erstellung einer Skelett-Website

Überblick

Dieser Artikel zeigt, wie man mit dem Express Application Generator Tool eine "Skelett"-Website erstellen kann, die dann mit sitespezifischen Routen, Ansichten/Templates und Datenbankaufrufen gefüllt werden kann. In diesem Fall verwenden wir das Tool, um das Framework für unsere Local Library Website zu erstellen, zu dem wir später den gesamten anderen 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 und optional auch die Template-Engine und den CSS-Generator der Website angeben.

Die folgenden Abschnitte zeigen, wie Sie den Applikationsgenerator aufrufen und bieten eine kleine Erklärung zu den verschiedenen Ansichts/CSS-Optionen. Wir erklären auch, 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.

Verwendung des Applikationsgenerators

Sie sollten den Generator bereits als Teil der Einrichtung einer Node-Entwicklungsumgebung installiert haben. Zur schnellen Erinnerung, Sie installieren das Generator-Tool site-wide mit dem npm-Paketmanager, wie hier dargestellt:

npm install express-generator -g

Der Generator hat eine Reihe von Optionen, die Sie in der Befehlszeile mit dem --help (oder -h) Befehl anzeigen 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 angeben, dass Express ein Projekt im gegenwärtigen Verzeichnis mit der Jade Ansichtsengine und plain CSS erstellen soll (wenn Sie einen Verzeichnisnamen angeben, wird das Projekt in einem Unterordner mit diesem Namen erstellt).

express

Sie können auch eine Ansicht (Template) Engine mit --view und/oder eine CSS-Genengine mit --css auswählen.

Welche Ansichtsengine sollte ich verwenden?

Der Express Application Generator ermöglicht es Ihnen, eine Reihe von beliebten Ansichts-/Template-Engines zu konfigurieren, darunter EJS, Hbs, Pug (Jade), Twig und Vash, obwohl standardmäßig Jade ausgewählt wird, wenn Sie keine Ansicht-Option angeben. Express selbst kann auch eine große Anzahl anderer Template-Sprachen out of the box unterstützen.

Generell sollten Sie eine Template-Engine auswählen, die alle benötigten Funktionen bietet und es Ihnen ermöglicht, schneller produktiv zu werden – oder mit anderen Worten, genauso wie Sie jede andere Komponente auswählen! Einige Überlegungen bei der Auswahl von Templates:

• Zeit bis zur Produktivität — Wenn Ihr Team bereits Erfahrung mit einer Template-Sprache hat, werden sie wahrscheinlich schneller produktiver in dieser Sprache. Wenn nicht, sollten Sie die relative Lernkurve für die verschiedenen Template-Engines in Betracht ziehen.
• 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 spezielle Markup, um eingefügte Inhalte innerhalb von "normalem" HTML anzuzeigen, während andere das HTML mit einer anderen Syntax konstruieren (zum Beispiel durch Einrückungen und Blocknamen).
• Leistung/Renderzeit.
• Funktionen — Sie sollten prüfen, ob die Engines, die Sie betrachten, die folgenden Funktionen haben:
  • Layout-Vererbung: Erlaubt Ihnen, ein Template als Basis zu definieren und dann nur die Teile davon zu "erben", die Sie für eine bestimmte Seite anders haben möchten. Dies ist typischerweise ein besserer Ansatz als Templates mit einer Reihe von benötigten Komponenten zu erstellen oder jedes Mal ein Template von Grund auf neu zu erstellen.
  • "Include"-Unterstützung: Erlaubt es Ihnen, Templates durch Einfügen anderer Templates aufzubauen.
  • Prägnante Variable- und Schleifensteuersyntax.
  • Fähigkeit, Variablewerte auf Template-Ebene zu filtern, z.B. Variablen in Großbuchstaben umzuwandeln oder ein Datumsformatierung vorzunehmen.
  • Möglichkeit, andere als HTML-Ausgabeformate wie JSON oder XML zu generieren.
  • Unterstützung für asynchrone Operationen und Streaming.
  • Client-seitige Funktionen. Wenn eine Template-Engine auf dem Client verwendet werden kann, besteht die Möglichkeit, dass die gesamte oder ein Großteil der Renderings clientseitig erfolgt.

Für dieses Projekt werden wir die Pug Template-Engine verwenden (früher "Jade" genannt), da dies eine der beliebtesten Express/JavaScript Template-Sprachen ist und vom Generator nativ unterstützt wird.

Welche CSS-Stileengine sollte ich verwenden?

Der Express Application Generator ermöglicht es Ihnen, ein Projekt zu erstellen, das für die Verwendung der beliebtesten CSS-Stileengines konfiguriert ist: LESS, SASS, Stylus.

Wie bei Template-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 den Einsatz von etwas anderem zu rechtfertigen.

Welche Datenbank sollte ich verwenden?

Der generierte Code verwendet/beinhaltet keine Datenbanken. Express-Apps können jeden Datenbankmechanismus nutzen, der von Node unterstützt wird (Express selbst definiert keine zusätzlichen Verhaltensweisen/Anforderungen für das Datenbankmanagement).

Wir werden in einem späteren Artikel besprechen, wie man eine Datenbank integriert.

Erstellen des Projekts

Für die Beispielanwendung Local Library, die wir erstellen werden, erstellen wir ein Projekt mit dem Namen express-locallibrary-tutorial, das die Pug Template-Bibliothek und keine CSS-Engine verwendet.

Navigieren Sie zuerst zu dem Ort, an dem Sie das Projekt erstellen möchten, und führen Sie dann den Express Application Generator in der Eingabeaufforderung aus, wie folgt:

express express-locallibrary-tutorial --view=pug

Der Generator wird die Dateien des Projekts erstellen (und auflisten).

   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 liefert der Generator Anweisungen, wie die Abhängigkeiten (wie in der package.json Datei angegeben) installiert werden und wie die Anwendung auf verschiedenen Betriebssystemen ausgeführt wird.

Ausführen der Skelett-Website

Zu diesem Zeitpunkt haben wir ein vollständiges Skelettprojekt. Die Website tut eigentlich noch nicht sehr viel, aber es ist es wert, sie auszuführen, um zu zeigen, dass sie funktioniert.

1. Installieren Sie zunächst die Abhängigkeiten (der install Befehl lädt alle in der package.json des Projekts aufgeführten Abhängigkeitspakete).

   bash

   cd express-locallibrary-tutorial
   npm install
   

2. Führen Sie dann die Anwendung aus.

   • Verwenden Sie im Windows CMD-Prompt diesen Befehl:

     batch

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

   • Verwenden Sie in Windows PowerShell diesen Befehl:

     powershell

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

     Hinweis: PowerShell-Befehle werden in diesem Tutorial nicht behandelt (die bereitgestellten "Windows" Befehle gehen davon aus, dass Sie den Windows CMD-Prompt verwenden).

   • In 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 Browserseite sehen, die so aussieht:

Herzlichen Glückwunsch! Sie haben jetzt eine funktionierende Express-Anwendung, die über Port 3000 erreichbar 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

Automatisches Serverneustart bei Dateiänderungen aktivieren

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

Ein praktisches Tool hierfür ist nodemon. Normalerweise wird es global installiert (da es ein "Tool" ist), aber hier werden wir es lokal als Entwicklerabhängigkeit installieren und verwenden, so dass alle Entwickler, die mit dem Projekt arbeiten, es automatisch installieren, wenn sie die Anwendung installieren. Verwenden Sie den folgenden Befehl im Root-Verzeichnis des Skelettprojekts:

npm install --save-dev nodemon

Wenn Sie sich entscheiden, nodemon global auf Ihrem Computer installieren möchten 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.10"
  }
}

Da das Tool nicht global installiert ist, können wir es nicht von der Kommandozeile aus starten (es sei denn, wir fügen es dem Pfad hinzu). Wir können es jedoch von einem npm-Skript aus aufrufen, da npm weiß, welche Pakete installiert sind. Finden Sie den scripts Abschnitt Ihrer package.json. Zunächst wird es eine Zeile enthalten, die mit "start" beginnt. Aktualisieren Sie ihn, indem Sie ein Komma am Ende dieser Zeile setzen und die Zeilen "devstart" und "serverstart" hinzufügen:

• Unter Linux und macOS sieht der Skriptenabschnitt so aus:

  json

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

• Unter Windows würde der Wert von "serverstart" stattdessen wie folgt aussehen (bei Verwendung der Eingabeaufforderung):

  bash

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

Wir können jetzt den Server fast genau so starten wie zuvor, aber unter Verwendung des devstart Befehls.

Das generierte Projekt

Werfen wir einen Blick auf das Projekt, das wir gerade erstellt haben. Wir werden im Laufe der Zeit einige kleine Änderungen daran vornehmen.

Verzeichnisstruktur

Das generierte Projekt hat, nachdem Sie die Abhängigkeiten installiert haben, die folgende Dateistruktur (Dateien sind die Elemente, die nicht mit "/" beginnen). Die package.json Datei definiert die Anwendungsabhängigkeiten und andere Informationen. Es definiert auch ein Startskript, das den Anwendungseinstiegspunkt aufruft, die JavaScript-Datei /bin/www. Diese führt einige der Anwendung Fehlerbehandlungen durch und lädt dann app.js, um den Rest der Arbeit zu erledigen. Die Benutzerdefinierte Routen werden in separaten Modulen im Verzeichnis routes/ gespeichert. Die Templates werden 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 detaillierter.

package.json

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.10"
  }
}

Der Skriptenabschnitt definiert zuerst ein "start" Skript, das ist das, was 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 sehen, dass dies tatsächlich die JavaScript-Datei ./bin/www mit node startet.

Wir haben diesen Abschnitt bereits in Automatisches Serverneustart bei Dateiänderungen aktivieren geändert, indem wir die devstart und serverstart Skripte hinzugefügt haben. Diese können verwendet werden, um dieselbe ./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 enthalten das express Paket und das Paket für unsere ausgewählte View-Engine (pug). Darüber hinaus haben wir folgende Pakete, die in vielen Webanwendungen nützlich sind:

• cookie-parser: Wird verwendet, um den Cookie-Header zu analysieren und req.cookies zu füllen (bietet im Wesentlichen eine bequeme Methode zum Zugriff auf Cookie-Informationen).
• debug: Ein kleines Node-Debugging-Utility, das nach node core's Debugging-Technik modelliert ist.
• morgan: Ein HTTP-Anfrage-Logger-Middleware für node.
• http-errors: Erstellen Sie bei Bedarf HTTP-Fehler (für Express Fehlerbehandlung).

Die Standardversionen im generierten Projekt sind etwas 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.7",
    "debug": "^4.4.1",
    "express": "^5.1.0",
    "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

www Datei

Die Datei /bin/www ist der Einstiegspunkt der Anwendung! Das allererste, was sie tut, ist das require() der echten Anwendungseinstiegspunktdatei (app.js, im Projektstamm), die das express() Anwendungsobjekt einrichtet und zurückgibt. require() ist der CommonJS-Weg, um JavaScript-Code, JSON und andere Dateien in die aktuelle Datei zu importieren. Hier geben wir das app.js Modul unter Verwendung eines relativen Pfades an und lassen die optionale (.js) Dateierweiterung weg.

#!/usr/bin/env node

/**
 * Module dependencies.
 */

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

Der Rest des Codes in dieser Datei richtet einen Node HTTP-Server ein, wobei app auf einen bestimmten Port gesetzt ist (definiert durch eine Umgebungsvariable oder 3000, wenn die Variable nicht definiert ist), und beginnt mit dem Abhören und Melden von Serverfehlern und Verbindungen. Für jetzt müssen Sie nicht wirklich mehr über den Code wissen (alles in dieser Datei ist "Boilerplate"), aber fühlen Sie sich frei, ihn zu überprüfen, wenn Sie interessiert sind.

app.js

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

const express = require("express");

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

Zurück in der www Einstiegspunktdatei oben, ist es dieses module.exports Objekt, das dem Anrufer bereitgestellt wird, wenn diese Datei importiert wird.

Lassen Sie uns die app.js Datei im Detail durchgehen. Zuerst importieren wir einige nützliche Node-Bibliotheken in die Datei unter Verwendung von require(), einschließlich http-errors, express, morgan und cookie-parser, die wir zuvor für unsere Anwendung mit npm heruntergeladen haben, und path, was eine Kernbibliothek von Node zum Parsen von Datei- und Verzeichnispfaden ist.

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 zur Behandlung bestimmter Sets verwandter "Routen" (URL-Pfade). Wenn wir die Skelettanwendung erweitern, um beispielsweise alle Bücher in der Bibliothek aufzulisten, fügen wir eine neue Datei hinzu, 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 Ansichtsengine einzurichten. Es gibt zwei Teile zum Einrichten der Engine. Zuerst setzen wir den "views" Wert, um den Ordner zu spezifizieren, in dem die Templates gespeichert werden (in diesem Fall der Unterordner /views). Dann setzen wir den "view engine" Wert, 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 Anfragenverarbeitungskette einzufügen. Zum Beispiel sind express.json() und express.urlencoded() notwendig, um req.body mit den Formfeldern zu bevölkern. Nach diesen Bibliotheken verwenden wir auch die express.static Middleware, die Express veranlasst, alle statischen Dateien im /public Verzeichnis im Projektstamm zu bedienen.

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) Routenbehandlungscode der Anfragenverarbeitungskette hinzu. Der importierte Code definiert bestimmte Routen für die verschiedenen Teile der Site:

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 ermöglicht es, dass es durch /bin/www importiert wird).

module.exports = app;

Routen

Die Routen-Datei /routes/users.js wird unten gezeigt (Routendateien haben eine ähnliche Struktur, daher müssen wir index.js nicht auch zeigen). Zuerst lädt es das express Modul und verwendet es, um ein express.Router Objekt zu erhalten. Dann gibt es eine Route auf diesem Objekt an und exportiert zuletzt den Router aus dem Modul (dies ermöglicht das Importieren der Datei in app.js).

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 Rückruf, der aufgerufen wird, wann immer eine HTTP GET Anfrage mit dem richtigen Muster erkannt wird. Das übereinstimmende Muster ist die Route, die beim Importieren des Moduls angegeben wurde ("/users") sowie das, was in dieser Datei definiert wurde ("/"). Mit anderen Worten, diese Route wird verwendet, wenn eine URL von /users/ eingegangen wird.

Eine Sache, die oben von Interesse ist, ist, dass die Rückruffunktion das dritte Argument next hat und daher eine Middleware-Funktion anstelle eines einfachen Routen-Rückrufs ist. Während der Code derzeit das next-Argument nicht verwendet, könnte es in der Zukunft nützlich sein, wenn Sie mehrere Routenhandler zur '/'-Routenpfad hinzufügen möchten.

Ansichten (Templates)

Die Ansichten (Templates) werden im /views Verzeichnis (wie in app.js angegeben) gespeichert und haben die Dateierweiterung .pug. Die Methode Response.render() wird verwendet, um ein angegebenes Template zusammen mit den Werten der in einem Objekt übergebenen benannten Variablen zu rendern und das Ergebnis dann als Antwort zu senden. Im folgenden Code von /routes/index.js können Sie sehen, wie diese Route eine Antwort unter Verwendung des Templates "index" darstellt, wobei die Templatevariable "title" übergeben wird.

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

Das entsprechende Template für die obige Route wird 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') dort eingefügt wird, wo es im Template angegeben ist.

extends layout

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

Fordern Sie sich selbst heraus

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 aufrufen.

Zusammenfassung

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, 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 werden wir beginnen, das Skelett so zu ändern, dass es als Bibliothekswebsite funktioniert.

Siehe auch

• Express Anwendungsgenerator (Express-Dokumentation)
• Verwenden von Template-Engines mit Express (Express-Dokumentation)

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