Node.js
Webb-appar med express

Introduktion

Syntax

• app.get (sökväg [, mellanprogram], återuppringning [, återuppringning ...])
• app.put (sökväg [, mellanprogram], återuppringning [, återuppringning ...])
• app.post (sökväg [, mellanprogram], återuppringning [, återuppringning ...])
• app ['delete'] (sökväg [, middleware], callback [, callback ...])
• app.use (sökväg [, mellanprogram], återuppringning [, återuppringning ...])
• app.use (återuppringning)

parametrar

Komma igång

Du måste först skapa en katalog, komma åt den i ditt skal och installera Express med npm genom att köra npm install express --save

Skapa en fil och namnge den app.js och lägg till följande kod som skapar en ny Express-server och lägger till en slutpunkt ( /ping ) med app.get metoden:

const express = require('express');

const app = express();

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

app.listen(8080, 'localhost');

För att köra ditt skript använder du följande kommando i ditt skal:

> node app.js

Din ansökan accepterar anslutningar på localhost-port 8080. Om värdnamnsargumentet till app.listen utelämnas accepterar servern anslutningar på maskinens IP-adress och localhost. Om portvärdet är 0 tilldelar operativsystemet en tillgänglig port.

När ditt skript körs kan du testa det i ett skal för att bekräfta att du får det förväntade svaret "pong" från servern:

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

Du kan också öppna en webbläsare, navigera till url http: // localhost: 8080 / ping för att se utgången

Grundläggande dirigering

Skapa först en expressapp:

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

Då kan du definiera sådana rutter:

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

Den strukturen fungerar för alla HTTP-metoder och förväntar sig en sökväg som det första argumentet, och en hanterare för den sökvägen, som tar emot begäran och svarobjekt. Så för de grundläggande HTTP-metoderna är det dessa rutter

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

Du kan kontrollera den fullständiga listan med stödda verb här . Om du vill definiera samma beteende för en rutt och alla HTTP-metoder kan du använda:

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

eller

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

eller

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

// * wildcard will route for all paths

Du kan kedja dina ruttdefinitioner för en enda sökväg

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

Du kan också lägga till funktioner till valfri HTTP-metod. De kommer att köras före den sista återuppringningen och tar parametrarna (req, res, nästa) som argument.

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

Dina slutliga återuppringningar kan lagras i en extern fil för att undvika att sätta för mycket kod i en fil:

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

Och sedan i filen som innehåller dina rutter:

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

Detta kommer att göra din kod mycket renare.

Få information från begäran

För att få information från den begärande webbadressen (märk att req är förfrågningsobjektet i hanterarfunktionen för rutter). Tänk på den här ruttdefinitionen /settings/:user_id och det här exemplet /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'

Du kan också få rubriker på begäran som den här

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

För att förenkla att få annan information kan du använda mellersta delar. Till exempel, för att få kroppsinfo om begäran, kan du använda body-parser middleware, som förvandlar råa begäran till användbart 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

Antag nu en begäran som den här

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

Du kan komma åt det publicerade namnet så här

req.body.name
// "Peter"

På liknande sätt kan du få åtkomst till kakor från begäran, du behöver också ett mellanprogram som cookie-parser

req.cookies.name

Modulär expressapplikation

Så här gör du routerfabriker för modulär användning av Express-webbapplikationer:

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

Ansökan:

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

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

Detta gör din applikation modulär, anpassningsbar och din kod kan återanvändas.

När du öppnar http://<hostname>:8080/api/v1/greet kommer utgången att vara Hello world

Mer komplicerat exempel

Exempel med tjänster som visar medelvarufördelar.

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

Ansökan:

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

När du öppnar http://<hostname>:8080/api/v1/service1/greet?name=World kommer utgången att vara Hello, World och komma åt http://<hostname>:8080/api/v1/service2/greet?name=World utgången blir Hi, World .

Med hjälp av en mallmotor

Med hjälp av en mallmotor

Följande kod ställer in Jade som mallmotor. (Obs: Jade har bytt namn till pug från och med december 2015.)

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

