Tento dokument m├┤┼że by┼ą v porovnan├ş s dokument├íciou v angli─Źtine zastaral├Ż. Aktu├ílne inform├ície n├íjdete v dokument├ícii v angli─Źtine.

Ôťľ

Pou┼żitie middleware

Express je webov├Ż framework s minim├ílnou vlastnou funkcionalitou: Express aplik├ícia je v podstate s├ęria volan├ş middleware funkci├ş.

Middleware funkcie s├║ funkcie, ktor├ę maj├║ pr├şstup k request objektu (req), response objektu (res) a nasleduj├║cej middleware funkcii v request-response cykle aplik├ície. Nasleduj├║ca middleware funkcia v porad├ş je be┼żne ozna─Źovan├í premennou next.

Middleware funkcie dok├í┼żu vykon├íva┼ą nasleduj├║ce ├║lohy:

Ak aktu├ílna middleware funkcia neukon─Źuje request-response cyklus, mus├ş posun├║┼ą obsluhu nasleduj├║cej middleware funkcii vyvolan├şm next(). V opa─Źnom pr├şpade zostane request ÔÇśvisie┼ąÔÇÖ.

Express aplik├ícia m├┤┼że pou┼żi┼ą nasledovn├ę typy middleware funkci├ş:

Application-level a router-level middleware m├┤┼żete na─Ź├şta┼ą s volite─żnou cestou (path-om). M├┤┼żete taktie┼ż na─Ź├şta┼ą skupinu middleware funkci├ş dohromady, ─Ź├şm vytvor├şte sub-stack middleware syst├ęm na danej ceste.

Application-level middleware

Pripojte application-level middleware k in┼ítancii app objektu pou┼żit├şm app.use() a app.METHOD() funkci├ş, kde METHOD je typicky HTTP met├│da requestu, ktor├Ż mddleware funkcia handluje (ako napr. GET, PUT, ─Źi POST) zap├şsan├í v lowercase form├íte.

Nasleduj├║ci pr├şklad ukazuje middleware funkciu, ktor├í nie je pripojen├í na ┼żiaden path. Funkcia bude vykonan├í v┼żdy, ke─Ć aplik├ícia obdr┼ż├ş request.


var app = express();

app.use(function (req, res, next) {
  console.log('Time:', Date.now());
  next();
});

Nasleduj├║ci pr├şklad ukazuje middleware funkciu pripojen├║ na ceste /user/:id. Funkcia bude vykonan├í v┼żdy, ke─Ć aplik├ícia odr┼ż├ş request na /user/:id a to bez oh─żadu na typ pou┼żitej HTTP met├│dy.


