Node.js
Web Apps mit Express

Einführung

Syntax

• app.get (Pfad [, Middleware], Rückruf [, Rückruf ...])
• app.put (Pfad [, Middleware], Rückruf [, Rückruf ...])
• app.post (Pfad [, Middleware], Rückruf [, Rückruf ...])
• app ['delete'] (Pfad [, Middleware], Rückruf [, Rückruf ...])
• app.use (Pfad [, Middleware], Rückruf [, Rückruf ...])
• app.use (Rückruf)

Parameter

Fertig machen

Sie werden zuerst ein Verzeichnis erstellen müssen, greifen sie in der Shell und installieren Express mit npm , indem Sie npm install express --save

Erstellen Sie eine Datei und nennen Sie sie app.js Sie den folgenden Code hinzu, der einen neuen Express-Server erstellt und ihm einen Endpunkt ( /ping ) mit der app.get Methode app.get :

const express = require('express');

const app = express();

app.get('/ping', (request, response) => {
    response.send('pong');
});

app.listen(8080, 'localhost');

Um Ihr Skript auszuführen, verwenden Sie den folgenden Befehl in Ihrer Shell:

> node app.js

Ihre Anwendung akzeptiert Verbindungen auf dem Localhost-Port 8080. Wenn das Hostname-Argument für app.listen ist, akzeptiert der Server Verbindungen sowohl auf der IP-Adresse des Computers als auch auf Localhost. Wenn der Portwert 0 ist, weist das Betriebssystem einen verfügbaren Port zu.

Sobald Ihr Skript ausgeführt wird, können Sie es in einer Shell testen, um zu bestätigen, dass Sie die erwartete Antwort "pong" vom Server erhalten:

> curl http://localhost:8080/ping
pong

Sie können auch einen Webbrowser öffnen. Navigieren Sie zur URL http: // localhost: 8080 / ping , um die Ausgabe anzuzeigen

Grundlegendes Routing

Erstellen Sie zuerst eine Express-App:

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

Dann können Sie Routen wie folgt definieren:

app.get('/someUri', function (req, res, next) {})

Diese Struktur funktioniert für alle HTTP-Methoden und erwartet einen Pfad als erstes Argument und einen Handler für diesen Pfad, der die Anforderungs- und Antwortobjekte empfängt. Für die grundlegenden HTTP-Methoden sind dies die Routen

// GET www.domain.com/myPath
app.get('/myPath', function (req, res, next) {})

// POST www.domain.com/myPath
app.post('/myPath', function (req, res, next) {})

// PUT www.domain.com/myPath
app.put('/myPath', function (req, res, next) {})

// DELETE www.domain.com/myPath
app.delete('/myPath', function (req, res, next) {})

Sie können die vollständige Liste der unterstützten Verben hier überprüfen. Wenn Sie dasselbe Verhalten für eine Route und alle HTTP-Methoden definieren möchten, können Sie Folgendes verwenden:

app.all('/myPath', function (req, res, next) {}) 

oder

app.use('/myPath', function (req, res, next) {})

oder

app.use('*', function (req, res, next) {})

// * wildcard will route for all paths

Sie können Ihre Routendefinitionen für einen einzelnen Pfad verketten

app.route('/myPath')
  .get(function (req, res, next) {})
  .post(function (req, res, next) {})
  .put(function (req, res, next) {})

Sie können jeder HTTP-Methode auch Funktionen hinzufügen. Sie werden vor dem letzten Rückruf ausgeführt und übernehmen die Parameter (req, res, next) als Argumente.

// GET www.domain.com/myPath
app.get('/myPath', myFunction, function (req, res, next) {})

Ihre letzten Rückrufe können in einer externen Datei gespeichert werden, um zu vermeiden, dass zu viel Code in eine Datei eingefügt wird:

// other.js
exports.doSomething = function(req, res, next) {/* do some stuff */};

Und dann in der Datei mit Ihren Routen:

const other = require('./other.js');
app.get('/someUri', myFunction, other.doSomething);

Dadurch wird Ihr Code viel sauberer.

Informationen aus der Anfrage erhalten

Um Informationen von der anfordernden URL zu erhalten (beachten Sie, dass req das Anforderungsobjekt in der Handlerfunktion der Routen ist). Berücksichtigen Sie diese /settings/:user_id und dieses bestimmte Beispiel /settings/32135?field=name

