Node.js
Aplikacje internetowe z Express

Wprowadzenie

Składnia

• app.get (ścieżka [, oprogramowanie pośrednie], callback [, callback ...])
• app.put (ścieżka [, oprogramowanie pośrednie], callback [, callback ...])
• app.post (ścieżka [, oprogramowanie pośrednie], callback [, callback ...])
• aplikacja [„usuń”] (ścieżka [, oprogramowanie pośrednie], oddzwonienie [, oddzwonienie ...])
• app.use (ścieżka [, oprogramowanie pośrednie], callback [, callback ...])
• app.use (oddzwanianie)

Parametry

Pierwsze kroki

Najpierw musisz utworzyć katalog, uzyskać do niego dostęp w powłoce i zainstalować Express za pomocą npm , uruchamiając npm install express --save

Utwórz plik i nazwij go app.js i dodaj następujący kod, który tworzy nowy serwer Express i dodaje do niego jeden punkt końcowy ( /ping ) za pomocą metody app.get :

const express = require('express');

const app = express();

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

app.listen(8080, 'localhost');

Aby uruchomić skrypt, użyj następującego polecenia w powłoce:

> node app.js

Twoja aplikacja zaakceptuje połączenia na porcie 80 hosta lokalnego. Jeśli argument nazwy hosta do app.listen zostanie pominięty, serwer zaakceptuje połączenia zarówno na adresie IP komputera, jak i na lokalnym hoście. Jeśli wartość portu wynosi 0, system operacyjny przypisze dostępny port.

Po uruchomieniu skryptu możesz przetestować go w powłoce, aby potwierdzić, że otrzymujesz oczekiwaną odpowiedź „pong” z serwera:

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

Możesz także otworzyć przeglądarkę internetową, przejść do adresu URL http: // localhost: 8080 / ping, aby wyświetlić dane wyjściowe

Podstawowy routing

Najpierw utwórz ekspresową aplikację:

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

Następnie możesz zdefiniować trasy w następujący sposób:

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

Ta struktura działa dla wszystkich metod HTTP i oczekuje ścieżki jako pierwszego argumentu oraz procedury obsługi tej ścieżki, która odbiera obiekty żądania i odpowiedzi. Tak więc dla podstawowych metod HTTP są to trasy

// 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) {})

Możesz sprawdzić pełną listę obsługiwanych czasowników tutaj . Jeśli chcesz zdefiniować to samo zachowanie dla trasy i wszystkich metod HTTP, możesz użyć:

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

lub

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

lub

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

// * wildcard will route for all paths

Możesz połączyć definicje tras w jedną ścieżkę

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

Możesz także dodawać funkcje do dowolnej metody HTTP. Będą działać przed ostatnim wywołaniem zwrotnym i przyjmą parametry (req, res, next) jako argumenty.

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

Ostateczne wywołania zwrotne można zapisać w pliku zewnętrznym, aby uniknąć umieszczenia zbyt dużej ilości kodu w jednym pliku:

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

A następnie w pliku zawierającym trasy:

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

Dzięki temu Twój kod będzie znacznie czystszy.

Uzyskiwanie informacji z zapytania

Aby uzyskać informacje z żądającego adresu URL (zwróć uwagę, że req jest obiektem żądania w funkcji obsługi tras). Rozważ tę definicję trasy /settings/:user_id i ten konkretny przykład /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'

Możesz także uzyskać nagłówki żądania, takie jak to

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

Aby uprościć uzyskiwanie innych informacji, możesz użyć oprogramowania pośredniego. Na przykład, aby uzyskać informacje o treści żądania, można użyć oprogramowania pośredniego body-parsera , które przekształci surowe treści żądania w użyteczny format.

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

Załóżmy teraz, że taka prośba

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

Możesz uzyskać dostęp do opublikowanej nazwy w ten sposób

req.body.name
// "Peter"

W podobny sposób możesz uzyskać dostęp do plików cookie z żądania, potrzebujesz również oprogramowania pośredniego, takiego jak parser plików cookie

req.cookies.name

Modułowa aplikacja ekspresowa

Aby modułowa aplikacja ekspresowa była modułowa, użyj fabryk routerów:

Moduł:

// 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;
};

Podanie:

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

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

To sprawi, że twoja aplikacja będzie modułowa, dostosowywalna i twój kod będzie można ponownie wykorzystać.

Podczas uzyskiwania dostępu do http://<hostname>:8080/api/v1/greet wyjściem będzie Hello world

Bardziej skomplikowany przykład

Przykład z usługami pokazującymi zalety fabryki oprogramowania pośredniego.

Moduł:

// 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;
};

Podanie:

// 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);

Podczas uzyskiwania dostępu do http://<hostname>:8080/api/v1/service1/greet?name=World wyjście będzie Hello, World i uzyskiwanie dostępu do http://<hostname>:8080/api/v1/service2/greet?name=World http://<hostname>:8080/api/v1/service1/greet?name=World http://<hostname>:8080/api/v1/service2/greet?name=World wynikiem będzie Hi, World .

Korzystanie z silnika szablonów

Korzystanie z silnika szablonów

