ExpressJS - Kurzanleitung

ExpressJS ist ein Webanwendungsframework, das Ihnen eine einfache API zum Erstellen von Websites, Webanwendungen und Backends bietet. Mit ExpressJS müssen Sie sich keine Gedanken über Protokolle, Prozesse usw. auf niedriger Ebene machen.

Was ist Express?

Express bietet eine minimale Schnittstelle zum Erstellen unserer Anwendungen. Es bietet uns die Tools, die zum Erstellen unserer App erforderlich sind. Es ist flexibel, da zahlreiche Module verfügbar sindnpm, die direkt an Express angeschlossen werden kann.

Express wurde von entwickelt TJ Holowaychukund wird von der Node.js- Stiftung und zahlreichen Open-Source-Mitwirkenden gepflegt .

Warum Express?

Im Gegensatz zu seinen Konkurrenten wie Rails und Django, die eine eigenwillige Methode zum Erstellen von Anwendungen haben, hat Express keine "beste Möglichkeit", etwas zu tun. Es ist sehr flexibel und steckbar.

Mops

Pug (früher bekannt als Jade) ist eine knappe Sprache zum Schreiben von HTML-Vorlagen. Es -

  • Erzeugt HTML
  • Unterstützt dynamischen Code

  • Unterstützt die Wiederverwendbarkeit (DRY)

Es ist eine der beliebtesten Vorlagensprachen, die mit Express verwendet werden.

MongoDB und Mongoose

MongoDB ist eine Open-Source-Dokumentendatenbank, die sich durch einfache Entwicklung und Skalierung auszeichnet. Diese Datenbank wird auch zum Speichern von Daten verwendet.

Mongoose ist eine Client-API für node.js Dies erleichtert den Zugriff auf unsere Datenbank über unsere Express-Anwendung.

In diesem Kapitel erfahren Sie, wie Sie mit der Entwicklung und Verwendung des Express Framework beginnen. Zunächst sollten Sie den Knoten und den npm (Node Package Manager) installiert haben. Wenn Sie diese noch nicht haben, gehen Sie zum Knoten-Setup , um den Knoten auf Ihrem lokalen System zu installieren. Stellen Sie sicher, dass Node und npm installiert sind, indem Sie die folgenden Befehle in Ihrem Terminal ausführen.

node --version
npm --version

Sie sollten eine Ausgabe ähnlich der folgenden erhalten.

v5.0.0
3.5.2

Jetzt haben wir Node und npm einrichten, lassen Sie uns verstehen, was npm ist und wie man es benutzt.

Node Package Manager (npm)

npm ist der Paketmanager für den Knoten. Die npm-Registrierung ist eine öffentliche Sammlung von Open-Source-Code-Paketen für Node.js, Front-End-Web-Apps, mobile Apps, Roboter, Router und unzählige andere Anforderungen der JavaScript-Community. Mit npm können wir auf alle diese Pakete zugreifen und sie lokal installieren. Sie können die Liste der auf npm verfügbaren Pakete unter npmJS durchsuchen .

Wie benutzt man npm?

Es gibt zwei Möglichkeiten, ein Paket mit npm zu installieren: global und lokal.

  • Globally- Diese Methode wird im Allgemeinen zum Installieren von Entwicklungstools und CLI-basierten Paketen verwendet. Verwenden Sie den folgenden Code, um ein Paket global zu installieren.

npm install -g <package-name>

  • Locally- Diese Methode wird im Allgemeinen zum Installieren von Frameworks und Bibliotheken verwendet. Ein lokal installiertes Paket kann nur in dem Verzeichnis verwendet werden, in dem es installiert ist. Verwenden Sie zum lokalen Installieren eines Pakets denselben Befehl wie oben ohne-g Flagge.

npm install <package-name>

Wann immer wir ein Projekt mit npm erstellen, müssen wir a bereitstellen package.jsonDatei, die alle Details zu unserem Projekt enthält. npm erleichtert uns das Einrichten dieser Datei. Lassen Sie uns unser Entwicklungsprojekt einrichten.

Step 1 - Starten Sie Ihr Terminal / cmd, erstellen Sie einen neuen Ordner mit dem Namen hallo-world und cd (Verzeichnis erstellen) darin -

Step 2 - Verwenden Sie nun den folgenden Code, um die Datei package.json mit npm zu erstellen.

npm init

Sie werden nach folgenden Informationen gefragt.

Drücken Sie einfach die Eingabetaste und geben Sie Ihren Namen in das Feld "Autorenname" ein.

Step 3- Nachdem wir unsere Datei package.json eingerichtet haben, werden wir Express weiter installieren. Verwenden Sie den folgenden Befehl, um Express zu installieren und zu unserer Datei package.json hinzuzufügen:

npm install --save express

Führen Sie den folgenden Code aus, um zu bestätigen, dass Express korrekt installiert wurde.

ls node_modules #(dir node_modules for windows)

Tip - Die -save Flag kann durch das ersetzt werden -SFlagge. Dieses Flag stellt sicher, dass Express als Abhängigkeit zu unserem hinzugefügt wirdpackage.jsonDatei. Dies hat den Vorteil, dass wir beim nächsten Installieren aller Abhängigkeiten unseres Projekts einfach den Befehl npm install ausführen können. Die Abhängigkeiten werden in dieser Datei gefunden und für uns installiert.

Dies ist alles, was wir brauchen, um mit der Entwicklung mit dem Express-Framework zu beginnen. Um unseren Entwicklungsprozess erheblich zu vereinfachen, werden wir ein Tool von npm, nodemon, installieren. Dieses Tool startet unseren Server neu, sobald wir Änderungen an einer unserer Dateien vornehmen. Andernfalls müssen wir den Server nach jeder Dateiänderung manuell neu starten. Verwenden Sie den folgenden Befehl, um nodemon zu installieren:

npm install -g nodemon

Sie können jetzt mit der Arbeit an Express beginnen.

Wir haben die Entwicklung eingerichtet, jetzt ist es Zeit, mit der Entwicklung unserer ersten App mit Express zu beginnen. Erstellen Sie eine neue Datei mit dem Namenindex.js und geben Sie Folgendes ein.

var express = require('express');
var app = express();

app.get('/', function(req, res){
   res.send("Hello world!");
});

app.listen(3000);

Speichern Sie die Datei, gehen Sie zu Ihrem Terminal und geben Sie Folgendes ein.

nodemon index.js

Dadurch wird der Server gestartet. Um diese App zu testen, öffnen Sie Ihren Browser und gehen Sie zuhttp://localhost:3000 und eine Meldung wird wie im folgenden Screenshot angezeigt.

Wie funktioniert die App?

Die erste Zeile importiert Express in unsere Datei, wir haben Zugriff über die Variable Express. Wir verwenden es, um eine Anwendung zu erstellen und sie der var-App zuzuweisen.

app.get (Route, Rückruf)

Diese Funktion gibt an, was zu tun ist, wenn a getAnfrage an der angegebenen Route wird aufgerufen. Die Rückruffunktion hat 2 Parameter,request(req) und response(res). Die Anfrageobject(req) stellt die HTTP-Anforderung dar und verfügt über Eigenschaften für die Anforderungsabfragezeichenfolge, Parameter, Text, HTTP-Header usw. In ähnlicher Weise stellt das Antwortobjekt die HTTP-Antwort dar, die die Express-App sendet, wenn sie eine HTTP-Anforderung empfängt.

res.send ()

Diese Funktion nimmt ein Objekt als Eingabe und sendet es an den anfordernden Client. Hier senden wir den String "Hello World!" .

app.listen (Port, [Host], [Backlog], [Rückruf]])

Diese Funktion bindet und wartet auf Verbindungen auf dem angegebenen Host und Port. Port ist hier der einzige erforderliche Parameter.

S.No. Argument & Beschreibung
1

port

Eine Portnummer, an der der Server eingehende Anforderungen annehmen soll.
2

host

Name der Domain. Sie müssen es festlegen, wenn Sie Ihre Apps in der Cloud bereitstellen.
3

backlog

Die maximale Anzahl anstehender Verbindungen in der Warteschlange. Der Standardwert ist 511.
4

callback

Eine asynchrone Funktion, die aufgerufen wird, wenn der Server auf Anforderungen wartet.

Web-Frameworks bieten Ressourcen wie HTML-Seiten, Skripte, Bilder usw. auf verschiedenen Routen.

Die folgende Funktion wird verwendet, um Routen in einer Express-Anwendung zu definieren:

app.method (Pfad, Handler)

Diese METHODE kann auf jedes der HTTP-Verben angewendet werden - get, set, put, delete. Es gibt auch eine alternative Methode, die unabhängig vom Anforderungstyp ausgeführt wird.

Pfad ist die Route, auf der die Anforderung ausgeführt wird.

Der Handler ist eine Rückruffunktion, die ausgeführt wird, wenn auf der entsprechenden Route ein übereinstimmender Anforderungstyp gefunden wird. Zum Beispiel,

var express = require('express');
var app = express();

app.get('/hello', function(req, res){
   res.send("Hello World!");
});

app.listen(3000);

Wenn wir unsere Anwendung ausführen und zu gehen localhost:3000/helloerhält der Server auf der Route eine Get-Anfrage "/hello"führt unsere Express-App die aus callback Funktion an diese Route angehängt und sendet "Hello World!" als Antwort.

Wir können auch mehrere verschiedene Methoden auf derselben Route haben. Zum Beispiel,

var express = require('express');
var app = express();

app.get('/hello', function(req, res){
   res.send("Hello World!");
});

app.post('/hello', function(req, res){
   res.send("You just called the post method at '/hello'!\n");
});

app.listen(3000);

Um diese Anforderung zu testen, öffnen Sie Ihr Terminal und führen Sie mit cURL die folgende Anforderung aus:

curl -X POST "http://localhost:3000/hello"

Eine besondere Methode, allwird von Express bereitgestellt, um alle Arten von http-Methoden auf einer bestimmten Route mit derselben Funktion zu verarbeiten. Versuchen Sie Folgendes, um diese Methode zu verwenden.

app.all('/test', function(req, res){
   res.send("HTTP method doesn't have any effect on this route!");
});

Diese Methode wird im Allgemeinen zum Definieren von Middleware verwendet, die im Kapitel Middleware erläutert wird.