// get the full path
req.originalUrl // => /settings/32135?field=name

// get the user_id param
req.params.user_id // => 32135     

// get the query value of the field
req.query.field // => 'name'

Sie können auch Header der Anfrage erhalten

req.get('Content-Type')
// "text/plain"

Um das Erhalten anderer Informationen zu vereinfachen, können Sie Middlewares verwenden. Um beispielsweise die Body-Informationen der Anfrage zu erhalten, können Sie die Body-Parser- Middleware verwenden, die rohen Request-Body in ein verwendbares Format umwandelt.

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

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

Angenommen, eine solche Anfrage

PUT /settings/32135
{
  "name": "Peter"
}

Sie können auf den veröffentlichten Namen wie folgt zugreifen

req.body.name
// "Peter"

In ähnlicher Weise können Sie von der Anfrage aus auf Cookies zugreifen, Sie benötigen außerdem eine Middleware wie einen Cookie-Parser

req.cookies.name

Modulare Expressanwendung

Um die Web-Anwendung für Webanwendungen modular zu gestalten, verwenden Sie Routerfabriken:

Modul:

// greet.js
const express = require('express');

module.exports = function(options = {}) { // Router factory
    const router = express.Router();

    router.get('/greet', (req, res, next) => {
        res.end(options.greeting);
    });

    return router;
};

Anwendung:

// app.js
const express = require('express');
const greetMiddleware = require('./greet.js');

express()
    .use('/api/v1/', greetMiddleware({ greeting:'Hello world' }))
    .listen(8080);

Dadurch wird Ihre Anwendung modular, anpassbar und der Code wiederverwendbar.

Wenn Sie auf http://<hostname>:8080/api/v1/greet zugreifen, wird Hello world ausgegeben

Komplizierteres Beispiel

Beispiel mit Services, die die Vorteile der Middleware-Fabrik zeigen.

Modul:

// greet.js
const express = require('express');

module.exports = function(options = {}) { // Router factory
    const router = express.Router();
    // Get controller
    const {service} = options;

    router.get('/greet', (req, res, next) => {
        res.end(
            service.createGreeting(req.query.name || 'Stranger')
        );
    });

    return router;
};

Anwendung:

// app.js
const express = require('express');
const greetMiddleware = require('./greet.js');

class GreetingService {
    constructor(greeting = 'Hello') {
        this.greeting = greeting;
    }

    createGreeting(name) {
        return `${this.greeting}, ${name}!`;
    }
}

express()
    .use('/api/v1/service1', greetMiddleware({
        service: new GreetingService('Hello'),
    }))
    .use('/api/v1/service2', greetMiddleware({
        service: new GreetingService('Hi'),
    }))
    .listen(8080);

Beim Zugriff auf http://<hostname>:8080/api/v1/service1/greet?name=World wird Hello, World ausgegeben und auf http://<hostname>:8080/api/v1/service2/greet?name=World Die Ausgabe ist Hi, World .

Template Engine verwenden

Template Engine verwenden

Mit dem folgenden Code wird Jade als Vorlagenmodul eingerichtet. (Hinweis: Jade wurde seit Dezember 2015 in pug umbenannt.)

const express = require('express');  //Imports the express module
const app = express();  //Creates an instance of the express module

const PORT = 3000; //Randomly chosen port

app.set('view engine','jade'); //Sets jade as the View Engine / Template Engine
app.set('views','src/views'); //Sets the directory where all the views (.jade files) are stored.

//Creates a Root Route
app.get('/',function(req, res){
    res.render('index');  //renders the index.jade file into html and returns as a response. The render function optionally takes the data to pass to the view.
});

//Starts the Express server with a callback
app.listen(PORT, function(err) {
    if (!err) {
        console.log('Server is running at port', PORT);
    } else {
        console.log(JSON.stringify(err));
    }
});

In ähnlicher Weise können auch andere Template Engines wie Handlebars ( hbs ) oder ejs . Denken Sie daran, auch die Template Engine von npm install . Für Lenker verwenden wir das hbs Paket, für Jade ein jade Paket und für EJS ein ejs Paket.

Beispiel für eine EJS-Vorlage