Poniższy kod skonfiguruje Jade jako silnik szablonów. (Uwaga: Jade przemianowano na pug od grudnia 2015 r.)

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));
    }
});

Również inne typy silników szablonów mogą być stosowane także takie jak Handlebars ( hbs ) lub ejs . Pamiętaj, aby npm install silnik szablonów. Do kierownic używamy pakietu hbs , dla Jade mamy pakiet jade , a dla EJS pakiet ejs .

Przykład szablonu EJS

Dzięki EJS (podobnie jak innym ekspresowym szablonom) możesz uruchamiać kod serwera i uzyskiwać dostęp do zmiennych serwera z poziomu HTML.
W EJS odbywa się to za pomocą „ <% ” jako znacznika początkowego i „ %> ” jako znacznika końcowego, zmienne przekazane jako parametry renderowania można uzyskać za pomocą <%=var_name%>
Na przykład, jeśli masz tablicę materiałów eksploatacyjnych w kodzie serwera
możesz go zapętlić za pomocą

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

Jak widać w przykładzie za każdym razem, gdy przełączasz się między kodem po stronie serwera a kodem HTML, musisz zamknąć bieżący znacznik EJS i otworzyć nowy później, tutaj chcieliśmy utworzyć li wewnątrz polecenia for więc musieliśmy zamknąć nasz znacznik EJS na końcu for i utwórz nowy tag tylko dla nawiasów klamrowych
inny przykład
jeśli chcemy ustawić domyślną wersję wejściową jako zmienną po stronie serwera, używamy <%=
na przykład:

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

Tutaj zmienna komunikatu przekazywana ze strony serwera będzie domyślną wartością danych wejściowych, należy zauważyć, że jeśli nie przekazałeś zmiennej wiadomości ze strony serwera, EJS zgłosi wyjątek. Możesz przekazać parametry za pomocą res.render('index', {message: message}); (dla pliku ejs o nazwie index.ejs).

W tagach EJS możesz także użyć if , while lub dowolnego innego polecenia javascript.

JSON API z 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)
})

Na http://localhost:8080/ obiekt wyjściowy

{
    string_value: "StackOverflow",
    number_value: 8476
}

Udostępnianie plików statycznych

Podczas budowania serwera WWW za pomocą Express często wymagane jest połączenie kombinacji zawartości dynamicznej i plików statycznych.

Na przykład możesz mieć index.html i script.js, które są plikami statycznymi przechowywanymi w systemie plików.

Często używa się folderu o nazwie „public”, aby mieć pliki statyczne. W takim przypadku struktura folderów może wyglądać następująco:

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

Oto jak skonfigurować Express do obsługi plików statycznych:

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

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

Uwaga: po skonfigurowaniu folderu, index.html, script.js i wszystkie pliki w folderze „publicznym” będą dostępne w ścieżce katalogu głównego (nie możesz podać /public/ w adresie URL). Wynika to z tego, że express szuka plików względem skonfigurowanego folderu statycznego. Możesz określić wirtualny prefiks ścieżki, jak pokazano poniżej:

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

udostępni zasoby pod prefiksem /static/ .

Wiele folderów

Możliwe jest zdefiniowanie wielu folderów jednocześnie:

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

Podczas obsługi zasobów Express sprawdzi folder w kolejności definicji. W przypadku plików o tej samej nazwie zostanie wyświetlony ten z pierwszego pasującego folderu.

Nazwane trasy w stylu Django

Jednym z dużych problemów jest to, że cenne nazwane trasy nie są obsługiwane przez Express po wyjęciu z pudełka. Rozwiązaniem jest zainstalowanie obsługiwanego pakietu innej firmy, na przykład express-reverse :

npm install express-reverse

Podłącz go do swojego projektu:

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

Następnie użyj go w następujący sposób:

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

Minusem tego podejścia jest to, że nie można użyć modułu route Express, jak pokazano w Zaawansowanym użyciu routera . Obejściem tego problemu jest przekazanie app jako parametru do fabryki routerów:

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

I używaj go w następujący sposób:

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

Możesz dowiedzieć się odtąd, jak definiować funkcje, aby połączyć je z określonymi niestandardowymi przestrzeniami nazw i wskazywać odpowiednie kontrolery.

Obsługa błędów

Podstawowa obsługa błędów

Domyślnie Express wyszuka widok „błędu” w katalogu /views do renderowania. Wystarczy utworzyć widok „błędu” i umieścić go w katalogu views, aby obsłużyć błędy. Błędy są zapisywane z komunikatem o błędzie, statusem i śledzeniem stosu, na przykład:

views / error.pug

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

Zaawansowana obsługa błędów

Zdefiniuj funkcje pośredniczące obsługi błędów na samym końcu stosu funkcji oprogramowania pośredniego. Mają cztery argumenty zamiast trzech (err, req, res, next) na przykład:

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
    });
});

Można zdefiniować kilka funkcji oprogramowania pośredniego obsługujących błędy, tak jak w przypadku zwykłych funkcji oprogramowania pośredniego.

Korzystanie z oprogramowania pośredniego i następnego oddzwaniania