Router

Das Definieren von Routen wie oben ist sehr mühsam. Um die Routen von unserer Hauptstrecke zu trennenindex.js Datei werden wir verwenden Express.Router. Erstellen Sie eine neue Datei mit dem Namenthings.js und geben Sie Folgendes ein.

var express = require('express');
var router = express.Router();

router.get('/', function(req, res){
   res.send('GET route on things.');
});
router.post('/', function(req, res){
   res.send('POST route on things.');
});

//export this router to use in our index.js
module.exports = router;

Verwenden Sie nun diesen Router in unserem index.jsGeben Sie vor dem Folgendes ein app.listen Funktionsaufruf.

var express = require('Express');
var app = express();

var things = require('./things.js');

//both index.js and things.js should be in same directory
app.use('/things', things);

app.listen(3000);

Das app.use Funktionsaufruf auf Route '/things' bringt die thingsRouter mit dieser Route. Jetzt werden alle Anfragen, die unsere App an das '/ things' erhält, von unserem Router things.js bearbeitet. Das'/'route in things.js ist eigentlich eine Subroute von '/ things'. Besuchen Sie localhost: 3000 / things / und Sie sehen die folgende Ausgabe.

Router sind sehr hilfreich bei der Trennung von Bedenken und halten relevante Teile unseres Codes zusammen. Sie helfen beim Erstellen von wartbarem Code. Sie sollten Ihre Routen, die sich auf eine Entität beziehen, in einer einzelnen Datei definieren und diese mit der oben beschriebenen Methode in Ihre Datei aufnehmenindex.js Datei.

Die HTTP-Methode wird in der Anforderung angegeben und gibt die vom Client angeforderte Operation an. In der folgenden Tabelle sind die am häufigsten verwendeten HTTP-Methoden aufgeführt.

S.No. Methode & Beschreibung
1

GET

Die GET-Methode fordert eine Darstellung der angegebenen Ressource an. Anforderungen, die GET verwenden, sollten nur Daten abrufen und keine anderen Auswirkungen haben.
2

POST

Die POST-Methode fordert den Server auf, die in der Anforderung enthaltenen Daten als neues Objekt / neue Entität der durch den URI identifizierten Ressource zu akzeptieren.
3

PUT

Die PUT-Methode fordert den Server auf, die in der Anforderung enthaltenen Daten als Änderung des durch den URI identifizierten vorhandenen Objekts zu akzeptieren. Wenn es nicht existiert, sollte die PUT-Methode eine erstellen.
4

DELETE

Die DELETE-Methode fordert den Server auf, die angegebene Ressource zu löschen.

Dies sind die gängigsten HTTP-Methoden. Um mehr über die Methoden zu erfahren, besuchen Siehttp://www.tutorialspoint.com/http/http_methods.htm.

Wir können jetzt Routen definieren, aber diese sind statisch oder fest. Um die dynamischen Routen zu verwenden, sollten wir verschiedene Arten von Routen bereitstellen. Durch die Verwendung dynamischer Routen können wir Parameter übergeben und basierend darauf verarbeiten.

Hier ist ein Beispiel für eine dynamische Route -

var express = require('express');
var app = express();

app.get('/:id', function(req, res){
   res.send('The id you specified is ' + req.params.id);
});
app.listen(3000);

Um dies zu testen, gehen Sie zu http://localhost:3000/123. Die folgende Antwort wird angezeigt.

Sie können '123' in der URL durch etwas anderes ersetzen, und die Änderung wird in der Antwort berücksichtigt. Ein komplexeres Beispiel dafür ist -

var express = require('express');
var app = express();

app.get('/things/:name/:id', function(req, res) {
   res.send('id: ' + req.params.id + ' and name: ' + req.params.name);
});
app.listen(3000);

Um den obigen Code zu testen, gehen Sie zu http://localhost:3000/things/tutorialspoint/12345.

Du kannst den ... benutzen req.paramsObjekt, um auf alle Parameter zuzugreifen, die Sie in der URL übergeben. Beachten Sie, dass die obigen 2 unterschiedliche Pfade sind. Sie werden sich niemals überlappen. Auch wenn Sie Code ausführen möchten, wenn Sie erhalten'/things' dann müssen Sie es separat definieren.

Musterangepasste Routen

Sie können auch verwenden regexum den URL-Parameterabgleich einzuschränken. Nehmen wir an, Sie brauchen dasideine 5-stellige lange Zahl sein. Sie können die folgende Routendefinition verwenden:

var express = require('express');
var app = express();

app.get('/things/:id([0-9]{5})', function(req, res){
   res.send('id: ' + req.params.id);
});

app.listen(3000);

Beachten Sie, dass dies wird only stimmen mit den Anforderungen überein, die eine 5-stellige Länge haben id. Sie können komplexere reguläre Ausdrücke verwenden, um Ihre Routen abzugleichen / zu validieren. Wenn keine Ihrer Routen mit der Anfrage übereinstimmt, erhalten Sie eine"Cannot GET <your-request-route>"Nachricht als Antwort. Diese Nachricht wird durch eine 404 nicht gefundene Seite ersetzt, die diese einfache Route verwendet -

var express = require('express');
var app = express();

//Other routes here
app.get('*', function(req, res){
   res.send('Sorry, this is an invalid URL.');
});
app.listen(3000);

Important - Dies sollte nach all Ihren Routen platziert werden, da Express die Routen vom Anfang bis zum Ende des index.js Datei, einschließlich der von Ihnen benötigten externen Router.

Wenn wir beispielsweise dieselben Routen wie oben definieren, wird beim Anfordern mit einer gültigen URL die folgende Ausgabe angezeigt. - -

Bei einer falschen URL-Anfrage wird die folgende Ausgabe angezeigt.

Middleware-Funktionen sind Funktionen, die Zugriff auf die haben request object (req), das response object (res)und die nächste Middleware-Funktion im Anforderungs- / Antwortzyklus der Anwendung. Diese Funktionen werden zum Ändern verwendetreq und res Objekte für Aufgaben wie das Parsen von Anforderungskörpern, das Hinzufügen von Antwortheadern usw.

Hier ist ein einfaches Beispiel für eine Middleware-Funktion in Aktion -

var express = require('express');
var app = express();

//Simple request time logger
app.use(function(req, res, next){
   console.log("A new request received at " + Date.now());
   
   //This function call is very important. It tells that more processing is
   //required for the current request and is in the next middleware
   function/route handler.
   next();
});

app.listen(3000);

Die oben genannte Middleware wird für jede Anforderung auf dem Server aufgerufen. Nach jeder Anfrage erhalten wir die folgende Meldung in der Konsole:

A new request received at 1467267512545

Geben Sie diese Route als erstes Argument von an, um sie auf eine bestimmte Route (und alle ihre Unterrouten) zu beschränken app.use(). Zum Beispiel,

var express = require('express');
var app = express();

//Middleware function to log request protocol
app.use('/things', function(req, res, next){
   console.log("A request for things received at " + Date.now());
   next();
});

// Route handler that sends the response
app.get('/things', function(req, res){
   res.send('Things');
});

app.listen(3000);

Wenn Sie jetzt eine Unterroutine von '/ things' anfordern, wird nur dann die Uhrzeit protokolliert.

Reihenfolge der Middleware-Aufrufe

Eines der wichtigsten Dinge bei Middleware in Express ist die Reihenfolge, in der sie in Ihre Datei geschrieben / aufgenommen werden. Die Reihenfolge, in der sie ausgeführt werden, muss ebenfalls berücksichtigt werden, da die Route übereinstimmt.

Im folgenden Codeausschnitt wird beispielsweise zuerst die erste Funktion ausgeführt, dann der Routenhandler und dann die Endfunktion. In diesem Beispiel wird zusammengefasst, wie Middleware vor und nach dem Routenhandler verwendet wird. auch, wie ein Routen-Handler selbst als Middleware verwendet werden kann.

var express = require('express');
var app = express();

//First middleware before response is sent
app.use(function(req, res, next){
   console.log("Start");
   next();
});

//Route handler
app.get('/', function(req, res, next){
   res.send("Middle");
   next();
});

app.use('/', function(req, res){
   console.log('End');
});

app.listen(3000);

Wenn wir nach dem Ausführen dieses Codes '/' besuchen, erhalten wir die Antwort als Middle und auf unserer Konsole -

Start
End

Das folgende Diagramm fasst zusammen, was wir über Middleware gelernt haben -

Nachdem wir uns nun mit dem Erstellen unserer eigenen Middleware befasst haben, wollen wir einige der am häufigsten verwendeten von der Community erstellten Middleware diskutieren.

Middleware von Drittanbietern

Eine Liste der Middleware von Drittanbietern für Express finden Sie hier . Im Folgenden finden Sie einige der am häufigsten verwendeten Middleware. Wir werden auch lernen, wie man diese benutzt / montiert -

Body-Parser

Dies wird verwendet, um den Hauptteil von Anforderungen zu analysieren, an die Nutzdaten angehängt sind. Um den Body Parser zu mounten, müssen wir ihn mit installierennpm install --save body-parser und um es zu mounten, fügen Sie die folgenden Zeilen in Ihre index.js ein -

var bodyParser = require('body-parser');

//To parse URL encoded data
app.use(bodyParser.urlencoded({ extended: false }))

//To parse json data
app.use(bodyParser.json())

Um alle verfügbaren Optionen für Body-Parser anzuzeigen, besuchen Sie die Github-Seite.

Cookie-Parser

Es analysiert den Cookie- Header und füllt req.cookies mit einem Objekt, das durch Cookie-Namen gekennzeichnet ist. Um den Cookie-Parser zu mounten, müssen wir ihn mit npm install --save cookie-parser installieren und zum Mounten die folgenden Zeilen in Ihre index.js aufnehmen -

var cookieParser = require('cookie-parser');
app.use(cookieParser())

Express-Sitzung

Es wird eine Sitzungs-Middleware mit den angegebenen Optionen erstellt. Wir werden seine Verwendung im Abschnitt Sitzungen diskutieren.

Wir haben viele andere Middleware von Drittanbietern in ExpressJS. Wir haben hier jedoch nur einige wichtige besprochen.