Mit EJS (wie andere Express-Vorlagen) können Sie Servercode ausführen und auf Ihre Servervariablen von Ihrem HTML-Code aus zugreifen.
In EJS wird " <% " als Starttag und " %> " als Endtag verwendet. Auf als Renderparameter übergebene Variablen kann mit <%=var_name%> zugegriffen werden
Zum Beispiel, wenn Sie in Ihrem Servercode ein Array mit Verbrauchsmaterialien haben
Sie können es mit schleifen

<h1><%= title %></h1>
   <ul>
<% for(var i=0; i<supplies.length; i++) { %>
    <li>
        <a href='supplies/<%= supplies[i] %>'>
            <%= supplies[i] %>
        </a>
    </li>
<% } %>

Wie Sie im Beispiel jedes Mal sehen können, wenn Sie zwischen serverseitigem Code und HTML wechseln, müssen Sie das aktuelle EJS-Tag schließen und später ein neues öffnen. Hier wollten wir ein li innerhalb des Befehls for erstellen am Ende des for und erstellen Sie ein neues Tag nur für die geschweiften Klammern
ein anderes Beispiel
Wenn wir die Standardeinstellung für die Eingabe als Variable auf der Serverseite festlegen möchten, verwenden wir <%=
zum Beispiel:

 Message:<br>
<input type="text" value="<%= message %>" name="message" required>

Hier ist die von Ihrem Server übergebene Nachrichtenvariable der Standardwert Ihrer Eingabe. Bitte beachten Sie, dass EJS eine Ausnahme auslöst, wenn Sie die Nachrichtenvariable nicht von Ihrem Server übergeben haben. Sie können Parameter mit res.render('index', {message: message}); (für ejs-Datei mit dem Namen index.ejs).

In den EJS-Tags können Sie auch verwenden, if , while oder mit einem anderen Javascript-Befehl.

JSON-API mit ExpressJS

var express = require('express');
var cors = require('cors'); // Use cors module for enable Cross-origin resource sharing

var app = express();
app.use(cors()); // for all routes

var port = process.env.PORT || 8080;

app.get('/', function(req, res) {
    var info = {
        'string_value': 'StackOverflow',
        'number_value': 8476
    }
    res.json(info);

    // or
    /* res.send(JSON.stringify({
        string_value: 'StackOverflow',
        number_value: 8476
    })) */

  //you can add a status code to the json response
   /* res.status(200).json(info) */
})

app.listen(port, function() {
    console.log('Node.js listening on port ' + port)
})

Auf http://localhost:8080/ Ausgabeobjekt

{
    string_value: "StackOverflow",
    number_value: 8476
}

Statische Dateien bereitstellen

Beim Erstellen eines Webservers mit Express muss häufig eine Kombination aus dynamischen Inhalten und statischen Dateien bereitgestellt werden.

Beispielsweise können Sie index.html und script.js haben, bei denen es sich um statische Dateien im Dateisystem handelt.

Es ist üblich, Ordner mit dem Namen "public" für statische Dateien zu verwenden. In diesem Fall kann die Ordnerstruktur folgendermaßen aussehen:

project root
├── server.js
├── package.json 
└── public
    ├── index.html
    └── script.js

So konfigurieren Sie Express für die Bereitstellung statischer Dateien:

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

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

Hinweis: Sobald der Ordner konfiguriert ist, sind index.html, script.js und alle Dateien im Ordner "public" unter dem Stammpfad verfügbar (Sie dürfen /public/ in der URL angeben). Dies liegt daran, dass express relativ zu dem konfigurierten statischen Ordner nach Dateien sucht. Sie können das virtuelle Pfadpräfix wie folgt angeben:

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

stellt die Ressourcen unter dem Präfix /static/ .

Mehrere Ordner

Es ist möglich, mehrere Ordner gleichzeitig zu definieren:

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

Beim Bereitstellen der Ressourcen prüft Express den Ordner in der Definitionsreihenfolge. Bei Dateien mit demselben Namen wird die Datei im ersten übereinstimmenden Ordner bereitgestellt.

Benannte Routen im Django-Stil

Ein großes Problem ist, dass wertvolle benannte Routen von Express nicht standardmäßig unterstützt werden. Die Lösung besteht darin, ein unterstütztes Paket eines Drittanbieters zu installieren, z. B. Express-Reverse :

npm install express-reverse

Stecken Sie es in Ihr Projekt:

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

Dann benutze es wie:

app.get('test', '/hello', function(req, res) {
  res.end('hello');
});

Der Nachteil dieses Ansatzes besteht darin, dass Sie das route Express-Modul nicht verwenden können, wie unter Erweiterte Router-Verwendung gezeigt . Die Problemumgehung besteht darin, Ihre app als Parameter an Ihre Router-Fabrik zu übergeben:

require('./middlewares/routing')(app);

Und benutze es wie:

module.exports = (app) => {
    app.get('test', '/hello', function(req, res) {
      res.end('hello');
    });
};

Von nun an können Sie herausfinden, wie Sie Funktionen definieren, um sie mit angegebenen benutzerdefinierten Namespaces zusammenzuführen und auf die entsprechenden Controller verweisen.

Fehlerbehandlung

Grundlegende Fehlerbehandlung

Standardmäßig sucht Express nach einer 'Fehleransicht' im Verzeichnis /views , die gerendert werden soll. Erstellen Sie einfach die 'Fehleransicht' und platzieren Sie sie im Verzeichnis 'views', um Fehler zu behandeln. Fehler werden mit der Fehlermeldung, dem Status und dem Stack-Trace geschrieben, zum Beispiel:

Ansichten / error.pug

html
  body
      h1= message
      h2= error.status
      p= error.stack

Erweiterte Fehlerbehandlung

Definieren Sie Ihre Fehlerbehandlungs-Middleware-Funktionen ganz am Ende des Middleware-Funktionsstapels. Diese haben vier Argumente anstelle von drei (err, req, res, next) zum Beispiel:

app.js

// catch 404 and forward to error handler
app.use(function(req, res, next) {
    var err = new Error('Not Found');
    err.status = 404;

    //pass error to the next matching route.
    next(err);
});

// handle error, print stacktrace
app.use(function(err, req, res, next) {
    res.status(err.status || 500);

    res.render('error', {
        message: err.message,
        error: err
    });
});

Sie können, wie bei normalen Middleware-Funktionen, mehrere Middleware-Funktionen zur Fehlerbehandlung definieren.

Mit Middleware und dem nächsten Callback

Express leitet einen next Rückruf an alle Routenhandler- und Middleware-Funktionen weiter, mit denen die Logik für einzelne Routen über mehrere Handler hinweg unterbrochen werden kann. Wenn Sie next() ohne Argumente aufrufen, wird express aufgefordert, mit der nächsten übereinstimmenden Middleware oder dem Routenhandler fortzufahren. Wenn Sie next(err) mit einem Fehler next(err) wird eine Middleware für die Fehlerbehandlung ausgelöst. Wenn Sie next('route') aufrufen, werden alle nachfolgenden Middleware auf der aktuellen Route umgangen und zur nächsten passenden Route gesprungen. Dies ermöglicht die Entkopplung der Domänenlogik in wiederverwendbare Komponenten, die eigenständig sind, einfacher zu testen und einfacher zu warten und zu ändern sind.

Mehrere übereinstimmende Routen

Anfragen an /api/foo oder /api/bar führen den ursprünglichen Handler aus, um das Mitglied nachzuschlagen, und übergeben dann die Kontrolle an den tatsächlichen Handler für jede Route.

app.get('/api', function(req, res, next) {
  // Both /api/foo and /api/bar will run this
  lookupMember(function(err, member) {
    if (err) return next(err);
    req.member = member;
    next();
  });
});

app.get('/api/foo', function(req, res, next) {
  // Only /api/foo will run this
  doSomethingWithMember(req.member);
});

app.get('/api/bar', function(req, res, next) {
  // Only /api/bar will run this
  doSomethingDifferentWithMember(req.member);
});

Fehlerhandler