På liknande sätt kan andra mallmotorer användas för t.ex. Handlebars ( hbs ) eller ejs . Kom ihåg att npm install . För styret använder vi hbs paket, för Jade har vi ett jade paket och för EJS, vi har ett ejs paket.

Exempel på EJS-mall

Med EJS (som andra expressmallar) kan du köra serverkod och få åtkomst till dina servervariabler från din HTML.
I EJS görs det med " <% " som starttagg och " %> " som sluttagg, variabler som passeras som renderingsparam kan nås med <%=var_name%>
Om du till exempel har leveransmatris i din serverkod
du kan slinga över det med

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

Som ni kan se i exemplet varje gång du växlar mellan serversidan kod och HTML måste du stänga den aktuella EJS taggen och öppna ett nytt senare, här ville vi skapa li inuti for kommandot så vi behövde för att avsluta vår EJS tag i slutet av for och skapa en ny tagg bara för de lockiga parenteserna
ett annat exempel
om vi vill lägga in standardversion för inmatning som en variabel från serversidan använder vi <%=
till exempel:

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

Här är meddelandevariabeln som skickas från din serversida standardvärdet för din inmatning. Observera att om du inte skickade meddelandevariabeln från din serversida kommer EJS att kasta ett undantag. Du kan skicka parametrar med hjälp av res.render('index', {message: message}); (för ejs-fil som heter index.ejs).

I EJS-taggarna kan du också använda if , while eller något annat javascript-kommando du vill ha.

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

På http://localhost:8080/ output-objekt

{
    string_value: "StackOverflow",
    number_value: 8476
}

Serverar statiska filer

När du bygger en webbserver med Express krävs det ofta en kombination av dynamiskt innehåll och statiska filer.

Till exempel kan du ha index.html och script.js som är statiska filer som finns i filsystemet.

Det är vanligt att använda mapp som heter 'public' för att ha statiska filer. I detta fall kan mappstrukturen se ut:

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

Så här konfigurerar Express för att visa statiska filer:

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

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

Obs: när mappen har konfigurerats kommer index.html, script.js och alla filerna i mappen "public" att vara tillgängliga på root-banan (du får inte ange /public/ i url). Detta beror på att express letar efter filerna relativt den statiska mappen som är konfigurerad. Du kan ange virtuellt sökprefix som visas nedan:

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

kommer att göra resurserna tillgängliga under /static/ prefixet.

Flera mappar

Det är möjligt att definiera flera mappar samtidigt:

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

Vid servering av resurserna kommer Express att undersöka mappen i definitionsordning. För filer med samma namn kommer den i den första matchande mappen att serveras.

Namngivna rutter i Django-stil

Ett stort problem är att värdefulla namngivna rutter inte stöds av Express utanför rutan. Lösning är att installera paket som stöds av tredje part, till exempel express-reverse :

npm install express-reverse

Anslut det till ditt projekt:

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

Använd det sedan som:

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

Nackdelen med detta tillvägagångssätt är att du inte kan använda route Express-modulen som visas i avancerad routeranvändning . Lösningen är att skicka din app som en parameter till din routerfabrik:

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

Och använd det som:

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

Du kan räkna ut det från och med nu, hur definiera funktioner för att slå samman den med specificerade anpassade namnutrymmen och peka på lämpliga kontroller.

Felhantering

Grundläggande felhantering

Som standard letar Express efter en "fel" -vy i katalogen /views ska visas. Skapa helt enkelt "fel" -vyn och placera den i visningskatalogen för att hantera fel. Fel skrivs med felmeddelandet, status och stapelspår, till exempel:

visningar / error.pug

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

Avancerad felhantering

Definiera dina felhanterande middleware-funktioner i slutet av middleware-funktionsstacken. Dessa har fyra argument istället för tre (err, req, res, next) till exempel:

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

Du kan definiera flera felhanterande mellanvarufunktioner, precis som med vanliga mellanvarufunktioner.

Med hjälp av mellanprogram och nästa återuppringning