Pug ist eine Template-Engine für Express. Template-Engines werden verwendet, um die Unordnung unseres Servercodes mit HTML zu beseitigen und Zeichenfolgen wild mit vorhandenen HTML-Vorlagen zu verknüpfen. Pug ist eine sehr leistungsstarke Templating-Engine mit einer Vielzahl von Funktionen, darunterfilters, includes, inheritance, interpolationusw. Es gibt viel zu tun.

Um Pug mit Express zu verwenden, müssen wir es installieren,

npm install --save pug

Nachdem Pug installiert ist, legen Sie es als Vorlagen-Engine für Ihre App fest. Siedon'tmüssen es "verlangen". Fügen Sie Ihrem Code den folgenden Code hinzuindex.js Datei.

app.set('view engine', 'pug');
app.set('views','./views');

Erstellen Sie nun ein neues Verzeichnis mit dem Namen views. Darin erstellen Sie eine Datei namensfirst_view.pugund geben Sie die folgenden Daten ein.

doctype html
html
   head
      title = "Hello Pug"
   body
      p.greetings#people Hello World!

Fügen Sie Ihrer App die folgende Route hinzu, um diese Seite auszuführen:

app.get('/first_template', function(req, res){
   res.render('first_view');
});

Sie erhalten die Ausgabe als - Hello World!Pug konvertiert dieses sehr einfach aussehende Markup in HTML. Wir müssen nicht das Schließen unserer Tags verfolgen, keine Klassen- und ID-Schlüsselwörter verwenden, sondern '.' und'#'um sie zu definieren. Der obige Code wird zuerst in - konvertiert

<!DOCTYPE html>
<html>
   <head>
      <title>Hello Pug</title>
   </head>
   
   <body>
      <p class = "greetings" id = "people">Hello World!</p>
   </body>
</html>

Pug kann viel mehr als nur das HTML-Markup vereinfachen.

Wichtige Eigenschaften des Mops

Lassen Sie uns nun einige wichtige Merkmale von Pug untersuchen.

Einfache Tags

Tags werden entsprechend ihrer Einrückung verschachtelt. Wie im obigen Beispiel,<title> wurde innerhalb der eingerückt <head>Tag, also war es drin. Aber die<body> Tag war auf dem gleichen Einzug, also war es ein Geschwister der <head> Etikett.

Wir müssen keine Tags schließen. Sobald Pug auf das nächste Tag auf derselben oder einer äußeren Einrückungsstufe trifft, wird das Tag für uns geschlossen.

Um Text in ein Tag einzufügen, haben wir drei Methoden:

  • Space seperated

h1 Welcome to Pug

  • Piped text

div
   | To insert multiline text, 
   | You can use the pipe operator.

  • Block of text

div.
   But that gets tedious if you have a lot of text.
   You can use "." at the end of tag to denote block of text.
   To put tags inside this block, simply enter tag in a new line and 
   indent it accordingly.

Bemerkungen

Pug verwendet dieselbe Syntax wie JavaScript(//)zum Erstellen von Kommentaren. Diese Kommentare werden in die HTML-Kommentare konvertiert (<! - Kommentar ->). Zum Beispiel,

//This is a Pug comment

Dieser Kommentar wird wie folgt konvertiert.

<!--This is a Pug comment-->

Attribute

Um Attribute zu definieren, verwenden wir eine durch Kommas getrennte Liste von Attributen in Klammern. Klassen- und ID-Attribute haben spezielle Darstellungen. Die folgende Codezeile behandelt das Definieren von Attributen, Klassen und IDs für ein bestimmtes HTML-Tag.

div.container.column.main#division(width = "100", height = "100")

Diese Codezeile wird in die folgende konvertiert. - -

<div class = "container column main" id = "division" width = "100" height = "100"></div>

Werte an Vorlagen übergeben

Wenn wir eine Mops-Vorlage rendern, können wir ihr tatsächlich einen Wert aus unserem Routen-Handler übergeben, den wir dann in unserer Vorlage verwenden können. Erstellen Sie einen neuen Routenhandler mit den folgenden Anweisungen.

var express = require('express');
var app = express();

app.get('/dynamic_view', function(req, res){
   res.render('dynamic', {
      name: "TutorialsPoint", 
      url:"http://www.tutorialspoint.com"
   });
});

app.listen(3000);

Erstellen Sie eine neue Ansichtsdatei im Ansichtsverzeichnis mit dem Namen dynamic.pug, mit folgendem Code -

html
   head
      title=name
   body
      h1=name
      a(href = url) URL

Öffnen Sie localhost: 3000 / dynamic_view in Ihrem Browser. Sie sollten die folgende Ausgabe erhalten -

Wir können diese übergebenen Variablen auch im Text verwenden. Um übergebene Variablen zwischen den Text eines Tags einzufügen, verwenden wir#{variableName}Syntax. Wenn wir im obigen Beispiel beispielsweise Grüße aus TutorialsPoint einfügen möchten, hätten wir Folgendes tun können.

html
   head
      title = name
   body
      h1 Greetings from #{name}
      a(href = url) URL

Diese Methode zur Verwendung von Werten wird aufgerufen interpolation. Der obige Code zeigt die folgende Ausgabe an. - -

Bedingungen

Wir können auch bedingte Anweisungen und Schleifenkonstrukte verwenden.

Betrachten Sie Folgendes:

Wenn ein Benutzer angemeldet ist, sollte die Seite angezeigt werden "Hi, User" und wenn nicht, dann die "Login/Sign Up"Verknüpfung. Um dies zu erreichen, können wir eine einfache Vorlage wie - definieren

html
   head
      title Simple template
   body
      if(user)
         h1 Hi, #{user.name}
      else
         a(href = "/sign_up") Sign Up

Wenn wir dies mit unseren Routen rendern, können wir ein Objekt wie im folgenden Programm übergeben -

res.render('/dynamic',{
   user: {name: "Ayush", age: "20"}
});

Sie erhalten eine Nachricht - Hi, Ayush. Wenn wir jedoch kein Objekt oder ein Objekt ohne Benutzerschlüssel übergeben, erhalten wir einen Anmeldelink.

Include und Komponenten

Pug bietet eine sehr intuitive Möglichkeit, Komponenten für eine Webseite zu erstellen. Wenn Sie beispielsweise eine Nachrichtenwebsite sehen, ist die Kopfzeile mit Logo und Kategorien immer festgelegt. Anstatt dies in jede von uns erstellte Ansicht zu kopieren, können wir die verwendenincludeMerkmal. Das folgende Beispiel zeigt, wie wir diese Funktion verwenden können -

Erstellen Sie 3 Ansichten mit dem folgenden Code:

HEADER.PUG

div.header.
   I'm the header for this website.

CONTENT.PUG

html
   head
      title Simple template
   body
      include ./header.pug
      h3 I'm the main content
      include ./footer.pug

FOOTER.PUG

div.footer.
   I'm the footer for this website.

Erstellen Sie dazu eine Route wie folgt:

var express = require('express');
var app = express();

app.get('/components', function(req, res){
    res.render('content');
});

app.listen(3000);

Gehen Sie zu localhost: 3000 / Komponenten, Sie erhalten die folgende Ausgabe -

include kann auch verwendet werden, um Klartext, CSS und JavaScript einzuschließen.

Es gibt viele weitere Funktionen von Pug. Diese sind jedoch nicht in diesem Lernprogramm enthalten. Sie können Pug at Pug weiter erkunden .

Statische Dateien sind Dateien, die Clients so herunterladen, wie sie vom Server sind. Erstellen Sie ein neues Verzeichnis,public. Express erlaubt Ihnen standardmäßig nicht, statische Dateien bereitzustellen. Sie müssen es mit der folgenden integrierten Middleware aktivieren.

app.use(express.static('public'));

Note - Express sucht die Dateien relativ zum statischen Verzeichnis, sodass der Name des statischen Verzeichnisses nicht Teil der URL ist.

Beachten Sie, dass die Root-Route jetzt auf Ihr öffentliches Verzeichnis festgelegt ist, sodass alle statischen Dateien, die Sie laden, public als root betrachten. Um zu testen, ob dies einwandfrei funktioniert, fügen Sie eine beliebige Bilddatei in Ihre neue einpublic dir und ändere seinen Namen in "testimage.jpg". Erstellen Sie in Ihren Ansichten eine neue Ansicht und fügen Sie diese Datei wie folgt hinzu:

html
   head
   body
      h3 Testing static file serving:
      img(src = "/testimage.jpg", alt = "Testing Image

Sie sollten die folgende Ausgabe erhalten -

Mehrere statische Verzeichnisse

Mit dem folgenden Programm können wir auch mehrere Verzeichnisse für statische Assets festlegen:

var express = require('express');
var app = express();

app.use(express.static('public'));
app.use(express.static('images'));

app.listen(3000);

Präfix für den virtuellen Pfad

Wir können auch ein Pfadpräfix für die Bereitstellung statischer Dateien bereitstellen. Zum Beispiel, wenn Sie ein Pfadpräfix wie angeben möchten'/static'müssen Sie den folgenden Code in Ihre index.js Datei -

var express = require('express');
var app = express();

app.use('/static', express.static('public'));

app.listen(3000);

Wenn Sie jetzt eine Datei einfügen müssen, z. B. eine Skriptdatei mit dem Namen main.js, die sich in Ihrem öffentlichen Verzeichnis befindet, verwenden Sie das folgende Skript-Tag:

<script src = "/static/main.js" />

Diese Technik kann nützlich sein, wenn mehrere Verzeichnisse als statische Dateien bereitgestellt werden. Diese Präfixe können dabei helfen, zwischen mehreren Verzeichnissen zu unterscheiden.

Formulare sind ein wesentlicher Bestandteil des Webs. Fast jede Website, die wir besuchen, bietet uns Formulare an, die Informationen für uns senden oder abrufen. Um mit Formularen zu beginnen, installieren wir zuerst den Body-Parser (zum Parsen von JSON- und URL-codierten Daten) und die Multer-Middleware (zum Parsen von mehrteiligen / Formulardaten).

Um den Body-Parser und den Multer zu installieren , gehen Sie zu Ihrem Terminal und verwenden Sie -

npm install --save body-parser multer

Ersetzen Sie Ihre index.js Dateiinhalt mit folgendem Code -

var express = require('express');
var bodyParser = require('body-parser');
var multer = require('multer');
var upload = multer();
var app = express();

app.get('/', function(req, res){
   res.render('form');
});

app.set('view engine', 'pug');
app.set('views', './views');

// for parsing application/json
app.use(bodyParser.json()); 

// for parsing application/xwww-
app.use(bodyParser.urlencoded({ extended: true })); 
//form-urlencoded

// for parsing multipart/form-data
app.use(upload.array()); 
app.use(express.static('public'));

app.post('/', function(req, res){
   console.log(req.body);
   res.send("recieved your request!");
});
app.listen(3000);

Nach dem Import des Body Parsers und Multers verwenden wir den body-parser für das Parsen von json- und x-www-form-urlencodierten Header-Anfragen, während wir verwenden werden multer zum Parsen von mehrteiligen / Formulardaten.

Lassen Sie uns ein HTML-Formular erstellen, um dies zu testen. Erstellen Sie eine neue Ansicht mit dem Namenform.pug mit folgendem Code -

html
html
   head
      title Form Tester
   body
      form(action = "/", method = "POST")
         div
            label(for = "say") Say:
            input(name = "say" value = "Hi")
         br
         div
            label(for = "to") To:
            input(name = "to" value = "Express forms")
         br
         button(type = "submit") Send my greetings

Führen Sie Ihren Server wie folgt aus.

nodemon index.js

Gehen Sie nun zu localhost: 3000 / und füllen Sie das Formular aus, wie Sie möchten, und senden Sie es ab. Die folgende Antwort wird angezeigt:

Schauen Sie sich Ihre Konsole an. Es zeigt Ihnen den Text Ihrer Anfrage als JavaScript-Objekt wie im folgenden Screenshot -

Das req.bodyObjekt enthält Ihren analysierten Anforderungshauptteil. Um Felder aus diesem Objekt zu verwenden, verwenden Sie sie einfach wie normale JS-Objekte.

Dies ist die am meisten empfohlene Methode zum Senden einer Anfrage. Es gibt viele andere Möglichkeiten, die jedoch hier nicht behandelt werden müssen, da unsere Express-App alle diese Anfragen auf dieselbe Weise behandelt. Weitere Informationen zu verschiedenen Möglichkeiten, eine Anfrage zu stellen, finden Sie auf dieser Seite.

Wir erhalten weiterhin Anfragen, speichern diese jedoch nirgendwo. Wir benötigen eine Datenbank zum Speichern der Daten. Dazu verwenden wir die aufgerufene NoSQL-DatenbankMongoDB.

Folgen Sie diesem Link, um Mongo zu installieren und zu lesen .

Um Mongo mit Express verwenden zu können, benötigen wir eine Client-API für den Knoten. Es gibt mehrere Möglichkeiten für uns, aber für dieses Tutorial bleiben wir beim Mungo . Mungo wird verwendet fürdocument Modelingim Knoten für MongoDB. Für die Dokumentmodellierung erstellen wir eineModel (ähnlich wie ein class in dokumentenorientierter Programmierung), und dann produzieren wir documents mit diesem Modell (wie wir erstellen documents of a classin OOP). Alle unsere Verarbeitung wird auf diesen "Dokumenten" durchgeführt, und schließlich werden wir diese Dokumente in unsere Datenbank schreiben.

Mungo einrichten

Nachdem Sie Mongo installiert haben, lassen Sie uns Mongoose genauso installieren, wie wir unsere anderen Knotenpakete installiert haben.

npm install --save mongoose

Bevor wir Mungo verwenden, müssen wir eine Datenbank mit der Mongo-Shell erstellen. Um eine neue Datenbank zu erstellen, öffnen Sie Ihr Terminal und geben Sie "mongo" ein. Eine Mongo-Shell wird gestartet. Geben Sie den folgenden Code ein:

use my_db

Eine neue Datenbank wird für Sie erstellt. Wenn Sie die Mongo-Shell öffnen, wird standardmäßig die Datenbank "getestet", und Sie müssen mit demselben Befehl wie oben zu Ihrer Datenbank wechseln.

Um Mongoose verwenden zu können, benötigen wir es in unserem index.js Datei und verbinden Sie sich dann mit dem mongodb Dienst läuft weiter mongodb://localhost.

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

Jetzt ist unsere App mit unserer Datenbank verbunden. Lassen Sie uns ein neues Modell erstellen. Dieses Modell dient als Sammlung in unserer Datenbank. Verwenden Sie zum Erstellen eines neuen Modells den folgenden Code, bevor Sie eine Route definieren:

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});
var Person = mongoose.model("Person", personSchema);