app.use('/user/:id', function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

Nasleduj├║ci pr├şklad ukazuje route a jej handler funkciu (middleware syst├ęm). T├íto funkcia handluje GET requesty na ceste /user/:id.


app.get('/user/:id', function (req, res, next) {
  res.send('USER');
});

Tu je pr├şklad na─Ź├ştania skupiny middleware funkci├ş pripojen├Żch na konkr├ętnu cesty. Pr├şklad ilustruje sub-stack middleware, ktor├Ż vyp├ş┼íe info o requeste pre v┼íetky typy HTTP requestov vykonan├Żch na /user/:id.


app.use('/user/:id', function(req, res, next) {
  console.log('Request URL:', req.originalUrl);
  next();
}, function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

Route handlery dovo─żuj├║ definova┼ą viacero route-ov pre jednu cestu. Nasleduj├║ci pr├şklad definuje dva routy pre GET requesty na ceste /user/:id. Definovanie druh├ęho route nesp├┤sob├ş ┼żiadne probl├ęmy, ale ani sa nikdy nezavol├í, preto┼że prv├Ż route ukon─Ź├ş request-response cyklus.

Tento pr├şklad zobrazuje middleware sub-stack ktor├Ż handluje GET requesty na ceste /user/:id.


app.get('/user/:id', function (req, res, next) {
  console.log('ID:', req.params.id);
  next();
}, function (req, res, next) {
  res.send('User Info');
});

// handler for the /user/:id path, which prints the user ID
app.get('/user/:id', function (req, res, next) {
  res.end(req.params.id);
});

Ak chcete presko─Źi┼ą zost├ívaj├║ce middleware funkcie z router middleware stack-u, zavolajte next('route') ─Ź├şm posuniete obsluhu ─Ćal┼íiemu route. POZN├üMKA: next('route') zafunguje iba v tak├Żch middleware funkci├ích, ktor├ę boli na─Ź├ştan├ę pomocou app.METHOD() alebo router.METHOD() funkci├ş.

Tento pr├şklad zobrazuje middleware sub-stack, ktor├Ż handluje GET requesty na ceste /user/:id.


app.get('/user/:id', function (req, res, next) {
  // if the user ID is 0, skip to the next route
  if (req.params.id == 0) next('route');
  // otherwise pass the control to the next middleware function in this stack
  else next(); //
}, function (req, res, next) {
  // render a regular page
  res.render('regular');
});

// handler for the /user/:id path, which renders a special page
app.get('/user/:id', function (req, res, next) {
  res.render('special');
});

Router-level middleware

Router-level middleware funguje rovnak├Żm sp├┤sobom ako application-level middleware, av┼íak je pripojen├Ż k express.Router() in┼ítancii.


var router = express.Router();

Router-level middleware na─Ź├ştate pomocou router.use() a router.METHOD() funkci├ş.

Nasleduj├║ci pr├şklad replikuje vy┼í┼íie zobrazen├Ż application-level middleware pou┼żit├şm router-level middlewaru:


var app = express();
var router = express.Router();

// a middleware function with no mount path. This code is executed for every request to the router
router.use(function (req, res, next) {
  console.log('Time:', Date.now());
  next();
});

// a middleware sub-stack shows request info for any type of HTTP request to the /user/:id path
router.use('/user/:id', function(req, res, next) {
  console.log('Request URL:', req.originalUrl);
  next();
}, function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

// a middleware sub-stack that handles GET requests to the /user/:id path
router.get('/user/:id', function (req, res, next) {
  // if the user ID is 0, skip to the next router
  if (req.params.id == 0) next('route');
  // otherwise pass control to the next middleware function in this stack
  else next(); //
}, function (req, res, next) {
  // render a regular page
  res.render('regular');
});

// handler for the /user/:id path, which renders a special page
router.get('/user/:id', function (req, res, next) {
  console.log(req.params.id);
  res.render('special');
});

// mount the router on the app
app.use('/', router);

Error-handling middleware

Error-handling middleware pr├şjma v┼żdy ┼ítyri argumenty. Aby bolo mo┼żn├ę identifikova┼ą error-handling middleware funkciu, mus├şte jej definova┼ą v┼żdy ┼ítyri argumenty. Mus├şte ho definova┼ą aj v situ├ícii, kedy nepotrebujete pou┼żi┼ą next objekt, aby ste dodr┼żali dohodnut├║ signat├║ru. V opa─Źnom pr├şpade bude next objekt interpretovan├Ż ako be┼żn├Ż middleware, ktor├Ż nedok├í┼że handlova┼ą errory.

Error-handling middleware funkcie sa definuj├║ rovnako ako ostatn├ę middleware funkcie, len maj├║ ┼ítyri argumenty namiesto troch, ┼ípecificky pod─ża signat├║ry (err, req, res, next):


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

Pre viac inform├íci├ş oh─żadom error-handling middlewarov si pozrite sekciu: Error handling.

Built-in middleware

Express po─Źn├║c od verzie 4.x nie je z├ívisl├Ż na Connect module. Okrem v├Żnimky express.static, v┼íetky predo┼íl├ę middleware funkcie p├┤vodne obsiahnut├ę v Express s├║ teraz samostatn├ę moduly. Zoznam middleware funkci├ş si pozrite tu.

Jedin├Żm vstavan├Żm middlewarom v Express je express.static funkcia. Tento middleware je zalo┼żen├Ż na serve-static module a je zodpovedn├Ż za servovanie statick├Żch assetov ako HTML s├║bory, obr├íky at─Ć.

Signat├║ra tejto funkcie je:


express.static(root, [options])

Parameter root ┼ípecifikuje hlavn├Ż adres├ír z ktor├ęho bude statick├Ż obsah servovan├Ż.

Inform├ície oh─żadom options parametra ako i ─Ćal┼íie detaily oh─żadom tohto middleware n├íjdete tu: express.static.

Tu je pr├şklad pou┼żitia express.static middleware funkcie s r├┤znou konfigur├íciou options objektu:


var options = {
  dotfiles: 'ignore',
  etag: false,
  extensions: ['htm', 'html'],
  index: false,
  maxAge: '1d',
  redirect: false,
  setHeaders: function (res, path, stat) {
    res.set('x-timestamp', Date.now());
  }
}

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

M├┤┼żete nastavi┼ą aj viac ako jeden prie─Źinok so statick├Żm obsahom:


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

Pre viac detailov oh─żadom serve-static funkcie a jej mo┼żnostiach si pozrite dokument├íciu k serve-static modulu.

Third-party middleware

V Express aplik├ícii mo┼żete vyu┼żi┼ą taktie┼ż third-party middleware funkcionalitu.

Nain┼ítalujte po┼żadovan├Ż Node.js modul a na─Ź├ştajte ho do aplik├ície ako aplika─Źn├Ż, ─Źi router middleware.

Nasleduj├║ci pr├şklad demon┼ítruje in┼ítal├íciu a na─Ź├ştanie middleware funkcie cookie-parser sl├║┼żiacej na pr├ícu s cookies.


$ npm install cookie-parser


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

// load the cookie-parsing middleware
app.use(cookieParser());

─îiasto─Źn├Ż zoznam be┼żne pou┼ż├şvan├Żch third-party middleware funkci├ş pre Express n├íjdete v sekcii: Third-party middleware.