Fehlerhandler sind Middleware mit der Signaturfunktion function(err, req, res, next) . Sie können pro Route eingerichtet werden (z. B. app.get('/foo', function(err, req, res, next) ). app.get('/foo', function(err, req, res, next) jedoch ein einzelner Fehlerhandler aus, der eine Fehlerseite darstellt.

app.get('/foo', function(req, res, next) {
  doSomethingAsync(function(err, data) {
    if (err) return next(err);
    renderPage(data);
  });
});

// In the case that doSomethingAsync return an error, this special
// error handler middleware will be called with the error as the 
// first parameter.
app.use(function(err, req, res, next) {
  renderErrorPage(err);
});

Middleware

Jede der oben genannten Funktionen ist eigentlich eine Middleware-Funktion, die immer dann ausgeführt wird, wenn eine Anforderung mit der definierten Route übereinstimmt. Es können jedoch beliebig viele Middleware-Funktionen auf einer einzelnen Route definiert werden. Auf diese Weise kann die Middleware in separaten Dateien definiert und die gemeinsame Logik über mehrere Routen hinweg wiederverwendet werden.

app.get('/bananas', function(req, res, next) {
  getMember(function(err, member) {
    if (err) return next(err);
    // If there's no member, don't try to look
    // up data. Just go render the page now.
    if (!member) return next('route');
    // Otherwise, call the next middleware and fetch
    // the member's data.
    req.member = member;
    next();
  });
}, function(req, res, next) {
  getMemberData(req.member, function(err, data) {
    if (err) return next(err);
    // If this member has no data, don't bother
    // parsing it. Just go render the page now.
    if (!data) return next('route');
    // Otherwise, call the next middleware and parse
    // the member's data. THEN render the page.
    req.member.data = data;
    next();
  });
}, function(req, res, next) {
  req.member.parsedData = parseMemberData(req.member.data);
  next();
});

app.get('/bananas', function(req, res, next) {
  renderBananas(req.member);
});

In diesem Beispiel befindet sich jede Middleware-Funktion entweder in einer eigenen Datei oder in einer anderen Stelle in der Datei, sodass sie in anderen Routen wiederverwendet werden kann.

Fehlerbehandlung

Grundlegende Dokumente finden Sie hier

app.get('/path/:id(\\d+)', function (req, res, next) { // please note: "next" is passed
    if (req.params.id == 0) // validate param
        return next(new Error('Id is 0')); // go to first Error handler, see below

    // Catch error on sync operation
    var data;
    try {
        data = JSON.parse('/file.json');
    } catch (err) {
        return next(err);
    }

    // If some critical error then stop application
    if (!data)
        throw new Error('Smth wrong');

    // If you need send extra info to Error handler
    // then send custom error (see Appendix B)
    if (smth)
        next(new MyError('smth wrong', arg1, arg2))

    // Finish request by res.render or res.end
    res.status(200).end('OK');
});    

// Be sure: order of app.use have matter
// Error handler
app.use(function(err, req, res, next)) {
    if (smth-check, e.g. req.url != 'POST') 
        return next(err); // go-to Error handler 2.

    console.log(req.url, err.message);

    if (req.xhr) // if req via ajax then send json else render error-page
        res.json(err);
    else 
        res.render('error.html', {error: err.message});  
});

// Error handler 2
app.use(function(err, req, res, next)) {
    // do smth here e.g. check that error is MyError
    if (err instanceof MyError) {
        console.log(err.message, err.arg1, err.arg2);
    }     
    ...
    res.end();
});

Anhang A

// "In Express, 404 responses are not the result of an error, 
// so the error-handler middleware will not capture them." 
// You can change it.
app.use(function(req, res, next) {
    next(new Error(404)); 
});

Anhang B

// How to define custom error
var util = require('util');
...
function MyError(message, arg1, arg2) {
    this.message = message;
    this.arg1 = arg1;
    this.arg2 = arg2;
    Error.captureStackTrace(this, MyError);
}
util.inherits(MyError, Error);
MyError.prototype.name = 'MyError';

Hook: Wie wird Code vor einer Anforderung und nach einer Res ausgeführt?

app.use() und Middleware für „vor“ und eine Kombination der verwendet werden schließen und beenden Ereignisse kann für „nach“ verwendet werden.

app.use(function (req, res, next) {
    function afterResponse() {
        res.removeListener('finish', afterResponse);
        res.removeListener('close', afterResponse);

        // actions after response
    }
    res.on('finish', afterResponse);
    res.on('close', afterResponse);

    // action before request
    // eventually calling `next()`
    next();
});
...
app.use(app.router);

Ein Beispiel dafür ist die Logger- Middleware, die standardmäßig nach der Antwort an das Protokoll angehängt wird.

app.router nur sicher, dass diese "Middleware" vor dem app.router da die Reihenfolge von Bedeutung ist.

---

Ursprünglicher Beitrag ist hier

POST-Anfragen bearbeiten