Der obige Code definiert das Schema für eine Person und wird zum Erstellen eines Mungo-Modus verwendet Person.

Dokumente speichern

Jetzt erstellen wir ein neues HTML-Formular. Mit diesem Formular können Sie die Details einer Person abrufen und in unserer Datenbank speichern. Erstellen Sie zum Erstellen des Formulars eine neue Ansichtsdatei mit dem Namenperson.pug im Ansichtenverzeichnis mit folgendem Inhalt -

html
head
   title Person
   body
      form(action = "/person", method = "POST")
      div
         label(for = "name") Name: 
         input(name = "name")
      br
      div
         label(for = "age") Age: 
         input(name = "age")
      br
      div
         label(for = "nationality") Nationality: 
         input(name = "nationality")
      br
      button(type = "submit") Create new person

Fügen Sie auch a hinzu new get route im index.js um dieses Dokument zu rendern -

app.get('/person', function(req, res){
   res.render('person');
});

Gehe zu "localhost:3000/person"um zu überprüfen, ob das Formular die richtige Ausgabe anzeigt. Beachten Sie, dass dies nur die Benutzeroberfläche ist und noch nicht funktioniert. Der folgende Screenshot zeigt, wie das Formular angezeigt wird -

Wir werden nun einen Post-Route-Handler unter definieren '/person' welches diese Anfrage behandeln wird

app.post('/person', function(req, res){
   var personInfo = req.body; //Get the parsed information
   
   if(!personInfo.name || !personInfo.age || !personInfo.nationality){
      res.render('show_message', {
         message: "Sorry, you provided worng info", type: "error"});
   } else {
      var newPerson = new Person({
         name: personInfo.name,
         age: personInfo.age,
         nationality: personInfo.nationality
      });
		
      newPerson.save(function(err, Person){
         if(err)
            res.render('show_message', {message: "Database error", type: "error"});
         else
            res.render('show_message', {
               message: "New person added", type: "success", person: personInfo});
      });
   }
});

Wenn wir im obigen Code ein leeres Feld erhalten oder kein Feld erhalten, senden wir eine Fehlerantwort. Wenn wir jedoch ein wohlgeformtes Dokument erhalten, erstellen wir einnewPerson Dokument aus dem Personenmodell und speichern Sie es mit dem in unserer Datenbank newPerson.save()Funktion. Dies ist in Mongoose definiert und akzeptiert einen Rückruf als Argument. Dieser Rückruf hat zwei Argumente - Fehler und Antwort. Diese Argumente rendern dieshow_message Aussicht.

Um die Antwort von dieser Route anzuzeigen, müssen wir auch eine erstellen show_messageAussicht. Erstellen Sie eine neue Ansicht mit dem folgenden Code:

html
   head
      title Person
   body
      if(type == "error")
         h3(style = "color:red") #{message}
      else
         h3 New person, 
            name: #{person.name}, 
            age: #{person.age} and 
            nationality: #{person.nationality} added!

Wir erhalten die folgende Antwort nach erfolgreicher Übermittlung der form(show_message.pug) - -

Wir haben jetzt eine Schnittstelle zu erstellen persons.

Dokumente abrufen

Mungo bietet viele Funktionen zum Abrufen von Dokumenten, wir werden uns auf drei davon konzentrieren. Alle diese Funktionen verwenden auch einen Rückruf als letzten Parameter, und genau wie die Speicherfunktion sind ihre Argumente Fehler und Antwort. Die drei Funktionen sind wie folgt:

Model.find (Bedingungen, Rückruf)

Diese Funktion findet alle Dokumente, die mit den Feldern im Bedingungsobjekt übereinstimmen. Dieselben in Mongo verwendeten Operatoren arbeiten auch in Mungos. Zum Beispiel,

Person.find(function(err, response){
   console.log(response);
});

Dadurch werden alle Dokumente aus der Sammlung der Person abgerufen.

Person.find({name: "Ayush", age: 20}, 
   function(err, response){
      console.log(response);
});

Dadurch werden alle Dokumente abgerufen, bei denen der Feldname "Ayush" und das Alter 20 Jahre beträgt.

Wir können auch die Projektion bereitstellen, die wir benötigen, dh die Felder, die wir benötigen. Zum Beispiel, wenn wir nur die wollennames von Menschen, deren nationalityist "indisch" , wir benutzen -

Person.find({nationality: "Indian"}, "name", function(err, response){
   console.log(response);
});

Model.findOne (Bedingungen, Rückruf)

Diese Funktion ruft immer ein einzelnes, relevantestes Dokument ab. Es hat die gleichen genauen Argumente wieModel.find().

Model.findById (ID, Rückruf)

Diese Funktion übernimmt die _id(definiert von mongo) als erstes Argument, eine optionale Projektionszeichenfolge und ein Rückruf zur Verarbeitung der Antwort. Zum Beispiel,

Person.findById("507f1f77bcf86cd799439011", function(err, response){
   console.log(response);
});

Lassen Sie uns nun eine Route erstellen, um alle Personendatensätze anzuzeigen -

var express = require('express');
var app = express();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

app.get('/people', function(req, res){
   Person.find(function(err, response){
      res.json(response);
   });
});

app.listen(3000);

Dokumente aktualisieren

Mongoose bietet 3 Funktionen zum Aktualisieren von Dokumenten. Die Funktionen werden nachfolgend beschrieben -

Model.update (Zustand, Updates, Rückruf)

Diese Funktion nimmt Bedingungen und aktualisiert ein Objekt als Eingabe und wendet die Änderungen auf alle Dokumente an, die den Bedingungen in der Sammlung entsprechen. Mit dem folgenden Code wird beispielsweise die Nationalität "Amerikaner" in allen Personendokumenten aktualisiert.

Person.update({age: 25}, {nationality: "American"}, function(err, response){
   console.log(response);
});