Express skickar en next återuppringning till varje rutthanterare och mellanprogramvarufunktion som kan användas för att bryta logiken för enstaka rutter över flera hanterare. Genom att ringa next() utan argument berättar express att fortsätta till nästa matchande mellanprogram eller rutthanterare. Att ringa next(err) med ett fel utlöser alla felhanterare mellanprogram. Om du ringer next('route') kommer du att förbigå eventuella efterföljande mellanprogram på den aktuella rutten och hoppa till nästa matchande rutt. Detta gör att domänlogik kan kopplas bort till återanvändbara komponenter som är fristående, enklare att testa och lättare att underhålla och ändra.

Flera matchande rutter

Förfrågningar till /api/foo eller till /api/bar kör den initiala hanteraren för att slå upp medlemmet och sedan överföra kontrollen till den faktiska hanteraren för varje rutt.

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

Felhanterare

Felhanterare är mellanprogram med signaturfunktionen function(err, req, res, next) . De kan ställas in per rutt (t.ex. app.get('/foo', function(err, req, res, next) ) men vanligtvis är en enda felhanterare som gör en felsida tillräcklig.

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

middle~~POS=TRUNC

Var och en av funktionerna ovan är faktiskt en mellanvarufunktion som körs när en begäran matchar den definierade rutten, men valfritt antal mellanprogramvarufunktioner kan definieras på en enda rutt. Detta gör att mellanprogram kan definieras i separata filer och gemensam logik kan återanvändas på flera rutter.

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

I det här exemplet skulle varje mellanprogramvara antingen vara i sin egen fil eller i en variabel någon annanstans i filen så att den kan återanvändas på andra rutter.

Felhantering

Grundläggande dokument kan hittas här

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

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

Bilaga 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: Hur man kör koden innan alla frågor och efter någon res

app.use() och mellanprogram kan användas för "före" och en kombination av när- och sluthändelserna kan användas för "efter".

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

Ett exempel på detta är loggerns mellanprogram, som kommer att läggas till loggen efter svaret som standard.

app.router bara till att det här "mellanprogrammet" används innan app.router eftersom ordning spelar roll.

---

Det ursprungliga inlägget är här

Hantera POST-förfrågningar

Precis som om du hanterar få förfrågningar i Express med app.get-metoden kan du använda app.post-metoden för att hantera inläggsförfrågningar.

Men innan du kan hantera POST-förfrågningar måste du använda body-parser middleware. Det analyserar helt enkelt kroppen av POST , PUT , DELETE och andra förfrågningar.

Body-Parser middleware analyserar kroppen på begäran och förvandlar den till ett objekt som finns tillgängligt i 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');

Ställer in kakor med cookie-parser

Följande är ett exempel för inställning och läsning av kakor med cookie-parser- modulen:

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

Anpassad mellanprogram i Express

I Express kan du definiera mellanslag som kan användas för att kontrollera förfrågningar eller ställa in några rubriker som svar.

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

Exempel

Följande kod lägger till user till förfrågningsobjektet och skickar kontrollen till nästa matchande rutt.

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

Felhantering i Express

I Express kan du definiera en enhetlig felhanterare för hanteringsfel som uppstod i applikationen. Definiera sedan hanteraren i slutet av alla rutter och logikkod.

Exempel

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

Lägga till Middleware

Middleware-funktioner är funktioner som har åtkomst till begäranobjektet (req), svarobjektet (res) och nästa mellanvarufunktion i programmets begäran-svarcykel.

Middleware-funktioner kan utföra valfri kod, göra ändringar i res och req objekt, avsluta svarscykel och ringa nästa middleware.

Mycket vanligt exempel på mellanprogram är cors modulen. För att lägga till CORS-support, installerar du det bara, kräver det och sätter denna rad:

app.use(cors());

innan några routrar eller routingsfunktioner.

Hej världen

Här skapar vi en grundläggande hej världsserver med Express. rutter:

• '/'
• '/ Wiki'

Och för vila ger "404", dvs. sidan inte hittad.

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

Obs: Vi har lagt 404-rutten som den sista rutten som Express staplar rutter i ordning och behandlar dem för varje begäran i följd.