Genau wie Sie Get-Anforderungen in Express mit der app.get-Methode abwickeln, können Sie die app.post-Methode verwenden, um Post-Anforderungen zu bearbeiten.

Bevor Sie jedoch mit POST-Anforderungen umgehen können, müssen Sie die body-parser Middleware verwenden. Es analysiert einfach den Hauptteil von POST , PUT , DELETE und anderen Anforderungen.

Body-Parser Middleware analysiert den Hauptteil der Anforderung und req.body sie in ein in req.body verfügbares Objekt req.body

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

const express = require('express');

const app = express();

// Parses the body for POST, PUT, DELETE, etc.
app.use(bodyParser.json());

app.use(bodyParser.urlencoded({ extended: true }));

app.post('/post-data-here', function(req, res, next){

    console.log(req.body); // req.body contains the parsed body of the request.

});

app.listen(8080, 'localhost');

Cookies mit Cookie-Parser setzen

Im Folgenden finden Sie ein Beispiel für das Setzen und Lesen von Cookies mithilfe des Cookie-Parser- Moduls:

var express = require('express');
var cookieParser = require('cookie-parser'); // module for parsing cookies
var app = express();
app.use(cookieParser());

app.get('/setcookie', function(req, res){
    // setting cookies
    res.cookie('username', 'john doe', { maxAge: 900000, httpOnly: true });
    return res.send('Cookie has been set');
});

app.get('/getcookie', function(req, res) {
    var username = req.cookies['username'];
    if (username) {
        return res.send(username);        
    }

    return res.send('No cookie found');
});

app.listen(3000);

Benutzerdefinierte Middleware in Express

In Express können Sie Middlewares definieren, die zum Überprüfen von Anforderungen oder zum Setzen einiger Header als Antwort verwendet werden können.

app.use(function(req, res, next){ });    // signature

Beispiel

Der folgende Code fügt user zum Anforderungsobjekt hinzu und übergibt das Steuerelement an die nächste übereinstimmende Route.

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

//each request will pass through it
app.use(function(req, res, next){
    req.user = 'testuser';
    next();    // it will pass the control to next matching route
});

app.get('/', function(req, res){
    var user = req.user;
    console.log(user); // testuser
    return res.send(user);
});

app.listen(3000);

Fehlerbehandlung in Express

In Express können Sie einen einheitlichen Fehlerhandler für die Behandlung von Fehlern definieren, die in der Anwendung aufgetreten sind. Definieren Sie dann den Handler am Ende aller Routen und des Logikcodes.

Beispiel

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

//GET /names/john
app.get('/names/:name', function(req, res, next){
    if (req.params.name == 'john'){
        return res.send('Valid Name');
    } else{
        next(new Error('Not valid name'));    //pass to error handler
    }
});

//error handler
app.use(function(err, req, res, next){
    console.log(err.stack);    // e.g., Not valid name
    return res.status(500).send('Internal Server Occured');
});

app.listen(3000);

Middleware hinzufügen

Middleware-Funktionen sind Funktionen, die Zugriff auf das Anforderungsobjekt (req), das Antwortobjekt (res) und die nächste Middleware-Funktion im Request-Response-Zyklus der Anwendung haben.

Middleware-Funktionen können beliebigen Code ausführen, Änderungen an res und req Objekten vornehmen, den Antwortzyklus beenden und die nächste Middleware aufrufen.

Ein bekanntes Beispiel für Middleware ist das cors Modul. Um die CORS-Unterstützung hinzuzufügen, installieren Sie sie einfach, fordern Sie sie an und setzen Sie diese Zeile ein:

app.use(cors());

vor irgendwelchen Routern oder Routing-Funktionen.

Hallo Welt

Hier erstellen wir einen einfachen Hallo-Welt-Server mit Express. Routen:

• '/'
• '/ wiki'

Und für den Rest gibt "404", dh Seite nicht gefunden.

'use strict';

const port = process.env.PORT || 3000;

var app = require('express')();
    app.listen(port);

app.get('/',(req,res)=>res.send('HelloWorld!'));
app.get('/wiki',(req,res)=>res.send('This is wiki page.'));
app.use((req,res)=>res.send('404-PageNotFound'));

Hinweis: Wir haben 404-Route als letzte Route festgelegt, da Express-Routen in Reihenfolge stapelbar sind und für jede Anforderung nacheinander verarbeitet werden.