Model.findOneAndUpdate (Bedingung, Aktualisierungen, Rückruf)

Es findet ein Dokument basierend auf der Abfrage und aktualisiert es gemäß dem zweiten Argument. Es wird auch ein Rückruf als letztes Argument verwendet. Lassen Sie uns das folgende Beispiel ausführen, um die Funktion zu verstehen

Person.findOneAndUpdate({name: "Ayush"}, {age: 40}, function(err, response) {
   console.log(response);
});

Model.findByIdAndUpdate (ID, Updates, Rückruf)

Diese Funktion aktualisiert ein einzelnes Dokument, das durch seine ID identifiziert wird. Zum Beispiel,

Person.findByIdAndUpdate("507f1f77bcf86cd799439011", {name: "James"}, 
   function(err, response){
      console.log(response);
});

Lassen Sie uns nun eine Route erstellen, um Personen zu aktualisieren. Dies wird einPUT Route mit der ID als Parameter und Details in der Nutzlast.

var express = require('express');
var app = express();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

app.put('/people/:id', function(req, res){
   Person.findByIdAndUpdate(req.params.id, req.body, function(err, response){
      if(err) res.json({message: "Error in updating person with id " + req.params.id});
      res.json(response);
   });
});

app.listen(3000);

Geben Sie zum Testen dieser Route Folgendes in Ihr Terminal ein (ersetzen Sie die ID durch eine ID aus Ihrem erstellten people) -

curl -X PUT --data "name = James&age = 20&nationality = American
"http://localhost:3000/people/507f1f77bcf86cd799439011

Dadurch wird das Dokument, das der in der Route angegebenen ID zugeordnet ist, mit den oben genannten Details aktualisiert.

Dokumente löschen

Wir haben abgedeckt Create, Read und UpdateJetzt werden wir sehen, wie man Mungo gewohnt ist DeleteUnterlagen. Wir haben hier 3 Funktionen, genau wie beim Update.

Model.remove (Bedingung, [Rückruf])

Diese Funktion verwendet ein Bedingungsobjekt als Eingabe und entfernt alle Dokumente, die den Bedingungen entsprechen. Wenn wir beispielsweise alle Personen im Alter von 20 Jahren entfernen müssen, verwenden Sie die folgende Syntax:

Person.remove({age:20});

Model.findOneAndRemove (Bedingung, [Rückruf])

Diese Funktion entfernt a single, relevantestes Dokument nach Bedingungsobjekt. Lassen Sie uns den folgenden Code ausführen, um dasselbe zu verstehen.

Person.findOneAndRemove({name: "Ayush"});

Model.findByIdAndRemove (id, [Rückruf])

Diese Funktion entfernt ein einzelnes Dokument, das durch seine ID identifiziert wird. Zum Beispiel,

Person.findByIdAndRemove("507f1f77bcf86cd799439011");

Lassen Sie uns nun eine Route erstellen, um Personen aus unserer Datenbank zu löschen.

var express = require('express');
var app = express();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

app.delete('/people/:id', function(req, res){
   Person.findByIdAndRemove(req.params.id, function(err, response){
      if(err) res.json({message: "Error in deleting record id " + req.params.id});
      else res.json({message: "Person with id " + req.params.id + " removed."});
   });
});

app.listen(3000);

Verwenden Sie den folgenden Curl-Befehl, um die Ausgabe zu überprüfen: 

curl -X DELETE http://localhost:3000/people/507f1f77bcf86cd799439011

Dadurch wird die Person mit der angegebenen ID entfernt, die die folgende Nachricht erstellt:

{message: "Person with id 507f1f77bcf86cd799439011 removed."}

Dies fasst zusammen, wie wir einfache CRUD-Anwendungen mit MongoDB, Mongoose und Express erstellen können. Lesen Sie die API-Dokumente, um Mongoose weiter zu erkunden .

Cookies sind einfache, kleine Dateien / Daten, die mit einer Serveranforderung an den Client gesendet und auf der Clientseite gespeichert werden. Jedes Mal, wenn der Benutzer die Website zurücklädt, wird dieses Cookie mit der Anfrage gesendet. Dies hilft uns, die Aktionen des Benutzers zu verfolgen.

Im Folgenden sind die zahlreichen Verwendungsmöglichkeiten der HTTP-Cookies aufgeführt:

  • Sitzungsverwaltung
  • Personalisierung (Empfehlungssysteme)
  • Benutzerverfolgung

Um Cookies mit Express verwenden zu können, benötigen wir die Cookie-Parser-Middleware. Verwenden Sie zum Installieren den folgenden Code:

npm install --save cookie-parser

Um nun Cookies mit Express verwenden zu können, benötigen wir die cookie-parser. Der Cookie-Parser ist eine Middleware, die an das Clientanforderungsobjekt angehängte Cookies analysiert . Um es zu benutzen, benötigen wir es in unseremindex.jsDatei; Dies kann genauso verwendet werden wie andere Middleware. Hier verwenden wir den folgenden Code.

var cookieParser = require('cookie-parser');
app.use(cookieParser());

Cookie-Parser analysiert den Cookie-Header und füllt ihn req.cookiesmit einem Objekt, das durch die Cookie-Namen verschlüsselt ist. Um ein neues Cookie zu setzen, definieren wir eine neue Route in Ihrer Express-App wie -

var express = require('express');
var app = express();

app.get('/', function(req, res){
   res.cookie('name', 'express').send('cookie set'); //Sets name = express
});

app.listen(3000);

Um zu überprüfen, ob Ihr Cookie gesetzt ist oder nicht, rufen Sie einfach Ihren Browser auf, starten Sie die Konsole und geben Sie - ein.

console.log(document.cookie);

Sie erhalten die Ausgabe wie (möglicherweise haben Sie mehr Cookies gesetzt, möglicherweise aufgrund von Erweiterungen in Ihrem Browser) -

"name = express"

Der Browser sendet außerdem jedes Mal Cookies zurück, wenn er den Server abfragt. Fügen Sie dieser Route den folgenden Code hinzu, um Cookies von Ihrem Server auf der Serverkonsole in einer Route anzuzeigen.

console.log('Cookies: ', req.cookies);

Wenn Sie das nächste Mal eine Anfrage an diese Route senden, erhalten Sie die folgende Ausgabe.

Cookies: { name: 'express' }

Hinzufügen von Cookies mit Ablaufzeit

Sie können Cookies hinzufügen, die ablaufen. Um ein Cookie hinzuzufügen, das abläuft, übergeben Sie einfach ein Objekt mit der Eigenschaft 'expire' auf den Zeitpunkt, zu dem es ablaufen soll. Zum Beispiel,

//Expires after 360000 ms from the time it is set.
res.cookie(name, 'value', {expire: 360000 + Date.now()});

Eine andere Möglichkeit, die Ablaufzeit festzulegen, ist die Verwendung 'maxAge'Eigentum. Mit dieser Eigenschaft können wir die relative Zeit anstelle der absoluten Zeit angeben. Das Folgende ist ein Beispiel für diese Methode.

//This cookie also expires after 360000 ms from the time it is set.
res.cookie(name, 'value', {maxAge: 360000});

Vorhandene Cookies löschen

Verwenden Sie zum Löschen eines Cookies die Funktion clearCookie. Zum Beispiel, wenn Sie ein Cookie mit dem Namen löschen müssenfooVerwenden Sie den folgenden Code.

var express = require('express');
var app = express();

app.get('/clear_cookie_foo', function(req, res){
   res.clearCookie('foo');
   res.send('cookie foo cleared');
});

app.listen(3000);

Im nächsten Kapitel erfahren Sie, wie Sie Cookies zum Verwalten von Sitzungen verwenden.

HTTP ist zustandslos. Um eine Anfrage einer anderen Anfrage zuzuordnen, benötigen Sie eine Möglichkeit, Benutzerdaten zwischen HTTP-Anfragen zu speichern. Cookies und URL-Parameter sind beide geeignete Möglichkeiten, um Daten zwischen dem Client und dem Server zu transportieren. Sie sind jedoch sowohl lesbar als auch clientseitig. Sitzungen lösen genau dieses Problem. Sie weisen dem Client eine ID zu und er stellt alle weiteren Anforderungen mit dieser ID. Mit dem Client verknüpfte Informationen werden auf dem mit dieser ID verknüpften Server gespeichert.

Wir benötigen die Express-Sitzung , installieren Sie sie also mit dem folgenden Code.

npm install --save express-session

Wir werden das setzen session und cookie-parserMiddleware vorhanden. In diesem Beispiel verwenden wir den Standardspeicher zum Speichern von Sitzungen, dh MemoryStore. Verwenden Sie dies niemals in Produktionsumgebungen. Die Sitzungs-Middleware erledigt alle Dinge für uns, dh das Erstellen der Sitzung, das Setzen des Sitzungscookies und das Erstellen des Sitzungsobjekts inreq Objekt.

Immer wenn wir erneut eine Anfrage vom selben Client stellen, werden deren Sitzungsinformationen bei uns gespeichert (vorausgesetzt, der Server wurde nicht neu gestartet). Wir können dem Sitzungsobjekt weitere Eigenschaften hinzufügen. Im folgenden Beispiel erstellen wir einen Ansichtszähler für einen Client.

var express = require('express');
var cookieParser = require('cookie-parser');
var session = require('express-session');

var app = express();

app.use(cookieParser());
app.use(session({secret: "Shh, its a secret!"}));

app.get('/', function(req, res){
   if(req.session.page_views){
      req.session.page_views++;
      res.send("You visited this page " + req.session.page_views + " times");
   } else {
      req.session.page_views = 1;
      res.send("Welcome to this page for the first time!");
   }
});
app.listen(3000);

Wenn ein Benutzer die Site besucht, erstellt der obige Code eine neue Sitzung für den Benutzer und weist ihm ein Cookie zu. Wenn der Benutzer das nächste Mal kommt, wird das Cookie überprüft und daspage_view Sitzungsvariable wird entsprechend aktualisiert.

Nun, wenn Sie die App ausführen und zu gehen localhost:3000wird die folgende Ausgabe angezeigt.

Wenn Sie die Seite erneut besuchen, erhöht sich der Seitenzähler. Die Seite im folgenden Screenshot wurde 42 Mal aktualisiert.