Express przekazuje next wywołanie zwrotne do każdej funkcji obsługi trasy i funkcji oprogramowania pośredniego, których można użyć do złamania logiki dla pojedynczych tras w wielu modułach obsługi. Wywołanie next() bez argumentów każe ekspresowi przejść do następnego pasującego oprogramowania pośredniego lub procedury obsługi trasy. Wywołanie next(err) z błędem spowoduje wywołanie oprogramowania pośredniego obsługi błędów. Wywołanie next('route') ominie kolejne oprogramowanie pośrednie na bieżącej trasie i przejdzie do następnej pasującej trasy. Pozwala to na rozdzielenie logiki domeny na komponenty wielokrotnego użytku, które są samodzielne, prostsze w testowaniu oraz łatwiejsze w utrzymaniu i zmianie.

Wiele pasujących tras

Żądania do /api/foo lub do /api/bar uruchomią początkowy moduł obsługi w celu wyszukania elementu, a następnie przekażą kontrolę rzeczywistemu modułowi obsługi dla każdej trasy.

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);
});

Obsługa błędów

Programy obsługi błędów to oprogramowanie pośrednie z function(err, req, res, next) podpisu function(err, req, res, next) . Można je skonfigurować dla każdej trasy (np. app.get('/foo', function(err, req, res, next) ), ale zazwyczaj wystarczy jedna procedura obsługi błędów, która wyświetla stronę błędu.

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

Każda z powyższych funkcji jest w rzeczywistości funkcją oprogramowania pośredniego, która jest uruchamiana za każdym razem, gdy żądanie odpowiada zdefiniowanej trasie, ale dowolną liczbę funkcji oprogramowania pośredniego można zdefiniować na jednej trasie. Pozwala to na zdefiniowanie oprogramowania pośredniego w osobnych plikach i ponowne użycie wspólnej logiki na wielu trasach.

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);
});

W tym przykładzie każda funkcja oprogramowania pośredniego znajdowałaby się we własnym pliku lub w zmiennej w innym miejscu pliku, aby można ją było ponownie wykorzystać na innych trasach.

Obsługa błędów

Podstawowe dokumenty można znaleźć tutaj

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();
});

załącznik 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)); 
});

Załącznik 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: Jak wykonać kod przed każdym wymaganiem i po jakimkolwiek res

app.use() i oprogramowanie pośrednie mogą być używane do „przed”, a kombinacja zdarzeń zamykających i kończących może być używana do „po”.

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);

Przykładem tego jest oprogramowanie pośredniczące rejestratora , które domyślnie dołącza się do dziennika po odpowiedzi.

Upewnij się tylko, że to „oprogramowanie pośrednie” jest używane przed app.router ponieważ kolejność ma znaczenie.

---

Oryginalny post jest tutaj

Obsługa żądań POST

Podobnie do obsługi żądań pobierania w Express za pomocą metody app.get, możesz używać metody app.post do obsługi żądań postów.

Ale zanim będzie można obsłużyć żądania POST, należy użyć oprogramowania pośredniego body-parser . Po prostu analizuje treść POST , PUT , DELETE i innych żądań.

Body-Parser pośrednie Body-Parser analizuje req.body żądania i zamienia go w obiekt dostępny w 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');

Ustawianie plików cookie za pomocą parsera plików cookie

Poniżej przedstawiono przykład ustawiania i odczytywania plików cookie za pomocą modułu analizatora plików cookie :

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);

Niestandardowe oprogramowanie pośrednie w programie Express

W programie Express można zdefiniować oprogramowanie pośrednie, które może być używane do sprawdzania żądań lub ustawiania niektórych nagłówków w odpowiedzi.

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

Przykład

Poniższy kod dodaje user do obiektu żądania i przekazuje formant do następnej pasującej trasy.

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);

Obsługa błędów w Express

W programie Express można zdefiniować ujednoliconą procedurę obsługi błędów w celu obsługi błędów występujących w aplikacji. Zdefiniuj następnie moduł obsługi na końcu wszystkich tras i kodu logicznego.

Przykład

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);

Dodawanie oprogramowania pośredniego

Funkcje oprogramowania pośredniego to funkcje, które mają dostęp do obiektu żądania (req), obiektu odpowiedzi (res) i następnej funkcji oprogramowania pośredniego w cyklu żądania i odpowiedzi aplikacji.

Funkcje oprogramowania pośredniego mogą wykonywać dowolny kod, wprowadzać zmiany w obiektach res i req , kończyć cykl odpowiedzi i wywoływać następne oprogramowanie pośrednie.

Bardzo częstym przykładem oprogramowania pośredniego jest moduł cors . Aby dodać obsługę CORS, po prostu zainstaluj ją, wymagaj i wstaw następujący wiersz:

app.use(cors());

przed wszelkimi routerami lub funkcjami routingu.

Witaj świecie

Tutaj tworzymy podstawowy serwer hello world za pomocą Express. Trasy:

• „/”
• „/ wiki”

A dla reszty da „404”, tzn. Nie znaleziono strony.

'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'));

Uwaga: umieściliśmy trasę 404 jako ostatnią trasę, ponieważ Express układa trasy w kolejności i przetwarza je kolejno dla każdego żądania.