Die Authentifizierung ist ein Prozess, bei dem die angegebenen Anmeldeinformationen mit denen verglichen werden, die in einer Datenbank mit Informationen autorisierter Benutzer auf einem lokalen Betriebssystem oder auf einem Authentifizierungsserver gespeichert sind. Wenn die Anmeldeinformationen übereinstimmen, ist der Vorgang abgeschlossen und der Benutzer erhält die Berechtigung zum Zugriff.

Damit wir ein Authentifizierungssystem erstellen können, müssen wir eine Anmeldeseite und einen Benutzerkennwortspeicher erstellen. Der folgende Code erstellt ein Konto für uns und speichert es im Speicher. Dies ist nur zum Zweck der Demo; Es wird empfohlen, immer einen dauerhaften Speicher (Datenbank oder Dateien) zum Speichern von Benutzerinformationen zu verwenden.

var express = require('express');
var app = express();
var bodyParser = require('body-parser');
var multer = require('multer');
var upload = multer(); 
var session = require('express-session');
var cookieParser = require('cookie-parser');

app.set('view engine', 'pug');
app.set('views','./views');

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true })); 
app.use(upload.array());
app.use(cookieParser());
app.use(session({secret: "Your secret key"}));

var Users = [];

app.get('/signup', function(req, res){
   res.render('signup');
});

app.post('/signup', function(req, res){
   if(!req.body.id || !req.body.password){
      res.status("400");
      res.send("Invalid details!");
   } else {
      Users.filter(function(user){
         if(user.id === req.body.id){
            res.render('signup', {
               message: "User Already Exists! Login or choose another user id"});
         }
      });
      var newUser = {id: req.body.id, password: req.body.password};
      Users.push(newUser);
      req.session.user = newUser;
      res.redirect('/protected_page');
   }
});

app.listen(3000);

Erstellen Sie nun für das Anmeldeformular eine neue Ansicht mit dem Namen signup.jade.

SIGNUP.JADE

html
   head
      title Signup
   body
      if(message)
         h4 #{message}
         form(action = "/signup" method = "POST")
         input(name = "id" type = "text" required placeholder = "User ID")
         input(name = "password" type = "password" required placeholder = "Password")
         button(type = "Submit") Sign me up!

Überprüfen Sie, ob diese Seite geladen wird, indem Sie localhost: 3000 / signup besuchen.

Wir haben das erforderliche Attribut für beide Felder festgelegt, sodass HTML5-fähige Browser dieses Formular erst senden können, wenn wir sowohl die ID als auch das Kennwort angeben. Wenn jemand versucht, sich mit einer Curl-Anfrage ohne Benutzer-ID oder Passwort zu registrieren, wird ein Fehler angezeigt. Erstellen Sie eine neue Datei mit dem Namenprotected_page.pug in Ansichten mit folgendem Inhalt -

html
   head
      title Protected page
   body
      div Hey #{id}, How are you doing today?
      div Want to log out?
      div Logout

Diese Seite sollte nur sichtbar sein, wenn der Benutzer sich gerade angemeldet oder angemeldet hat. Definieren wir nun seine Route und auch die Routen zum An- und Abmelden.

var express = require('express');
var app = express();
var bodyParser = require('body-parser');
var multer = require('multer');
var upload = multer(); 
var session = require('express-session');
var cookieParser = require('cookie-parser');

app.set('view engine', 'pug');
app.set('views','./views');

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true })); 
app.use(upload.array());
app.use(cookieParser());
app.use(session({secret: "Your secret key"}));

var Users = [];

app.get('/signup', function(req, res){
   res.render('signup');
});

app.post('/signup', function(req, res){
   if(!req.body.id || !req.body.password){
      res.status("400");
      res.send("Invalid details!");
   } else {
      Users.filter(function(user){
         if(user.id === req.body.id){
            res.render('signup', {
               message: "User Already Exists! Login or choose another user id"});
         }
      });
      var newUser = {id: req.body.id, password: req.body.password};
      Users.push(newUser);
      req.session.user = newUser;
      res.redirect('/protected_page');
   }
});
function checkSignIn(req, res){
   if(req.session.user){
      next();     //If session exists, proceed to page
   } else {
      var err = new Error("Not logged in!");
      console.log(req.session.user);
      next(err);  //Error, trying to access unauthorized page!
   }
}
app.get('/protected_page', checkSignIn, function(req, res){
   res.render('protected_page', {id: req.session.user.id})
});

app.get('/login', function(req, res){
   res.render('login');
});

app.post('/login', function(req, res){
   console.log(Users);
   if(!req.body.id || !req.body.password){
      res.render('login', {message: "Please enter both id and password"});
   } else {
      Users.filter(function(user){
         if(user.id === req.body.id && user.password === req.body.password){
            req.session.user = user;
            res.redirect('/protected_page');
         }
      });
      res.render('login', {message: "Invalid credentials!"});
   }
});

app.get('/logout', function(req, res){
   req.session.destroy(function(){
      console.log("user logged out.")
   });
   res.redirect('/login');
});

app.use('/protected_page', function(err, req, res, next){
console.log(err);
   //User should be authenticated! Redirect him to log in.
   res.redirect('/login');
});

app.listen(3000);

Wir haben eine Middleware-Funktion checkSignIn erstellt , um zu überprüfen, ob der Benutzer angemeldet istprotected_pageverwendet diese Funktion. Um den Benutzer abzumelden, zerstören wir die Sitzung.

Lassen Sie uns nun die Anmeldeseite erstellen. Benennen Sie die Ansicht alslogin.pug und geben Sie den Inhalt ein -

html
   head
      title Signup
   body
      if(message)
         h4 #{message}
         form(action = "/login" method = "POST")
         input(name = "id" type = "text" required placeholder = "User ID")
         input(name = "password" type = "password" required placeholder = "Password")
         button(type = "Submit") Log in

Unsere einfache Authentifizierungsanwendung ist jetzt vollständig. Lassen Sie uns nun die Anwendung testen. Führen Sie die App mit nodemon index.js aus und fahren Sie mit localhost: 3000 / signup fort.

Geben Sie einen Benutzernamen und ein Passwort ein und klicken Sie auf Anmelden. Sie werden zu weitergeleitetprotected_page wenn Details gültig / eindeutig sind -

Melden Sie sich jetzt von der App ab. Dadurch werden wir zur Anmeldeseite weitergeleitet -

Diese Route ist so geschützt, dass eine nicht authentifizierte Person, die versucht, sie zu besuchen, auf unsere Anmeldeseite weitergeleitet wird. Hier ging es um die grundlegende Benutzerauthentifizierung. Es wird immer empfohlen, ein dauerhaftes Sitzungssystem zu verwenden und Hashes für den Kennworttransport zu verwenden. Es gibt jetzt viel bessere Möglichkeiten, Benutzer zu authentifizieren, indem JSON-Token verwendet werden.

Eine API wird immer benötigt, um mobile Anwendungen und Anwendungen mit nur einer Seite zu erstellen, AJAX-Aufrufe zu verwenden und Daten für Clients bereitzustellen. Ein beliebter Architekturstil zum Strukturieren und Benennen dieser APIs und der Endpunkte wird aufgerufenREST(Representational Transfer State). HTTP 1.1wurde unter Berücksichtigung der REST-Prinzipien entwickelt. REST wurde von eingeführtRoy Fielding im Jahr 2000 in seinen Paper Fielding Dissertations.

RESTful URIs und Methoden liefern uns fast alle Informationen, die wir zur Bearbeitung einer Anfrage benötigen. Die folgende Tabelle fasst zusammen, wie die verschiedenen Verben verwendet werden sollten und wie URIs benannt werden sollten. Wir werden gegen Ende eine Film-API erstellen. Lassen Sie uns nun diskutieren, wie es strukturiert sein wird.

Methode URI Einzelheiten Funktion
BEKOMMEN /Filme Sicher, zwischenspeicherbar Ruft die Liste aller Filme und deren Details ab
BEKOMMEN / movies / 1234 Sicher, zwischenspeicherbar Ruft die Details der Film-ID 1234 ab
POST /Filme N / A Erstellt einen neuen Film mit den angegebenen Details. Die Antwort enthält den URI für diese neu erstellte Ressource.
STELLEN / movies / 1234 Idempotent Ändert die Film-ID 1234 (erstellt eine, falls sie noch nicht vorhanden ist). Die Antwort enthält den URI für diese neu erstellte Ressource.
LÖSCHEN / movies / 1234 Idempotent Die Film-ID 1234 sollte gelöscht werden, falls vorhanden. Die Antwort sollte den Status der Anforderung enthalten.
LÖSCHEN oder EINSETZEN /Filme Ungültig Sollte ungültig sein. DELETE und PUT sollte angeben, an welcher Ressource sie arbeiten.

Lassen Sie uns diese API jetzt in Express erstellen. Wir werden JSON als Transportdatenformat verwenden, da es in JavaScript einfach zu verarbeiten ist und andere Vorteile bietet. Ersetzen Sie Ihreindex.js Datei mit dem movies.js Datei wie im folgenden Programm.

index.js

var express = require('express');
var bodyParser = require('body-parser');
var multer = require('multer');
var upload = multer();

var app = express();

app.use(cookieParser());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(upload.array());

//Require the Router we defined in movies.js
var movies = require('./movies.js');

//Use the Router on the sub route /movies
app.use('/movies', movies);

app.listen(3000);

Nachdem wir unsere Anwendung eingerichtet haben, konzentrieren wir uns auf die Erstellung der API.

Beginnen Sie mit dem Einrichten der Datei movies.js. Wir verwenden keine Datenbank zum Speichern der Filme, sondern speichern sie im Speicher. Bei jedem Neustart des Servers verschwinden die von uns hinzugefügten Filme. Dies kann leicht mithilfe einer Datenbank oder einer Datei (mithilfe des Knotens fs-Modul) nachgeahmt werden.

Sobald Sie Express importiert haben, erstellen Sie einen Router und exportieren Sie ihn mit module.exports -

var express = require('express');
var router = express.Router();
var movies = [
   {id: 101, name: "Fight Club", year: 1999, rating: 8.1},
   {id: 102, name: "Inception", year: 2010, rating: 8.7},
   {id: 103, name: "The Dark Knight", year: 2008, rating: 9},
   {id: 104, name: "12 Angry Men", year: 1957, rating: 8.9}
];

//Routes will go here
module.exports = router;

Routen abrufen

Definieren wir die GET-Route, um alle Filme zu erhalten -

router.get('/', function(req, res){
   res.json(movies);
});

Um zu testen, ob dies einwandfrei funktioniert, führen Sie Ihre App aus, öffnen Sie Ihr Terminal und geben Sie -

curl -i -H "Accept: application/json" -H "Content-Type: application/json" -X GET 
localhost:3000/movies

Die folgende Antwort wird angezeigt:

[{"id":101,"name":"Fight Club","year":1999,"rating":8.1},
{"id":102,"name":"Inception","year":2010,"rating":8.7},
{"id":103,"name":"The Dark Knight","year":2008,"rating":9},
{"id":104,"name":"12 Angry Men","year":1957,"rating":8.9}]

Wir haben eine Route, um alle Filme zu bekommen. Lassen Sie uns nun eine Route erstellen, um einen bestimmten Film anhand seiner ID zu erhalten.

router.get('/:id([0-9]{3,})', function(req, res){
   var currMovie = movies.filter(function(movie){
      if(movie.id == req.params.id){
         return true;
      }
   });
   if(currMovie.length == 1){
      res.json(currMovie[0])
   } else {
      res.status(404);//Set status to 404 as movie was not found
      res.json({message: "Not Found"});
   }
});

Dadurch erhalten wir die Filme gemäß der von uns angegebenen ID. Verwenden Sie den folgenden Befehl in Ihrem Terminal, um die Ausgabe zu überprüfen:

curl -i -H "Accept: application/json" -H "Content-Type: application/json" -X GET 
localhost:3000/movies/101

Sie erhalten folgende Antwort:

{"id":101,"name":"Fight Club","year":1999,"rating":8.1}

Wenn Sie eine ungültige Route besuchen, wird eine cannot GET error Wenn Sie eine gültige Route mit einer nicht vorhandenen ID besuchen, wird ein 404-Fehler ausgegeben.

Wir sind mit den GET-Routen fertig, lassen Sie uns nun zu den weitergehen POST Route.

POST Route

Verwenden Sie die folgende Route, um die POSTed Daten -

router.post('/', function(req, res){
   //Check if all fields are provided and are valid:
   if(!req.body.name ||
      !req.body.year.toString().match(/^[0-9]{4}$/g) || !req.body.rating.toString().match(/^[0-9]\.[0-9]$/g)){
      
      res.status(400);
      res.json({message: "Bad Request"});
   } else {
      var newId = movies[movies.length-1].id+1;
      movies.push({
         id: newId,
         name: req.body.name,
         year: req.body.year,
         rating: req.body.rating
      });
      res.json({message: "New movie created.", location: "/movies/" + newId});
   }
});

Dadurch wird ein neuer Film erstellt und in der Filmvariablen gespeichert. Geben Sie den folgenden Code in Ihr Terminal ein, um diese Route zu überprüfen:

curl -X POST --data "name = Toy%20story&year = 1995&rating = 8.5" http://localhost:3000/movies

Die folgende Antwort wird angezeigt:

{"message":"New movie created.","location":"/movies/105"}

Führen Sie die get-Anforderung für aus, um zu testen, ob dies dem Filmobjekt hinzugefügt wurde /movies/105nochmal. Die folgende Antwort wird angezeigt:

{"id":105,"name":"Toy story","year":"1995","rating":"8.5"}

Lassen Sie uns fortfahren, um die PUT- und DELETE-Routen zu erstellen.

PUT-Route

Die PUT-Route entspricht fast der POST-Route. Wir geben die ID für das Objekt an, das aktualisiert / erstellt wird. Erstellen Sie die Route folgendermaßen.

router.put('/:id', function(req, res){
   //Check if all fields are provided and are valid:
   if(!req.body.name ||
      !req.body.year.toString().match(/^[0-9]{4}$/g) || !req.body.rating.toString().match(/^[0-9]\.[0-9]$/g) ||
      !req.params.id.toString().match(/^[0-9]{3,}$/g)){
      
      res.status(400);
      res.json({message: "Bad Request"});
   } else {
      //Gets us the index of movie with given id.
      var updateIndex = movies.map(function(movie){
         return movie.id;
      }).indexOf(parseInt(req.params.id));
      
      if(updateIndex === -1){
         //Movie not found, create new
         movies.push({
            id: req.params.id,
            name: req.body.name,
            year: req.body.year,
            rating: req.body.rating
         });
         res.json({message: "New movie created.", location: "/movies/" + req.params.id});
      } else {
         //Update existing movie
         movies[updateIndex] = {
            id: req.params.id,
            name: req.body.name,
            year: req.body.year,
            rating: req.body.rating
         };
         res.json({message: "Movie id " + req.params.id + " updated.", 
            location: "/movies/" + req.params.id});
      }
   }
});

Diese Route führt die in der obigen Tabelle angegebene Funktion aus. Das Objekt wird mit neuen Details aktualisiert, falls vorhanden. Wenn es nicht existiert, wird ein neues Objekt erstellt. Verwenden Sie den folgenden Curl-Befehl, um die Route zu überprüfen. Dadurch wird ein vorhandener Film aktualisiert. Um einen neuen Film zu erstellen, ändern Sie einfach die ID in eine nicht vorhandene ID.

curl -X PUT --data "name = Toy%20story&year = 1995&rating = 8.5" 
http://localhost:3000/movies/101

Response

{"message":"Movie id 101 updated.","location":"/movies/101"}

Route LÖSCHEN

Verwenden Sie den folgenden Code, um eine Löschroute zu erstellen. - -

router.delete('/:id', function(req, res){
   var removeIndex = movies.map(function(movie){
      return movie.id;
   }).indexOf(req.params.id); //Gets us the index of movie with given id.
   
   if(removeIndex === -1){
      res.json({message: "Not found"});
   } else {
      movies.splice(removeIndex, 1);
      res.send({message: "Movie id " + req.params.id + " removed."});
   }
});

Überprüfen Sie die Route auf die gleiche Weise wie die anderen Routen. Nach erfolgreichem Löschen (z. B. ID 105) erhalten Sie die folgende Ausgabe:

{message: "Movie id 105 removed."}

Endlich unsere movies.js Die Datei sieht folgendermaßen aus.

var express = require('express');
var router = express.Router();
var movies = [
   {id: 101, name: "Fight Club", year: 1999, rating: 8.1},
   {id: 102, name: "Inception", year: 2010, rating: 8.7},
   {id: 103, name: "The Dark Knight", year: 2008, rating: 9},
   {id: 104, name: "12 Angry Men", year: 1957, rating: 8.9}
];
router.get('/:id([0-9]{3,})', function(req, res){
   var currMovie = movies.filter(function(movie){
      if(movie.id == req.params.id){
         return true;
      }
   });
   
   if(currMovie.length == 1){
      res.json(currMovie[0])
   } else {
      res.status(404);  //Set status to 404 as movie was not found
      res.json({message: "Not Found"});
   }
});
router.post('/', function(req, res){
   //Check if all fields are provided and are valid:
   if(!req.body.name ||
      !req.body.year.toString().match(/^[0-9]{4}$/g) ||
      !req.body.rating.toString().match(/^[0-9]\.[0-9]$/g)){ res.status(400); res.json({message: "Bad Request"}); } else { var newId = movies[movies.length-1].id+1; movies.push({ id: newId, name: req.body.name, year: req.body.year, rating: req.body.rating }); res.json({message: "New movie created.", location: "/movies/" + newId}); } }); router.put('/:id', function(req, res) { //Check if all fields are provided and are valid: if(!req.body.name || !req.body.year.toString().match(/^[0-9]{4}$/g) ||
      !req.body.rating.toString().match(/^[0-9]\.[0-9]$/g) || !req.params.id.toString().match(/^[0-9]{3,}$/g)){
      res.status(400);
      res.json({message: "Bad Request"});
   } else {
      //Gets us the index of movie with given id.
      var updateIndex = movies.map(function(movie){
         return movie.id;
      }).indexOf(parseInt(req.params.id));
      
      if(updateIndex === -1){
         //Movie not found, create new
         movies.push({
            id: req.params.id,
            name: req.body.name,
            year: req.body.year,
            rating: req.body.rating
         });
         res.json({
            message: "New movie created.", location: "/movies/" + req.params.id});
      } else {
         //Update existing movie
         movies[updateIndex] = {
            id: req.params.id,
            name: req.body.name,
            year: req.body.year,
            rating: req.body.rating
         };
         res.json({message: "Movie id " + req.params.id + " updated.",
            location: "/movies/" + req.params.id});
      }
   }
});

router.delete('/:id', function(req, res){
   var removeIndex = movies.map(function(movie){
      return movie.id;
   }).indexOf(req.params.id); //Gets us the index of movie with given id.
   
   if(removeIndex === -1){
      res.json({message: "Not found"});
   } else {
      movies.splice(removeIndex, 1);
      res.send({message: "Movie id " + req.params.id + " removed."});
   }
});
module.exports = router;

Dies vervollständigt unsere REST-API. Jetzt können Sie mit diesem einfachen Architekturstil und Express viel komplexere Anwendungen erstellen.

Gerüste ermöglichen es uns, einfach eine zu erstellen skeleton for a web application. Wir erstellen unser öffentliches Verzeichnis manuell, fügen Middleware hinzu, erstellen separate Routendateien usw. Ein Gerüst-Tool richtet all diese Dinge für uns ein, damit wir direkt mit dem Erstellen unserer Anwendung beginnen können.

Der Gerüst, den wir verwenden werden, heißt Yeoman. Es ist ein Gerüstwerkzeug fürNode.jshat aber auch Generatoren für verschiedene andere Frameworks (wie Kolben, Schienen, Django usw.). Geben Sie zum Installieren von Yeoman den folgenden Befehl in Ihr Terminal ein:

npm install -g yeoman

Yeoman verwendet Generatoren, um Anwendungen auszurüsten. Um die verfügbaren Generatoren zu überprüfennpmZur Verwendung mit Yeoman können Sie auf diesen Link klicken . In diesem Tutorial verwenden wir den 'generator-Express-simple' . Geben Sie den folgenden Befehl in Ihr Terminal ein, um diesen Generator zu installieren:

npm install -g generator-express-simple

Geben Sie den folgenden Befehl ein, um diesen Generator zu verwenden:

yo express-simple test-app

Sie erhalten ein paar einfache Fragen, z. B. welche Dinge Sie mit Ihrer App verwenden möchten. Wählen Sie die folgenden Antworten aus. Wenn Sie diese Technologien bereits kennen, wählen Sie aus, wie sie aussehen sollen.

express-simple comes with bootstrap and jquery
[?] Select the express version you want: 4.x
[?] Do you want an mvc express app: Yes
[?] Select the css preprocessor you would like to use: sass
[?] Select view engine you would like to use: jade
[?] Select the build tool you want to use for this project: gulp
[?] Select the build tool you want to use for this project: gulp
[?] Select the language you want to use for the build tool: javascript
   create public/sass/styles.scss
   create public/js/main.js
   create views/layout.jade
   create views/index.jade
   create views/404.jade
   create app.js
   create config.js
   create routes/index.js
   create package.json
   create bower.json
identical .bowerrc
identical .editorconfig
identical .gitignore
identical .jshintrc
   create gulpfile.js

I'm all done. Running bower install & npm install for you to install the
required dependencies. If this fails, try running the command yourself.

Anschließend wird eine neue Anwendung für Sie erstellt, alle Abhängigkeiten installiert, Ihrer Anwendung einige Seiten hinzugefügt (Startseite, 404 nicht gefundene Seite usw.) und Sie erhalten eine Verzeichnisstruktur, an der Sie arbeiten können.

Dieser Generator schafft für uns eine sehr einfache Struktur. Entdecken Sie die vielen für Express verfügbaren Generatoren und wählen Sie den für Sie richtigen aus. Die Schritte zur Arbeit mit allen Generatoren sind gleich. Sie müssen einen Generator installieren und mit Yeoman betreiben. Es werden Ihnen einige Fragen gestellt und dann basierend auf Ihren Antworten ein Skelett für Ihre Anwendung erstellt.

Die Fehlerbehandlung in Express erfolgt mit Middleware. Diese Middleware hat jedoch besondere Eigenschaften. Die Fehlerbehandlungs-Middleware wird auf die gleiche Weise wie andere Middleware-Funktionen definiert, mit Ausnahme der FehlerbehandlungsfunktionenMUST have four arguments statt drei - err, req, res, next. Um beispielsweise eine Antwort auf einen Fehler zu senden, können wir Folgendes verwenden:

app.use(function(err, req, res, next) {
   console.error(err.stack);
   res.status(500).send('Something broke!');
});

Bisher haben wir Fehler in den Routen selbst behandelt. Die Fehlerbehandlungs-Middleware ermöglicht es uns, unsere Fehlerlogik zu trennen und Antworten entsprechend zu senden. Die next () -Methode, die wir in der Middleware besprochen haben, führt uns zur nächstenmiddleware/route handler.

Für die Fehlerbehandlung haben wir die next(err)Funktion. Ein Aufruf dieser Funktion überspringt die gesamte Middleware und ordnet uns den nächsten Fehlerbehandler für diese Route zu. Lassen Sie uns dies anhand eines Beispiels verstehen.

var express = require('express');
var app = express();

app.get('/', function(req, res){
   //Create an error and pass it to the next function
   var err = new Error("Something went wrong");
   next(err);
});

/*
 * other route handlers and middleware here
 * ....
 */

//An error handling middleware
app.use(function(err, req, res, next) {
   res.status(500);
   res.send("Oops, something went wrong.")
});

app.listen(3000);

Diese Middleware zur Fehlerbehandlung kann strategisch nach Routen platziert werden oder Bedingungen enthalten, um Fehlertypen zu erkennen und den Clients entsprechend zu reagieren. Das obige Programm zeigt die folgende Ausgabe an.

Express verwendet das Debug- Modul, um intern Informationen zu Routenanpassung, Middleware-Funktionen, Anwendungsmodus usw. zu protokollieren.

Um alle in Express verwendeten internen Protokolle anzuzeigen, setzen Sie die Umgebungsvariable DEBUG auf Express:* beim Starten der App -

DEBUG = express:* node index.js

Die folgende Ausgabe wird angezeigt.

Diese Protokolle sind sehr hilfreich, wenn eine Komponente Ihrer App nicht richtig funktioniert. Diese ausführliche Ausgabe könnte etwas überwältigend sein. Sie können die Variable DEBUG auch auf einen bestimmten zu protokollierenden Bereich beschränken. Wenn Sie beispielsweise den Logger auf Anwendung und Router beschränken möchten, können Sie den folgenden Code verwenden.

DEBUG = express:application,express:router node index.js

Das Debuggen ist standardmäßig deaktiviert und wird in der Produktionsumgebung automatisch aktiviert. Das Debuggen kann auch erweitert werden, um Ihren Anforderungen gerecht zu werden. Weitere Informationen finden Sie auf der npm-Seite.

Im Gegensatz zu Django und Rails, die eine definierte Vorgehensweise, Dateistruktur usw. haben, folgt Express keiner definierten Vorgehensweise. Dies bedeutet, dass Sie die Anwendung nach Ihren Wünschen strukturieren können. Da Ihre Anwendung jedoch größer wird, ist es sehr schwierig, sie zu warten, wenn sie keine genau definierte Struktur aufweist. In diesem Kapitel werden wir uns mit den allgemein verwendeten Verzeichnisstrukturen und der Trennung von Bedenken beim Erstellen unserer Anwendungen befassen.

Zunächst werden die Best Practices zum Erstellen von Knoten- und Expressanwendungen erläutert.

  • Beginnen Sie ein Knotenprojekt immer mit npm init.

  • Installieren Sie Abhängigkeiten immer mit a --save oder --save-dev. Dadurch wird sichergestellt, dass Sie beim Wechsel auf eine andere Plattform einfach npm install ausführen können , um alle Abhängigkeiten zu installieren.

  • Halten Sie sich an Dateinamen in Kleinbuchstaben und camelCase-Variablen. Wenn Sie sich ein npm-Modul ansehen, wird es in Kleinbuchstaben benannt und durch Bindestriche getrennt. Verwenden Sie camelCase, wenn Sie diese Module benötigen.

  • Schieben Sie node_modules nicht in Ihre Repositorys. Stattdessen installiert npm alles auf Entwicklungsmaschinen.

  • Verwenden ein config Datei zum Speichern von Variablen

  • Gruppieren und isolieren Sie Routen zu ihrer eigenen Datei. Nehmen Sie zum Beispiel die CRUD-Operationen in dem Filmbeispiel, das wir auf der REST-API-Seite gesehen haben.

Verzeichnisaufbau

Lassen Sie uns nun die Express-Verzeichnisstruktur diskutieren.

Websites

Express verfügt nicht über eine Community-definierte Struktur zum Erstellen von Anwendungen. Das Folgende ist eine häufig verwendete Projektstruktur für eine Website.

test-project/
   node_modules/
   config/
      db.js                //Database connection and configuration
      credentials.js       //Passwords/API keys for external services used by your app
      config.js            //Other environment variables
   models/                 //For mongoose schemas
      users.js
      things.js
   routes/                 //All routes for different entities in different files 
      users.js
      things.js
   views/
      index.pug
      404.pug
        ...
   public/                 //All static content being served
      images/
      css/
      javascript/
   app.js
   routes.js               //Require all routes in this and then require this file in 
   app.js 
   package.json

Es gibt auch andere Ansätze, um Websites mit Express zu erstellen. Sie können eine Website mithilfe des MVC-Entwurfsmusters erstellen. Weitere Informationen finden Sie unter den folgenden Links.

https://code.tutsplus.com/tutorials/build-a-complete-mvc-website-with-expressjs--net-34168

und,

https://www.terlici.com/2014/08/25/best-practices-express-structure.html.

RESTful APIs

APIs sind einfacher zu entwerfen. Sie benötigen kein öffentliches oder ein Ansichtsverzeichnis. Verwenden Sie die folgende Struktur, um APIs zu erstellen:

test-project/
   node_modules/
   config/
      db.js                //Database connection and configuration
      credentials.js       //Passwords/API keys for external services used by your app
   models/                 //For mongoose schemas
      users.js
      things.js
   routes/                 //All routes for different entities in different files 
      users.js
      things.js
   app.js
   routes.js               //Require all routes in this and then require this file in 
   app.js 
   package.json

Sie können auch einen Yeoman-Generator verwenden , um eine ähnliche Struktur zu erhalten.

In diesem Kapitel werden die verschiedenen Ressourcen aufgelistet, die wir für dieses Lernprogramm verwendet haben.

  • Der wichtigste Link sind natürlich die Express API-Dokumente - https://expressjs.com/en/4x/api.html

  • Sehr hilfreich sind auch die auf der Express-Website bereitgestellten Anleitungen zu verschiedenen Aspekten -

    • Routing

    • Middleware

    • Fehlerbehandlung

    • Debugging

  • Eine Liste nützlicher Bücher und Blogs zu Express finden Sie unter https://expressjs.com/en/resources/books-blogs.html

  • Eine Liste der am häufigsten verwendeten Middleware mit Express finden Sie unter https://expressjs.com/en/resources/middleware.html

  • Diese Blogs mit Express-Tipps und Tricks können sich als hilfreich erweisen -

    • https://derickbailey.com/categories/tips-and-tricks/

    • https://scotch.io/tutorials/learn-to-use-the-new-router-in+-expressjs-4

  • Anwendungsstruktur - https://www.terlici.com/2014/08/25/best-practices-express-structure.html

  • RESTful APIs -

    • https://www.thepolyglotdeveloper.com/2015/10/create-a-simple-restful-api-with-node-js/

    • https://scotch.io/tutorials/build-a-restful-api-using-node-and-express-4

    • https://devcenter.heroku.com/articles/mean-apps-restful-api

    • https://pixelhandler.com/posts/develop-a-restful-api-using-nodejs-with-express-and-mongoose

    • http://cwbuecheler.com/web/tutorials/2014/restful-web-app-node-express-mongodb/

  • Verwenden Sie für die erweiterte Authentifizierung PassportJS - http://passportjs.org

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved