$ npm install express

ili, da biste imali pristup ekspresnoj komandi, instalirajte globalno:

$ npm install -g express

Brzi početak

Najlakši način da počnete s Expressom je da pokrenete express naredbu, koja će generirati aplikaciju:

Kreiranje aplikacije:

$ npm install -g express $ express /tmp/foo && cd /tmp/foo

Instaliranje zavisnosti:

$ npm install -d

Pokretanje servera:

Kreiranje servera

Da biste kreirali instancu express.HTTPServera, jednostavno pozovite metodu createServer(). Sa našom instancom aplikacije, možemo specificirati rute zasnovane na HTTP metodama, u ovom primjeru app.get() .

var app = require("express").createServer(); app.get("/", function(req, res)(res.send("hello world"); )); app.listen(3000);

Kreiranje HTTPS servera

Da bismo inicijalizirali express.HTTPSServer , izvodimo iste korake kao gore, ali također prosljeđujemo objekt opcija koji sadrži ključ, certifikat i druge parametre koji su opisani u dokumentaciji NodeJS https modula.

var app = require("express").createServer(( ključ: ... ));

Konfiguracija

Express podržava proizvoljna okruženja, kao što su proizvodnja i razvoj. Programeri mogu koristiti metodu configure() za dodavanje funkcija potrebnih za dato okruženje. Kada se configure() pozove bez imena okruženja, aktivirat će se u bilo kojem okruženju prije nego što se pokrene bilo koja konfiguracija u kojoj je navedeno okruženje.

U primjeru ispod, jednostavno koristimo opciju dumpExceptions i, u razvojnom modu, odgovaramo klijentu sa praćenjem steka izuzetka. U oba načina koristimo slojeve methodOverride i bodyParser. Obratite pažnju na upotrebu app.router , koji sam po sebi omogućava montiranje ruta - inače se montiraju kada se prvi put pozovu app.get(), app.post() itd.

app.configure(function())( app.use(express.methodOverride()); app.use(express.bodyParser()); app.use(app.router); )); app.configure("development", function())( app.use(express.static(__dirname + "/public")); app.use(express.errorHandler(( dumpExceptions: true, showStack: true ))); ) ); app.configure("production", function())( var oneYear = 31557600000; app.use(express.static(__dirname + "/public", (maxAge: oneYear ))); app.use(express.errorHandler() ) ; ));

Za okruženja sa sličnim postavkama, možete proslijediti više naziva okruženja:

app.configure("stage", "prod", function())( // config ));

Za interne i proizvoljne postavke, Express ima metode set(key[, val]) , enable(key) , disable(key) :

app.configure(function () ( app.set("views", __dirname + "/views"); app.set("views"); // => "/absolute/path/to/views" app.enable ("neka karakteristika" // isto kao app.set("neka karakteristika", true)("neka karakteristika"); .enabled("neka karakteristika") // => false ));

Da bismo postavili okruženje, možemo postaviti varijablu okruženja NODE_ENV. Na primjer:

$ NODE_ENV=proizvodni čvor app.js

Ovo je vrlo važno jer su mnogi mehanizmi keširanja omogućeni samo u proizvodnom okruženju.

Postavke

Iz kutije Express podržava sljedeće postavke:

• home je osnovna putanja aplikacije, koja se koristi za res.redirect() kao i transparentnu podršku za montirane aplikacije.
• views je korijenski direktorij pogleda. Podrazumevano trenutni_folder/pregledi
• view engine - zadani predložak za preglede pozvane bez ekstenzije datoteke.
• opcije prikaza - objekat koji odražava opcije globalnog pogleda
• view cache - omogući keširanje pogleda (omogućeno u proizvodnom okruženju)
• Rute osjetljive na velika i mala slova - omogućite rute osjetljive na velika i mala slova
• striktno usmjeravanje - ako je omogućeno, zadnje kose crte se više ne zanemaruju
• jsonp povratni poziv - dozvoli metodu res.send() da transparentno podržava JSONP

Routing

Express koristi HTTP metode za pružanje smislenog, izražajnog API-ja za usmjeravanje. Na primjer, želimo da pretraga za /user/12 prikaže profil korisnika sa id=12. Da bismo to učinili, u nastavku definiramo rutu. Vrijednosti povezane s imenovanim poljima dostupne su u objektu res.params.

app.get("/user/:id", function(req, res)( res.send("user " + req.params.id); ));

Ruta je jednostavno niz koji se kompajlira u regularni izraz unutar motora. Na primjer, kada se kompajlira /user/:id, rezultat je regularni izraz poput ovog:

\/user\/([^\/]+)\/?

Takođe možete odmah proslijediti regularni izraz. Ali pošto grupe nisu imenovane u regularnim izrazima, do njih se može doći u req.params brojevima. Dakle, prva grupa ide u req.params, druga u req.params, itd.

app.get(/^\/users?(?:\/(\d+)(?:\.\.(\d+))?)?/, function(req, res)( res.send(req.params ); ));

Sada uzmimo curl i pošaljimo zahtjev na gornju rutu:

$ curl http://dev:3000/user $ curl http://dev:3000/users $ curl http://dev:3000/users/1 ["1",null] $ curl http://dev: 3000/users/1..15 ["1","15"]

Ispod su neki primjeri ruta i staza koje bi im mogle odgovarati:

"/user/:id" /user/12 "/users/:id?" /users/5 /users "/files/*" /files/jquery.js /files/javascripts/jquery.js "/file/*.*" /files/jquery.js /files/javascripts/jquery.js "/ user/:id/:operation?" /user/1 /user/1/edit "/products.:format" /products.json /products.xml "/products.:format?" /products.json /products.xml /products "/user/:id.:format?" /user/12 /user/12.json

Na primjer, možemo POST nešto JSON i odgovoriti sa istim JSON koristeći bodyParser sloj, koji može analizirati JSON zahtjev (kao i druge zahtjeve) i smjestiti odgovor u req.body:

var express = require("express"), app = express.createServer(); app.use(express.bodyParser()); app.post("/", function(req, res) (res.send(req.body); )); app.listen(3000);

Po pravilu koristimo „glupo“ polje (na primjer, /user/:id), koje nema ograničenja. Ali ako, na primjer, želimo ograničiti korisnički ID samo na numeričke znakove, možemo koristiti /user/:id(+) . Ova konstrukcija neće raditi ako vrijednost polja sadrži nenumeričke znakove.

Prenos kontrole na drugu rutu

Pozivanjem trećeg argumenta, next() , možete prenijeti kontrolu na sljedeću rutu. Ako se podudaranje ne pronađe, kontrola se vraća nazad na Connect i slojevi se nastavljaju pozivati ​​onim redoslijedom kojim su bili omogućeni korištenjem use() . Više ruta koje dijele istu stazu također funkcioniraju. Oni se jednostavno pozivaju jedan po jedan dok jedan od njih ne odgovori umjesto da pozove next().

app.get("/users/:id?", function(req, res, next) ( var id = req.params.id; if (id) ( // uradi nešto ) else ( next(); ) )) ; app.get("/users", function(req, res) ( // uradi nešto drugo));

Metoda app.all() je korisna ako želite da izvedete istu logiku za sve HTTP metode. U nastavku koristimo ovu metodu da preuzmemo korisnika iz baze podataka i dodijelimo ga req.user.

var express = require("express"), app = express.createServer(); var korisnici = [( ime: "tj" )]; app.all("/user/:id/:op?", function(req, res, next) (req.user = korisnici; if (req.user) ( next(); ) else ( next(new Error( "ne mogu pronaći korisnika " + req.params.id)); app.get("/user/:id", function(req, res) ( res.send("pregled " + req.user.name); )); app.get("/user/:id/edit", function(req, res) ( res.send("editing " + req.user.name); )); app.put("/user/:id", function(req, res) ( res.send("ažuriranje " + req.user.name); )); app.get("*", function(req, res) (res.send("šta???", 404); )); app.listen(3000);

Međuslojevi

Connect framework slojevi se mogu proslijediti express.createServer() na isti način kao da se koristi običan Connect server. Na primjer:

var express = require("express"); var app = express.createServer(express.logger(), express.bodyParser());

Možete koristiti i use(). Ovo čini pogodnijim dodavanje slojeva unutar configure() blokova, što je progresivnije.

app.use(express.logger(( format: ":method:url" )));

Obično sa Connect slojevima možemo povezati Connect na ovaj način:

var connect = require("connect"); app.use(connect.logger()); app.use(connect.bodyParser());

Ovo nije sasvim zgodno, pa Express ponovo izvozi Connect slojeve:

app.use(express.logger()); app.use(express.bodyParser());

Redoslijed slojeva je bitan. Dakle, kada Connect primi zahtjev, prvi sloj dodan preko createServer() ili use() se izvršava. Poziva se s tri parametra: zahtjevom, odgovorom i funkcijom povratnog poziva koja se obično poziva next. kada se pozove next(), kontrola se prenosi na drugi sloj, itd. Ovo je važno uzeti u obzir, jer mnogi slojevi zavise jedan od drugog. Na primjer, methodOverride() poziva req.body.method da preoptereti HTTP metodu, a bodyParser() analizira tijelo zahtjeva da ispuni req.body. Drugi primjer je raščlanjivanje kolačića i podrška za sesiju - prvo morate pozvati use() na cookieParser(), a zatim na session().

Mnoge Express aplikacije mogu imati liniju app.use(app.router) . Ovo može izgledati čudno, ali ovo je jednostavno da se eksplicitno navede sloj koji uključuje sve rute koje smo kreirali. Ovaj sloj se može uključiti bilo kojim redoslijedom, iako je po defaultu uključen na kraju. Promjenom njegove pozicije možete kontrolirati redoslijed njegovog izvršavanja. Na primjer, potreban nam je rukovalac greškama koji će se pokrenuti nakon svih ostalih slojeva i prikazati svaki izuzetak koji mu je proslijeđen pomoću next() . Ili će možda biti potrebno smanjiti redoslijed izvršavanja sloja koji opslužuje statičke datoteke kako bi se omogućilo drugim rutama da presretnu zahtjeve za takve datoteke i, na primjer, broje broj preuzimanja itd. Evo kako bi to moglo izgledati:

app.use(express.logger(...)); app.use(express.bodyParser(...)); app.use(express.cookieParser(...)); app.use(express.session(...)); app.use(app.router); app.use(express.static(...)); app.use(express.errorHandler(...));

Prvo dodajemo logger() - on će omotati metodu req.end() kako bi nam dao podatke o stopi odgovora. Zatim analiziramo tijelo zahtjeva (ako postoji), zatim kolačiće, pa sesiju, tako da je req.session već definirana kada dođemo do ruta u app.router . Ako, na primjer, GET zahtjevom za /javascripts/jquery.js rukuju rute i mi ne pozovemo next() , tada static() sloj nikada neće primiti taj zahtjev. Međutim, ako definiramo rutu kao što je prikazano u nastavku, bit će moguće bilježiti statistiku, odbijati preuzimanja, naplaćivati ​​preuzimanja itd.

var preuzimanja = (); app.use(app.router); app.use(express.static(__dirname + "/public")); app.get("/*", function(req, res, next) (var file = req.params; preuzimanja = preuzimanja || 0; preuzimanja++; next(); ));

Slojevite rute

Rute mogu koristiti slojeve usmjeravanja prosljeđivanjem dodatnih povratnih poziva (ili nizova) metodi. Ovo je korisno ako trebate ograničiti pristup ili učitati bilo koje podatke prije korištenja rute itd.

Tipično, asinkrono dohvaćanje podataka može izgledati nešto poput onog prikazanog ispod (ovdje uzimamo parametar:id i učitavamo korisničke podatke).

app.get("/user/:id", function(req, res, next) ( loadUser(req.params.id, function(err, user) (if (err) return next(err); res.send( "Pregled korisnika " + user.name);

Da biste se pridržavali DRY principa i poboljšali čitljivost koda, možete organizirati takvu logiku koristeći slojeve. Kao što vidite, apstrahovanjem logike koristeći slojeve, možete postići ponovnu upotrebu slojeva i učiniti kod rute ljepšim.

funkcija loadUser(req, res, next) ( // ovdje učitavamo korisnika iz baze podataka var user = users; if (user) ( req.user = user; next(); ) else ( next(new Error("Failed za učitavanje korisnika " + req.params.id)); ) ) app.get("/user/:id", loadUser, function(req, res) ( res.send("Pregled korisnika " + req.user.name ) ; ));

Može se dodati više slojeva rutiranja i oni će se izvršavati uzastopno kako bi se obezbijedila drugačija logika, kao što je ograničavanje pristupa korisničkom nalogu. U primjeru ispod, samo ovlašteni korisnik može uređivati ​​svoj račun.

funkcija andRestrictToSelf(req, res, next) ( req.authenticatedUser.id == req.user.id ? next() : next(new Error("Unauthorized")); ) app.get("/user/:id/ edit", loadUser, andRestrictToSelf, function(req, res) ( res.send("Uređivanje korisnika " + req.user.name); ));

Prepoznajući da su slojevi samo funkcije, možete napisati funkciju koja vraća sloj (kako bi se pružilo još izražajnije i fleksibilnije rješenje), kao što je prikazano u nastavku.

funkcija andRestrictTo(role) ( return function(req, res, next) (req.authenticatedUser.role == uloga? next() : next(new Error("Unauthorized")); ) ) app.del("/user/ :id", loadUser, andRestrictTo("admin"), function(req, res) ( res.send("Izbrisani korisnik " + req.user.name); ));

Često korišteni "slojevi" slojeva mogu se proslijediti kao nizovi proizvoljne dubine i strukture stabla (oni će se primjenjivati ​​rekurzivno):

var a = , b = , sve = ; app.get("/foo", a, function() ()); app.get("/bar", a, function() ()); app.get("/", a, middleware3, middleware4, function() ()); app.get("/", a, b, function() ()); app.get("/", sve, funkcija() ());

Cijeli primjer se može pogledati u spremištu.

Postoje slučajevi kada trebate preskočiti preostale slojeve rute u stogu, ali nastaviti s izvršavanjem sljedećih ruta. Da biste to učinili, pozovite next() s argumentom rute: next("route") . Ako nema preostalih ruta za izvršenje, Express će odgovoriti sa greškom 404 Not Found.

HTTP metode

Već smo koristili app.get() nekoliko puta, ali Express nudi i druge HTTP metode - app.post(), app.del() itd.

Najčešći slučaj upotrebe POST-a je podnošenje obrasca. U primjeru ispod jednostavno pravimo HTML obrazac. A onda će se kontrola prenijeti na rutu koju ćemo definirati u sljedećem primjeru.

Podrazumevano, Express ne zna šta da radi sa tijelom zahtjeva, tako da moramo dodati sloj bodyParser() koji će analizirati tijelo zahtjeva kodirano u aplikaciji/x-www-form-urlencoded ili application/json i staviti raščlanjivanje rezultira u req .body . Da bismo to učinili moramo reći use() kao što je dolje:

app.use(express.bodyParser());

Sada će donja ruta pristupiti objektu req.body.user, koji će imati svojstva imena i e-pošte:

app.post("/", function(req, res) ( console.log(req.body.user); res.redirect("back"); ));

Ako obrazac koristi metode kao što je PUT, možete koristiti skriveni unos koji se zove _method, koji vam omogućava da promijenite HTTP metodu. Da bismo to postigli, prvo moramo omogućiti sloj methodOverride(), koji će biti postavljen iza bodyParser(), što će mu omogućiti da koristi req.body koji sadrži polja poslanog obrasca.

app.use(express.bodyParser()); app.use(express.methodOverride());

Ovi slojevi nisu omogućeni prema zadanim postavkama, jer Express ne mora odmah imati punu funkcionalnost. Ovisno o potrebama aplikacije, možda ih nećete morati koristiti. I tada će metode PUT i DELETE i dalje biti dostupne, ali direktno. U isto vrijeme, methodOverride je odlično rješenje za HTML forme. Ispod je primjer korištenja PUT metode:

app.put("/", function() ( console.log(req.body.user); res.redirect("back"); ));

Greška u obradi

Express ima metodu app.error() koja prihvaća sve izuzetke koje bacaju rute ili proslijeđuju kao next(err) . Ispod je primjer kako poslužiti više stranica koristeći domaći izuzetak NotFound:

funkcija NotFound(msg) ( this.name = "NotFound"; Error.call(this, msg); Error.captureStackTrace(this, arguments.callee); ) NotFound.prototype.__proto__ = Error.prototype; app.get("/404", function(req, res) (baci novi NotFound; )); app.get("/500", function(req, res) (izbaci novu grešku("keyboard cat!"); ));

Možete pozvati app.error() više puta kao što je prikazano ispod. Ovdje provjeravamo instanceof NotFound i prikazujemo 404 stranicu ili prosljeđujemo kontrolu sljedećem rukovaocu greškama.

Imajte na umu da se ovi rukovaoci mogu definirati bilo gdje, jer će i dalje biti smješteni ispod rukovatelja ruta u listen() . Ovo im omogućava da se definiraju unutar configure() blokova, tako da se izuzecima može drugačije rukovati ovisno o trenutnom okruženju.

app.error(function(err, req, res, next) ( if (err instanceof NotFound) (res.render("404.jade"); ) else ( next(err); ) ));

Radi jednostavnosti, ovdje pretpostavljamo da sve greške imaju kod 500, ali ovo možete promijeniti kako želite. Na primjer, kada Node radi operacije sistema datoteka, možemo dobiti objekat greške sa poljem error.code = ENOENT, što znači "datoteka ili direktorij nije pronađen", možemo to koristiti u rukovaocu greškama i prikazati odgovarajuću stranicu.

app.error(function(err, req, res) ( res.render("500.jade", ( greška: err )); ));

Aplikacije također mogu koristiti Connect-ov errorHander sloj za obradu izuzetaka. Na primjer, ako trebate prikazati izuzetke u stderr u razvojnom okruženju, možete učiniti ovo:

app.use(express.errorHandler(( dumpExceptions: true )));

Takođe, tokom razvoja, možda će nam trebati cool HTML stranice koje prikazuju izbačene ili izbačene izuzetke. U ovom slučaju, morate postaviti showStack na true:

app.use(express.errorHandler(( showStack: true, dumpExceptions: true )));

ErrorHandler sloj također odgovara u JSON-u ako klijent prosledi Accept: application/json zaglavlje, što je korisno za razvoj AJAX aplikacija.

Predobrada parametara rute

Parametri rute prije obrade mogu značajno poboljšati čitljivost aplikacije kroz eksplicitno učitavanje podataka i traženje validacije URL-a. Na primjer, ako stalno preuzimate neke podatke za određene upite (npr. učitavate korisničke podatke za /user/:id), možete učiniti nešto ovako:

app.get("/user/:userId", function(req, res, next) ( User.get(req.params.userId, function(err, user) (if (err) return next(err); res. send("user " + user.name ));

Uz preduvjete, možemo priložiti funkcije povratnog poziva našim parametrima upita koje bi izvršile provjeru valjanosti, ograničile pristup ili čak učitale podatke iz baze podataka. U primjeru ispod, pozivamo app.param() s imenom parametra kojem želimo priložiti povratni poziv. Kao što vidite, primamo argument id, koji sadrži ime polja. Na ovaj način učitavamo korisnički objekat i obavljamo uobičajeno rukovanje greškama i jednostavan poziv next() da prenesemo kontrolu sljedećem preduvjetu ili rukovatelju rute.

app.param("userId", function(req, res, next, id) (User.get(id, function(err, user) (if (err) return next(err); if (!user) return next( nova greška("nije uspjelo pronaći korisnika") req.user = user();

Gore navedeni koraci, kao što je već spomenuto, značajno poboljšavaju čitljivost koda i olakšavaju korištenje iste logike na različitim mjestima u aplikaciji:

app.get("/user/:userId", function(req, res) ( res.send("user " + req.user.name); ));

Rendering Views

Prikaz imena datoteka slijede shemu (ime). (motor), gdje je (motor) naziv modula predloška motora koji mora biti povezan. Na primjer, pogled layout.ejs govori sistemu pogleda da uradi require("ejs") . Da bi se integrirao sa Expressom, modul koji se može učitati mora izvesti metodu, exports.compile(str, options) i vratiti funkciju. Da biste promijenili ovo ponašanje, možete koristiti metodu app.register() - ona vam omogućava da povežete ekstenzije datoteka sa određenim mašinama. Na primjer, možete napraviti foo.html prikazan od strane motora ejs.

Ispod je primjer korištenja Jade za renderiranje index.html . A pošto ne koristimo layout:false , prikazani sadržaj prikaza index.jade će biti proslijeđen kao lokalna varijabla tijela u prikaz layout.jade.

app.get("/", function(req, res) ( res.render("index.jade", (naslov: "Moja stranica" )); ));

Podešavanje mehanizma pregleda vam omogućava da odredite podrazumevani mehanizam za predložak. Tako, na primjer, kada koristite Jade možete učiniti ovo:

app.set("view engine", "jade");

što će nam omogućiti da prikažemo ovako:

res.render("indeks");

Ali ne ovako:

res.render("index.jade");

Kada je predložak instaliran preko mehanizma pregleda, ekstenzije datoteka nisu potrebne. Međutim, još uvijek možemo koristiti nekoliko predložaka odjednom:

res.render("druga-stranica.ejs");

Express također ima postavke opcija prikaza koje će se primjenjivati ​​svaki put kada se prikaz prikaže. Na primjer, ako ne koristite rasporede tako često, možete to napisati ovako:

app.set("view options", (layout: false ));

Što se onda može preopteretiti ako je potrebno u pozivu res.render() :

res.render("myview.ejs", (layout: true));

Kada vam je potreban drugačiji izgled, možete odrediti i putanju. Na primjer, ako imamo mehanizam za pregled postavljen na jade, a datoteka rasporeda se zove ./views/mylayout.jade, možemo jednostavno proći:

res.render("stranica", ( raspored: "mylayout" ));

U suprotnom, možete proslijediti ekstenziju datoteke:

res.render("stranica", ( raspored: "mylayout.jade" ));

Putevi također mogu biti apsolutni:

res.render("stranica", ( raspored: __dirname + "/../../mylayout.jade" ));

Dobar primjer je specificiranje nestandardnih oznaka motora za otvaranje i zatvaranje ejs:

app.set("opcije pregleda", (otvori: "((", zatvori: "))" ));

View Fragments

Sistem Express view ima ugrađenu podršku za fragmente i kolekcije, svojevrsni mini-prikaz. Na primjer, umjesto da se krećete kroz prikaz kako biste prikazali listu komentara, možete jednostavno koristiti fragment kolekcije:

parcijalni("komentar", (kolekcija: komentari));

Ako druge opcije ili lokalne varijable nisu potrebne, onda možete preskočiti objekt i jednostavno proslijediti niz podataka. Primjer ispod je ekvivalentan prethodnom:

parcijalni("komentar", komentari);

Kada koristimo kolekcije, imamo nekoliko "magičnih" lokalnih varijabli:

• firstInCollection - istina ako je ovo prvi objekt
• indexInCollection - indeks objekta u kolekciji
• lastInCollection - istina ako je ovo posljednji objekt
• collectionLength - dužina kolekcije

Lokalne varijable proslijeđene ili generirane imaju prednost, ali lokalne varijable proslijeđene roditeljskom prikazu su također dostupne i podređenom pogledu. Tako, na primjer, ako renderiramo pogled koristeći partial("blog/post", post) i on proizvodi lokalnu varijablu post, a pogled koji je pozvao ovu funkciju imao je lokalnu varijablu user, tada će korisnik također biti vidljiv na blogu /post view.

Pogledajte res.partial() za više dokumentacije.

Napomena: Pažljivo koristite kolekcije, jer prikazivanje niza od 100 elemenata znači prikazivanje 100 prikaza. Za jednostavne kolekcije, bolje je proći kroz prikaz, a ne koristiti kolekcije. Na taj način će opterećenje biti manje.

Potražite poglede

Pregledi se traže u odnosu na roditeljski prikaz. Na primjer, ako imamo view views/user/list.jade i unutar njega zovemo partial("edit") , sistem će pokušati učitati view views/user/edit.jade , dok partial("../ poruke") će rezultirati preuzimanjem views/messages.jade

Sistem pregleda vam takođe omogućava da kreirate indeksne datoteke. Na primjer, možemo pozvati res.render("users") i to može učitati i views/users.jade i views/users/index.jade.

Također možete koristiti indeksne datoteke iz pogleda u istom direktoriju. Dakle, pozivanje partial("users") može pristupiti pogledu ../users/index umjesto poziva partial("index") .

Predlošci

Ispod je nekoliko šablonskih mehanizama koji se obično koriste sa Expressom:

• E.J.S.- ugrađeni JavaScript
• CoffeeKup- na osnovu šablona CoffeeScript
• jQuery Templates za Node

Podrška sesiji

Podrška za sesiju može se omogućiti korištenjem Connect-ovog sloja sesije. Također za ovo nam je potreban sloj cookieParser koji se nalazi iznad, koji će analizirati kolačiće i smjestiti ih u req.cookies.

app.use(express.cookieParser()); app.use(express.session(( tajna: "keyboard cat" )));

Prema zadanim postavkama, sloj sesije koristi Connect-ovu memoriju, ali postoje mnoga druga rješenja. Na primjer connect-redis podržava pohranu sesije u Redis. Evo kako ga koristiti:

var RedisStore = require("connect-redis")(express); app.use(express.cookieParser()); app.use(express.session(( tajna: "keyboard cat", store: new RedisStore )));

Sada će svojstva req.session i req.sessionStore biti dostupna sa svih ruta i narednih slojeva. Svojstva req.session se automatski spremaju nakon odgovora. Evo kako organizirati svoju košaricu:

var RedisStore = require("connect-redis")(express); app.use(express.bodyParser()); app.use(express.cookieParser()); app.use(express.session(( tajna: "keyboard cat", store: new RedisStore ))); app.post("/add-to-cart", function(req, res) ( // recimo da smo proslijedili nekoliko objekata iz obrasca // koristimo bodyParser() za ovo var items = req.body.items; req. sesija = stavke res.redirect("nazad"); app.get("/add-to-cart", function(req, res) ( // Kada preusmjerimo na GET /add-to-cart // možemo provjeriti req.session.items && req.session.items . dužina // za ispis naše poruke if (req.session.items && req.session.items.length) ( req.flash("info", "Imate %s artikala u korpi", req.session.items. dužina ); res.render("kolica za kupovinu");

Objekt req.session također ima metode Session.touch(), Session.destroy(), Session.regenerate() za manipuliranje sesijama. Za potpunije informacije pogledajte dokumentaciju Connect Session.

Vodič za migraciju

Programeri koji su radili sa Express 1.x mogu se obratiti vodiču za migraciju kako bi njihove aplikacije radile sa Express 2.x, Connect 1.x i Node 0.4.x.

Zahtjev

req.header(ključ[, defaultValue])

Nabavite zaglavlje zahtjeva za ključ (neosjetljivo na velika i mala slova) s opcionom zadanom DefaultValue:

req.header("Host"); req.header("host"); req.header("Prihvati", "*/*");

Zaglavlja Referer i Referer su poseban slučaj: obje konstrukcije će raditi;

// poslao zaglavlje "Referrer: http://google.com" req.header("Referer"); // => "http://google.com" req.header("Referrer"); // => "http://google.com"

req.accepts(type)

Provjerava da li je zaglavlje Accept proslijeđeno i da li odgovara datom tipu.

Kada nedostaje zaglavlje Accept, vraća se true. U suprotnom, tip se podudara, a zatim se provjeravaju podtipovi. Moguće je proslijediti "html" koji je interno konvertiran u "text/html" korištenjem MIME tabele pretraživanja.

// Prihvati: text/html req.accepts("html"); // => true // Prihvati: text/*; application/json req.accepts("html"); req.accepts("text/html"); req.accepts("tekst/običan"); req.accepts("application/json"); // => true req.accepts("image/png"); req.accepts("png"); // => netačno

req.is(tip)

Provjerava dolazni zahtjev za prisustvo zaglavlja tipa sadržaja i odgovara specificiranom MIME tipu.

// Neka Content-Type: text/html; charset=utf-8 req.is("html"); req.is("tekst/html"); // => true // Neka Content-Type sada bude application/json req.is("json"); req.is("application/json"); // => true req.is("html"); // => netačno

U Express-u možete registrirati vlastite povratne pozive za različite provjere zahtjeva. Na primjer, recimo da moramo dobro provjeriti da li je dolazni zahtjev slika. Da biste to učinili, možete registrirati povratni poziv "an image":

app.is("slika", function(req) (vrat 0 == req.headers["content-type"].indexOf("image"); ));

Sada ga možete koristiti unutar rukovatelja ruta da provjerite Content-Type u obliku "image/jpeg", "image/png", itd.

app.post("/image/upload", function(req, res, next) ( if (req.is("an image")) ( // izvodi određene radnje ) else ( next(); ) ));

Ne zaboravite da se ova metoda ne odnosi samo na Content-Type – možete izvršiti bilo koju vrstu provjera.

Također možete koristiti zamjenske znakove. Ovo će pojednostaviti naš primjer slike. Ovdje ćemo samo provjeriti vrstu:

req.is("slika/*");

Također možemo provjeriti podtip kao što je prikazano ispod. Ovdje će provjera vratiti true u slučajevima "application/json" i "text/json" .

req.is("*/json");

req.param(name[, default])

Vraća vrijednost naziva parametra ili - ako ne postoji - default .

Provjerava parametre rute (req.params), na primjer /user/:id

Provjerava parametre niza upita (req.query), na primjer, ?id=12

Provjerava urlenkodirane parametre tijela zahtjeva (req.body), na primjer, id=12

Za primanje urlenkodiranih parametara tijela zahtjeva, mora postojati objekt req.body. Da biste to učinili, omogućite sloj bodyParser().

req.get(polje, parametar)

Dobiva parametar polja zaglavlja. Podrazumevano je prazan niz.

req.get("content-disposition", "filename"); // => "something.png" req.get("Content-Type", "boundary"); // => "--foo-bar-baz"

req.flash(tip[, msg])

Stavlja u red iskačuće poruke.

req.flash("info", "e-mail poslat"); req.flash("greška", "isporuka e-pošte nije uspjela"); req.flash("info", "e-mail ponovo poslan"); // => 2 req.flash("info"); // => ["e-pošta poslana", "e-pošta ponovo poslata"] req.flash("info"); // => req.flash(); // => ( greška: ["isporuka e-pošte nije uspjela"], info: )

Iskačuće poruke također mogu koristiti nizove formata. Zadani niz "%s" je dostupan:

req.flash("info", "isporuka e-pošte _%s_ od _%s_ nije uspjela.", korisniku, od korisnika);

req.isXMLHttpRequest

Također skraćeno req.xhr. Provjerava zaglavlje X-Requested-With da vidi da li je zahtjev napravljen pomoću XMLHttpRequest:

req.xhr req.isXMLHttpRequest

Odgovor

res.header(ključ[, val])

Dobiva ili postavlja zaglavlje odgovora.

res.header("Dužina sadržaja"); // => undefined res.header("Content-Length", 123); // => 123 res.header("Content-Length"); // => 123

res.charset

Postavlja kodiranje sljedećih zaglavlja tipa sadržaja. Na primjer, res.send() i res.render() će po defaultu biti "utf8" i možemo eksplicitno postaviti kodiranje prije renderiranja predloška:

res.charset = "ISO-8859-1"; res.render("korisnici");

ili prije nego što odgovorite sa res.send() :

res.charset = "ISO-8859-1"; res.send(str);

ili koristeći Node ugrađen res.end() :

res.charset = "ISO-8859-1"; res.header("Content-Type", "text/plain"); res.end(str);

res.contentType(tip)

Postavlja zaglavlje odgovora Content-Type.

var filename = "put/do/image.png"; res.contentType(ime datoteke); // Content-Type je sada "image/png"

Također možete postaviti Content-Type sa sljedećim nizom:

res.contentType("application/json");

Ili samo ekstenzija datoteke (bez vodeće tačke):

res.contentType("json");

res.attachment()

Postavlja zaglavlje odgovora Content-Disposition na "attachment" . Opciono, može se prenijeti ime datoteke.

res.attachment("put/do/moje/image.png");

res.sendfile(put[, opcije[, povratni poziv]])

Koristi se u res.download() za prijenos proizvoljnog fajla.

res.sendfile("put/do/moju.datoteku");

Ova metoda prihvaća opcijski parametar povratnog poziva, koji se poziva ako prijenos datoteke ne uspije ili ne uspije. Po defaultu, next(err) se poziva, ali ako je proslijeđen povratni poziv, onda to mora biti učinjeno eksplicitno, ili obraditi grešku.

res.sendfile(path, function(err) ( if (err) ( next(err); ) else ( console.log("transferred %s", path); ) ));

Također možete proslijediti opcije pozivu fs.createReadStream(). Na primjer, da promijenite veličinu bafera:

res.sendfile(path, ( bufferSize: 1024), function(err) ( // obrada... ));

res.download(fajl[, ime datoteke[, povratni poziv[, povratni poziv2]]])

Otpremite ovu datoteku kao prilog (možete navesti opcionalno alternativno ime datoteke).

res.download('put/do/image.png');

res.download('put/do/image.png', 'foo.png');

Ovo je ekvivalentno sljedećem:

res.attachment(file); res.sendfile(fajl);

Opciono, možete navesti povratni poziv kao drugi ili treći argument res.sendfile() . Unutar njega možete odgovoriti kao da zaglavlje još nije poslano.

res.download(path, "expenses.doc", function(err) ( // obrada... ));

Također možete opciono proslijediti drugi povratni poziv - povratni poziv2. Obrađuje greške vezane za povezivanje. Međutim, ne bi trebalo da pokušava da pošalje odgovor.

res.download(path, function(err) ( // greška ili završetak), function(err) ( // greška veze));

res.send(tijelo|status[, zaglavlja|status[, status]])

Res.send() metoda je mogućnost odgovora visokog nivoa koja vam omogućava da proslijedite objekte (za JSON odgovor), nizove (za HTML odgovor), instance međuspremnika ili cijele brojeve koji specificiraju statusni kod (404, 500, itd. .) . Evo kako se koristi:

res.send(); // 204 res.send(new Buffer("wahoo")); res.send(( neki: "json" )); res.send(""); res.send("Izvini, ne mogu to pronaći", 404); res.send("text", ( "Content-Type": "text/plain" ), 201); res.send(404);

Podrazumevano, zaglavlje Content-Type se postavlja automatski. Međutim, ako je ručno postavljen eksplicitno u res.send() ili prije korištenja res.header() , ili korištenjem res.contentType() , tada neće biti automatski postavljen.

Imajte na umu da ova metoda završava odgovor (slično res.end()), tako da ako trebate proizvesti više odgovora ili stream, trebate koristiti res.write() .

res.json(obj[, zaglavlja|status[, status]])

Šalje JSON odgovor s opcijskim zaglavljima i statusnim kodom. Ova metoda je idealna za organiziranje JSON API-ja, ali JSON se također može poslati pomoću res.send(obj) (što nije idealno ako želite poslati samo JSON kodirani niz, jer će res.send(string) poslati HTML)

res.json(null); res.json(( korisnik: "tj" )); res.json("čuvar!", 500); res.json("Ništa nije pronađeno", 404);

res.redirect(url[, status])

Preusmjerava na navedeni URL. Zadani statusni kod je 302.

res.redirect("/", 301); res.redirect("/account"); res.redirect("http://google.com"); res.redirect("home"); res.redirect("nazad");

Express podržava prečice za preusmjeravanja - zadane su one "nazad" i "početna". U ovom slučaju, "nazad" preusmjerava na URL naveden u zaglavlju Referrer (ili Referer), a "home" koristi postavku "home" (podrazumevano "/").

res.cookie(ime, val[, opcije])

Postavlja vrijednost kolačića pod nazivom name na val. Opcije: httpOnly, secure, expires, itd. Opcija putanje je zadana vrijednost postavljena u postavci "home", obično "/".

// "Zapamti me" 15 minuta res.cookie("rememberme", "yes", ( ističe: novi datum(Date.now() + 900000), httpOnly: true ));

Svojstvo maxAge može se postaviti da istekne u odnosu na Date.now() u milisekundama. Dakle, naš gornji primjer sada se može prepisati kao:

res.cookie("memberme", "yes", (maxAge: 900000));

Za raščlanjivanje dolaznih kolačića koristite sloj cookieParser, koji generiše objekat req.cookies:

app.use(express.cookieParser()); app.get("/", function(req, res) ( // koristi req.cookies.rememberme));

res.clearCookie(ime[, opcije])

Brišemo kolačić pod nazivom name, dodjeljujući parametru expires datum u dalekoj prošlosti. Opcije su iste kao i za res.cookie() , putanja je takođe podrazumevana na "početnu" postavku.

res.clearCookie("memberme");

res.render(view[, options[, fn]])

Renderira prikaz sa datim opcijama i opcionim fn povratnim pozivom. Kada je dat fn, odgovor klijentu nije automatski, inače se pravi tekst/html odgovor sa kodom 200.

Proslijeđene opcije su također lokalne varijable pogleda. Na primjer, ako želimo proslijediti korisničku varijablu i onemogućiti izgled, to radimo u jednom objektu:

var user = (ime: "tj"); res.render("index", (izgled: lažno, korisnik: korisnik));

Objekt options se također koristi za prosljeđivanje opcija. Na primjer, ako proslijedite svojstvo statusa, ono ne samo da postaje dostupno pregledu, već također postavlja statusni kod odgovora. Ovo je također korisno ako mehanizam predloška prihvaća određene opcije, kao što su debug ili compress . Ispod je primjer kako možete prikazati stranicu s greškom - ovdje se prosljeđuje status i za prikaz i za postavljanje statusnog koda res.statusCode.

res.render("error", ( status: 500, poruka: "Internal Server Error" ));

res.partial(pregled[, opcije])

Renderira fragment sa datim opcijama. Ova metoda je uvijek dostupna iz pogleda kao lokalna varijabla.

• objekat - objekat prosleđen pogledu
• kao što je ime varijable koja će predstavljati objektni objekat ili svaki element kolekcije prosleđen u pogled. Podrazumevano je naziv prikaza.
  • kao: "nešto" - će dodati lokalnu varijablu nešto
  • kao: ovo - koristit će element kolekcije kao kontekst prikaza (ovo)
  • kao: globalno - spojiće zajedno svojstva elementa kolekcije i varijabli lokalnog pogleda
  • zbirka - niz objekata. Njegovo ime dolazi od naziva pogleda. Na primjer, video.html će imati video objekat unutra.

Sljedeće konstrukcije su ekvivalentne jedna drugoj i ime kolekcije koje se prosljeđuje fragmentu uvijek će biti "movie".

partial("theatre/movie.jade", (kolekcija: filmovi )); partial("theatre/movie.jade", filmovi); partial("movie.jade", (kolekcija: filmovi )); partial("movie.jade", filmovi); parcijalni("film", filmovi); // Unutar pogleda: moovie.director

Za promjenu naziva lokalne varijable iz "movie" u "video" možete koristiti opciju kao:

partial("movie", (kolekcija: filmovi, kao: "video" )); // Unutar pogleda: video.director

Također možemo napraviti film kao vrijednost this unutar našeg pogleda tako da umjesto movie.director možemo upućivati ​​na this.director.

partial("film", (kolekcija: filmovi, kao: ovo )); // Unutar pogleda: this.director

Alternativno rješenje je proširiti svojstva elementa kolekcije na pseudoglobalne (zapravo lokalne) varijable koristeći kao: global , što je sintaktički šećer:

partial("film", (kolekcija: filmovi, kao: globalni )); // Unutar pogleda: direktor

Ista logika se primjenjuje ne samo na kolekcije, već i na objekt unutar pogleda fragmenta:

partial("film", ( objekt: film, kao: ovo )); // Unutar pogleda: this.director partial("movie", ( objekt: film, kao: global )); // Unutar pogleda: director partial("movie", ( objekt: film, kao: "video" )); // Unutar pogleda: video.director partial("movie", ( objekt: film)); // movie.director

Kada je drugi argument ne-kolekcija (bez .length), tretira se kao objekt. U ovom slučaju, ime lokalne varijable za ovaj objekt formira se iz imena pogleda.

var movie = new Movie("Noćna mora prije Božića", "Tim Burton") partial("movie", film) // => Unutar pogleda: movie.director

Izuzetak od ovog pravila je kada se proslijedi jednostavan objekt ("()" ili "novi objekt"), tada se smatra lokalnim objektom i nije mu dostupan po imenu unutar pogleda fragmenta. Na primjer, u sljedećem primjeru očekivali biste da postoji lokalna varijabla "movie" , međutim, budući da je ovo jednostavan objekt, lokalne varijable su već "director" i "title" , odnosno njegova svojstva:

var movie = ( naslov: "Noćna mora prije Božića", režija: "Tim Burton" ); djelomično ("film", film)

U takvim slučajevima, kada trebate proslijediti jednostavan objekt, jednostavno ga dodijelite nekom svojstvu ili koristite svojstvo objekta, koje će naslijediti ime objekta od imena datoteke. Dolje navedeni primjeri su ekvivalentni:

parcijalni("film", (lokalni stanovnici: (film: film)) parcijalni("film", (film: film)) parcijalni("film", (objekat: film))

Isti API se može koristiti sa rute tako da možete odgovoriti HTML fragmentom putem AJAX-a ili WebSockets-a, na primjer možete prikazati kolekciju korisnika direktno sa rute:

app.get("/users", function(req, res) ( if (req.xhr) ( // pošalji kao odgovor svakog korisnika iz kolekcije // proslijeđen na pogled "user" res.partial("user", users) ) else ( // odgovori sa potpunim izgledom sa stranicom liste korisnika // čiji predložak čini parcijalni("user", users) // i dodaje neku vrstu interfejsa res.render("users", ("users", korisnici: korisnici ) );

res.local(ime[, val])

Dobijte ili postavite navedenu lokalnu varijablu. Lokalne varijable u ovom slučaju se odnose na varijable proslijeđene metodama renderiranja pogleda, kao što je res.render() .

app.all("/movie/:id", function(req, res, next) ( Movie.get(req.params.id, function(err, movie) ( // Dodeljuje res.locals.movie = movie res .local("film", film )); app.get("/movie/:id", function(req, res) ( // lokalna varijabla film već postoji // ali možemo je dodati ako je potrebno res.render("movie", ( displayReviews: true ) ); ));

res.locals(obj)

Dodijelite više lokalnih varijabli koristeći dati objekt obj. Sljedeće je ekvivalentno:

res.local("foo", bar); res.local("bar", baz); res.locals(( foo: bar, bar, baz));

Server

app.set(name[, val])

Postavite postavku naziva aplikacije na val ili uzmite vrijednost postavke imena ako nedostaje val:

app.set("views", __dirname + "/views"); app.set("pregledi"); // => ...put...

Do postavki možete doći i putem postavki aplikacije:

app.settings.views // => ...put...

app.enable(ime)

Postavlja postavku imena na true:

app.enable("neka proizvoljna postavka"); app.set("neka proizvoljna postavka"); // => true app.enabled("neka proizvoljna postavka"); // => istina

app.enabled(ime)

Provjerava da li je postavka imena tačna:

app.enabled("pogledaj keš memoriju"); // => false app.enable("view cache"); app.enabled("pogledaj keš memoriju"); // => istina

app.disable(ime)

Postavite postavku imena na false:

app.disable("neka postavka"); app.set("neke postavke"); // => false app.disabled("neka postavka"); // => netačno

app.disabled(ime)

Provjerava da li je postavka imena lažna:

app.enable("pogledaj keš memoriju"); app.disabled("pogledaj keš memoriju"); // => false app.disable("view cache"); app.disabled("pogledaj keš memoriju"); // => istina

app.configure(env|funkcija[, funkcija])

Određuje povratni poziv funkcije povratnog poziva za okruženje env (ili za sva okruženja):

app.configure(function() ( // radi za sva okruženja)); app.configure("development", function() ( // izvršava se samo za "razvojno" okruženje));

app.redirect(ime, val)

Za res.redirect() možemo definirati prečice (u okviru aplikacije) na sljedeći način:

app.redirect("google", "http://google.com");

Sada u ruti možemo pozvati:

res.redirect("google");

Također možete raditi dinamičke skraćenice:

app.redirect("comments", function(req, res) (vraćanje "/post/" + req.params.id + "/comments"; ));

Sada možete učiniti sljedeće i preusmjeravanje će biti dinamički izgrađeno u skladu s kontekstom zahtjeva. Ako smo rutu pozvali sa GET /post/12, naše preusmjeravanje će biti /post/12/comments.

app.get("/post/:id", function(req, res) (res.redirect("comments"); ));

U slučaju montirane aplikacije, res.redirect() će uzeti u obzir tačku montiranja aplikacije. Na primjer, ako je blog aplikacija montirana na /blog, sljedeći primjer će preusmjeriti na /blog/posts:

res.redirect("/posts");

app.error(funkcija)

Dodaje funkciju rukovanja greškom čiji će prvi parametar prihvatiti sve izuzetke, kao što je prikazano u nastavku. Imajte na umu da je moguće postaviti više rukovatelja greškama pozivanjem ove metode više puta, međutim metoda mora pozvati next() ako ne želi sama obraditi izuzetak:

app.error(function(err, req, res, next) (res.send(err.message, 500); ));

app.helpers(obj)

Registrira pomoćnike za statički pogled.

app.helpers(( ime: funkcija(prvi, zadnji) (vrati prvi + ", " + zadnji), firstName: "tj", prezime: "holowaychuk" ));

Naš pogled sada može koristiti varijable firstName i lastName i funkciju name().

<%= name(firstName, lastName) %>

Express također podrazumijeva nekoliko lokalnih varijabli:

• podešavanja - objekat postavki aplikacije
• layout(path) specificira raspored direktno iz unutrašnjosti pogleda

Ova metoda je pod nazivom app.locals() .

app.dynamicHelpers(obj) (#app.dynamic-helpers)

Registrira pomoćnike dinamičkog pogleda. Pomoćnici dinamičkog pogleda su jednostavno funkcije koje uzimaju res, req i izvršavaju se u kontekstu instance servera prije prikazivanja bilo kojeg pogleda. Povratna vrijednost takve funkcije postaje lokalna varijabla s kojom je funkcija pridružena.

app.dynamicHelpers(( sesija: funkcija(req, res) (vrat req.session; ) ));

Sada će svi naši pogledi imati pristup sesiji - podaci o sesiji će biti dostupni na način session.name, itd.:

<%= session.name %>

app.lookup

Vraća rukovaoce rute pridružene datoj stazi.

Recimo da postoje ove rute:

Možete koristiti funkciju pretraživanja da provjerite koje su rute specificirane. Ovo može biti korisno za okvire višeg nivoa izgrađene na Express-u.

app.lookup.get("/user/:id"); // => app.lookup.get("/user/:id/:op?"); // => app.lookup.put("/user/:id"); // => app.lookup.all("/user/:id"); // => app.lookup.all("/hej"); // =>

Alias ​​za app.lookup.HTTP_METHOD() je jednostavno app.HTTP_METHOD() - bez argumenta povratnog poziva. Ovo je smanjenje. Na primjer, sljedeće je ekvivalentno:

app.lookup.get("/user"); app.get("/user");

Svaka vraćena funkcija je dopunjena korisnim svojstvima:

var fn = app.get("/user/:id/:op?"); fn.regexp // => /^\/user\/(?:([^\/]+?))(?:\/([^\/]+?))?\/?$/i fn .keys // => ["id", "op"] fn.path // => "/user/:id/:op?" fn.method // => "GET"

app.match

Vraća niz funkcija povratnog poziva koje se aktiviraju na datom URL-u, koji može sadržavati niz upita itd. Ovo može biti korisno za razumijevanje koje rute imaju sposobnost reagiranja.

Recimo da imamo sljedeće rute:

app.get("/user/:id", function() ()); app.put("/user/:id", function() ()); app.get("/user/:id/:op?", function() ());

Pozivanje podudaranja na GET će vratiti dvije funkcije jer je :op u posljednjoj ruti opcijski parametar.

app.match.get("/user/1"); // =>

I sljedeći poziv će vratiti samo jedan povratni poziv za /user/:id/:op? .

app.match.get("/user/23/edit"); // =>

Također možemo koristiti all() ako nam HTTP metoda nije važna

app.match.all("/user/20"); // =>

Svaka funkcija je opremljena sljedećim svojstvima:

var fn = app.match.get("/user/23/edit"); fn.keys // => ["id", "op"] fn.params // => ( id: "23", op: "edit" ) fn.method // => "GET"

app.mounted(fn)

Dodijelite povratni poziv fn-u koji se poziva kada se ovaj Server prosljeđuje Server.use() .

var app = express.createServer(), blog = express.createServer(); blog.mounted(function(parent) ( //roditelj je aplikacija // ovo je blog)); app.use(blog);

app.register (ext, izvozi)

Povezuje navedena svojstva izvoza (izvoze) mehanizma predloška s ekstenzijom datoteke predloška.

app.register(".html", require("jade"));

Ovo također može biti korisno u slučaju biblioteka čije se ime ne podudara baš s ekstenzijom datoteke šablona. Živi primjer - Haml.js, koji je instaliran npm-om kao "hamljs" i možemo ga registrirati sa ".haml" predlošcima umjesto ".hamljs" kao što bi bilo zadano:

app.register(".haml", require("haml-js"));

Osim toga, app.register je od velike pomoći u slučaju predložaka čiji API nije u skladu sa Express specifikacijama. U primjeru ispod povezujemo ekstenziju .md sa rendererom markdown-fajlovi. Renderovaćemo u HTML-u samo prvi put - radi boljih performansi - i podržaćemo promenljivu zamenu oblika "(ime)".

app.register(".md", ( kompajliraj: funkcija(str, opcije) (var html = md.toHTML(str); vrati funkciju(lokalni) (vrati html.replace(/\(([^)]+) \)/g, function(_, ime) (vratiti lokalne vrijednosti; ) ));

app.listen()

Vežemo utičnicu servera aplikacija za adresu host:porta. Podrazumevani port je 3000, host je INADDR_ANY.

app.listen(); app.listen(3000); app.listen(3000, "n.n.n.n");

Argument port također može biti string koji predstavlja putanju do unix domenska utičnica:

app.listen("/tmp/express.sock");

Sada probajmo:

$ telnet /tmp/express.sock GET / HTTP/1.1 HTTP/1.1 200 OK Content-Type: text/plain Content-Length: 11 Hello World

Učesnici projekta

Glavni doprinosioci projekta bili su sljedeći:

• TJ Holowaychuk (visionmedia)
• Ciaran Jessup (ciaranj)
• Aaron Heckmann (aheckmann)
• Guillermo Rauch (guille)

Moduli treće strane

Sljedeći moduli rade sa ili su izgrađeni na vrhu Expressa:

• pruža usmjeravanje resursa
• ekspresne poruke koje prikazuju iskačuće obavijesti
• podrška za ekspresnu konfiguraciju za asinkronu konfiguraciju (učitavanje podataka iz Redis-a, itd.)
• express-namespace - imenski prostori u rutama
• express-expose jednostavno objavljuje JS kod na strani klijenta aplikacije
• express-params - app.param() ekstenzije
• express-mongoose - dodatak za jednostavno prikazivanje rezultata Mongoose upita (ORM za MongoDB)

Node JS & Express Basics (III).

Hajde da shvatimo šta je npm i za šta je potreban. Instalirajte Express i EJS predložak. Odrađujemo sve pripremne radove i počinjemo kreirati vlastitu web stranicu u NodeJS-u.

Sada sa parametrima koji će se stalno mijenjati.

Ako trebamo kreirati referencu na određenu vrijednost, nakon /mews/value . To će se promijeniti. Na primjer: 23, dio ili bilo koja druga vrijednost.

App.get("/news/:id", function(req, res)( res.send("ID je - " + req.params.id); ));

Ovisno o ovom parametru, možemo uzeti podatke iz baze podataka (baze podataka) i prikazati određeni članak.

Potrebna nam je određena html datoteka u koju ćemo prenijeti podatke našeg ID-a i, ovisno o tim podacima, prikazati ove ili one informacije.

Treba nam malo šablonski mehanizam.

Zahvaljujući Expressu, možemo koristiti više šablonskih mehanizama.

Pošto je EJS opcioni paket, moramo ga instalirati.

Pritisnite Enter

Nakon toga će biti instaliran u našem projektu.

Omogućava vam da proslijedite podatke različitim šablonima, a ovi predlošci će imati ekstenziju .ejs.

U ovim predlošcima moći ćemo prikazati naš html kod zajedno sa js kodom umetnutim u njega (varijable, prikaz petlje i još mnogo toga).

Postojat će predložak stranice koji će se mijenjati ovisno o podacima koji se na njega prenose.

Prva stvar koju treba da uradimo je da odredimo koji mehanizam prikaza ćemo koristiti.

View engine je u suštini mehanizam za šablone.

Pošto ih ima ogroman broj, a mi smo odabrali EJS, moramo ga navesti u našem index.js fajlu.

Odmah nakon inicijalizacije varijable aplikacije.

App.set("view-engine", "ejs");

Sve datoteke koje ćemo prikazati bit će pretraživane u folderu views prema zadanim postavkama.

Na istom nivou na kojem je index.js kreiraćemo folder pogleda.

U njemu ćemo kreirati novu datoteku news.ejs. Ovo će biti neka vrsta šablona koji ćemo popuniti.

U ove šablone možemo postaviti najčešći html kod.

Da bih to uradio, ne moram da koristim metodu .send ili .sendFile, ali će mi trebati metod render().

Metoda render() uzima željenu datoteku (šablon) u folder view i može je prikazati u pretraživaču. Osim toga, može proslijediti određene parametre ovom šablonu.

Ekstenzija možda nije navedena u metodi render(). Zatim možete prenijeti neke parametre samom predlošku. Stoga, objekt prosljeđujemo kao drugi parametar. Može sadržavati veliki broj svojstava i vrijednosti.

Recimo da smo odlučili da prosledimo određeni parametar newsId sa vrednošću req.params.id - to jest, vrednost će biti sam pozvani id.

App.get("/news/:id", function(req, res)( render("news", (newsId: req.params.id)); ));

Dakle, vrijednost će biti proslijeđena šablonu vijesti, koji će se zvati newsId sa vrijednošću id.

Sve ovo možemo prihvatiti i prikazati u datoteci news.ejs.

Promijenimo malo naš news.ejs fajl. ID ćemo prikazati u naslovu stranice.

Sve se može naći u dokumentaciji za EJS template engine (link iznad).

Stranica vijesti s ID =<%= newsId %>

Fajl /views/news.ejs

index.js fajl

Neka express = require("express"); neka app = express(); app.set("view engine", "ejs"); app.get("/", function(req, res)(res.sendFile(__dirname + "/index.html"); )); app.get("/about", function(req, res)(res.sendFile(__dirname + "/about.html"); )); app.get("/news/:id", function(req, res)( res.render("news", (newsId: req.params.id)); )); app.listen(8080);

Možemo proslijediti više parametara. Na primjer:

App.get("/news/:id", function(req, res)( res.render("news", (newsId: req.params.id, newParam: 535 )); ));

A u datoteci news.ejs ćemo je prikazati na stranici, na primjer ovako:

<%= newParam %>

Osim toga, možemo prenositi vlastite objekte. Na primjer, napravimo objekat:

App.get("/news/:id", function(req, res)( let obj = (naslov:"Novosti", id: 4); res.render("novosti", (newsId: req.params.id, newParam: 535)); ));

A mi također možemo prenijeti ovaj objekt. Prvo odredimo naziv onoga što ćemo emitovati, a zatim naznačimo šta prenosimo.

Na primjer:

App.get("/news/:id", function(req, res)(let obj = ( title:"Vijesti", id: 4); res.render("news", (newsId: req.params.id , newParam: 535, obj: obj ));

Naslov =<%= obj.title %>

ID=<%= obj.id %>

<%= newParam %>

Prosljeđivanje niza predlošku.

Kreirajmo niz podataka i prikažimo ga pomoću petlje.

App.get("/news/:id", function(req, res)( neka obj = ( title:"Vijesti", id: 4, paragrafi:["Paragraf", "Običan tekst", "Brojevi: 3, 7, 24", 476]); res.render("news", (newsId: req.params.id, newParam: 535, obj: obj)); ));

Sada ćemo u samom predlošku jednostavno izvesti ovaj niz u petlji:

<% obj.paragraphs.forEach(function(item) { %>
• <%= item %>
<% }); %>

Statički fajlovi i međuverzija.

Fajlovi koji se mogu uključiti u druge datoteke.

Sada imamo jedan šablon - news.ejs, ali zamislite. da ih ima mnogo. Desetine. I moraćete da promenite neki deo koda koji se pojavljuje u svim ovim fajlovima. Morat će se napraviti mnogo promjena.

Da biste to izbjegli, možete koristiti datoteke koje se mogu uključiti u druge datoteke. Na primjer. Postoji datoteka sa zaglavljem stranice. A ako treba nešto da promenite, dovoljno je da promenite samo jedan fajl, jer se on jednostavno povezuje sa drugim.

U folderu predlošci prikaza kreirajte folder koji se zove blokovi, a u njemu datoteku hrader.ejs.

Datoteka hrader.ejs

• To main
• O nama
• Vijesti

Sada trebamo uključiti ovu datoteku u sve šablone. Idite na datoteku vijesti i odmah nakon uvodne oznake tijela napišite:

<% include blocks/header.ejs %>

Putanja je specificirana iz mape pogleda, pošto mehanizam za šablone uvijek počinje da traži tamo.

Statički fajlovi.

Kreirajmo novi folder na nivou index.js pod nazivom public. Sadržat će sve statičke datoteke. To su css fajlovi, slike, dokumenti, itd. Svi ti fajlovi. koji će biti pozvan sa raznih stranica naše stranice.

U ovom folderu ćemo kreirati još jedan folder - css iu njemu ćemo kreirati fajl style.css.

U njega ćemo prenijeti sav stilski kod iz datoteke index.ejs

U .ejs fajlove uključujemo stilove:

Ako sada provjerite, ništa se neće dogoditi. Stilovi se neće povezati.

Da bismo uključili statičke datoteke, moramo koristiti međuopremu:

U datoteci index.js na vrhu, odmah nakon app.set , trebali bismo napisati:

App.use("/public",);

A sada, ako koristimo vezu negdje koja počinje sa /public, NodeJS i Express će razumjeti šta koristimo statičke datoteke i sve će se pravilno povezati.

Drugi je mjesto gdje ih tražimo express.static("public"), tj. u /public folderu.

Da rezimiramo, u kodu app.use("/public", express.static("public")); pratimo link u koji upisujemo

Da je ovako:

Tada bi u ovom kodu bilo:

App.use("/assets", express.static("public"));

U ovom slučaju, public ukazuje na folder!

Ako ostavite ovako, neće doći do promjena. Fajl će se povezati jer ćemo pratiti vezu imovine.

App.use("/assets", express.static("public"));

Kako bi se izbjegla zabuna, obično prave link i mapu istog imena. Najčešće je to javno.

Middleware je ono što radimo prije nego što pošaljemo bilo kakve podatke na stranicu (server).

U ovom slučaju, ovo je naš srednji softver.

Kreiranje HTML obrasca i preuzimanje podataka

Prvo što ćemo učiniti je dodati sam obrazac na našu web stranicu.

Otvorite about.ejs datoteku i ovdje ćemo dodati obrazac koristeći bootstrap tehnologiju.

Unesite Forms u prozor za pretragu i kopirajte prvi obrazac sa vrha na pronađenoj stranici.

Sačuvajmo i bežimo.

POST zahtjev.

Pošto ćemo izvršiti POST zahtjev, moramo dodati nekoliko atributa u obrazac.

Metod="post" - jer POST zahtjev

A action="" je mjesto gdje trebate preusmjeriti korisnika nakon što klikne na "Pošalji". U našem slučaju to je:

Moramo da uradimo sve ostalo u datoteci index.js

Prije svega, moramo preuzeti paket koji se zove body-parser.

Omogućava nam da uzmemo POST zahtjev koji dolazi iz obrasca i obradimo ga. Drugim riječima, uzmite sve podatke iz obrasca.

Da biste instalirali, upišite u projektnu fasciklu u CS-u.

npm install body-parser

Pritisnite - Enter.

Paket je instaliran.

Nakon instalacije trebate slijediti jednostavna uputstva.

Idemo na odjeljak Primjeri na web stranici i tamo pronaći odjeljak za ekspresnu rutu

1. Povezujemo module koji su nam potrebni.

Var bodyParser = require("body-parser")

Var urlencodedParser = bodyParser.urlencoded(( prošireno: false ))

To jest, parser koji će nam omogućiti da uzmemo podatke iz POST zahtjeva i radimo s njima kako nam je potrebno.

2. Nadalje, na osnovu dokumentacije vidimo da moramo pratiti POST zahtjev i proslijediti mu neki međuverski softver (urlencodedParser). Već smo ranije pratili GET zahtjeve.

Podatke primljene iz obrasca ćemo izbaciti na konzolu.

Console.log(req.body);

Možete odmah dodati ček. Ako podaci obrasca nisu dostavljeni, jednostavno ćemo izdati grešku.

Ako (!req.body) vrati res.sendStatus(400)

U samom obrascu morate navesti atribut name za polja. To će biti imena svojstava, a vrijednost će biti ono što korisnik unese.

<% include blocks/header.ejs %>

Naslov drugog nivoa.

To main

naslov trećeg nivoa.

Značaj ovih problema je toliko očigledan da nam konsultacije sa širokim spektrom aktivista omogućavaju da izvršimo važne zadatke u razvoju sistema masovnog učešća. Ideološka razmatranja višeg reda, kao i obim i mjesto obuke kadrova, omogućavaju nam da ocijenimo značaj sistema obuke kadrova koji zadovoljava hitne potrebe. Ne treba, međutim, zaboraviti da konsultacije sa širokim spektrom sredstava doprinose pripremi i implementaciji sistema obuke kadrova koji zadovoljava hitne potrebe.

Ne treba, međutim, zaboraviti da konsultacije sa širokim spektrom sredstava doprinose pripremi i implementaciji sistema obuke kadrova koji zadovoljava hitne potrebe.

E-mail adresa Nikada nećemo dijeliti vašu e-poštu ni sa kim drugim.

Lozinka

Pogledaj me

Pošalji

Neka express = require("express"); var bodyParser = require("body-parser"); neka app = express(); var urlencodedParser = bodyParser.urlencoded(( prošireno: false )); app.set("view engine", "ejs"); app.use("/public", express.static("public")); app.get("/", function(req, res)(res.render("index"); )); app.get("/about", function(req, res)(res.render("about"); )); app.post("/about", urlencodedParser, function(req, res)(if (!req.body) vrati res.sendStatus(400); console.log(req.body); res.render("about") ;)); app.get("/news", function(req, res) ( res.render("news-common",(newParam1:"Param-1")); )); app.get("/news/:id", function(req, res)( neka obj = ( title:"Vijesti", id: 4, paragrafi:["Paragraf", "Običan tekst", "Brojevi: 3, 7, 24", 476]); res.render("vijesti", (newsId: req.params.id, newParam: 535, obj: obj)); )); app.listen(8080);

Unesite podatke i kliknite pošalji. U konzoli ćemo vidjeti izlaz ovih podataka (svojstvo - vrijednost).

Stranica će se ponovo učitati nakon slanja obrasca i na konzoli ćemo vidjeti podatke koji su poslani.

Sada možemo napraviti tako da nakon slanja prikazujemo druge podatke.

Hajde da promijenimo mali kod u datoteci index.js

App.post("/about", urlencodedParser, function(req, res)(if (!req.body) vrati res.sendStatus(400); console.log(req.body); res.render(" o-uspjehu", (podaci: req.body)); });

Na ovaj način ćemo izbaciti stranicu about-success.ejs i sada ćemo je kreirati u folderu views. Kao drugi parametar mi ćemo proslijediti podatke obrasca kao objekt. - (podaci: req.body)

<% include blocks/header.ejs %>

Na ovaj način možete pratiti podatke koji dolaze iz obrazaca, provjeriti njihovu usklađenost i ako korisnik nešto nije popunio, izdati grešku itd.

Osim toga, bilo bi zgodno ove podatke poslati e-poštom ili ih sačuvati u bazi podataka.

Ako želite da ih pošaljete poštom. onda postoji još jedan paket u npm-u - Nodemailer. Ovaj paket vam omogućava slanje podataka direktno na e-poštu. Jednostavan je za upotrebu. A uz pomoć njega možete poštom primiti sve podatke obrasca koji je popunio korisnik.

NodeJS nam pruža mnoge dodatne pakete. Na primjer, koristili smo Express kako bismo olakšali praćenje veza i korištenje šablona. Body-parseer kako bi prihvatio podatke primljene iz obrasca. Nodemailer - za slanje podataka putem e-pošte.

Kako dobiti podatke iz URL niza.

Ponekad je potrebno da dobijete ovu vrstu podataka iz adresne trake:

http://localhost:8080/news/12?filter-id&city=london

Pogledajmo kako dobiti ove podatke koristeći ovaj kod iz datoteke index.js kao primjer:

App.get("/news/:id", function(req, res)( neka obj = ( title:"Vijesti", id: 4, paragrafi:["Paragraf", "Običan tekst", "Brojevi: 3, 7, 24", 476]); res.render("vijesti", (newsId: req.params.id, newParam: 535, obj: obj)); ));

Hajde da jednostavno izbacimo ove podatke na konzolu:

App.get("/news/:id", function(req, res)( neka obj = ( title:"Vijesti", id: 4, paragrafi:["Paragraf", "Običan tekst", "Brojevi: 3, 7, 24", 476]); console.log(req.query); res.render("news", (newsId: req.params.id, newParam: 535, obj: obj)); ));

U konzoli ćemo vidjeti

( filter: "id", grad: "london")

Ovo ponekad može biti korisno.

Kao što možete vidjeti iz naslova, naš članak će se fokusirati na odabir jednog od tri okvira za Node.js: Express, Koa I Jedra.

Na kraju članka podijelit ćemo s vama izbor kompanijei objasnićemo zašto okviru koji smo odabrali treba posvetiti posebnu pažnju.

Odmah da naglasimo da je zadatak prilično složen, te će biti teško jednu od opcija proglasiti optimalnom i prikladnom za sve prilike.

U našem članku prvo ćemo opisati glavne karakteristike svakog okvira. A kada steknete opšti utisak o njima, uporedimo tri okvira na osnovu nekoliko ključnih kriterijuma.

A sada idemo na2009, kada su dvogodišnji eksperimentiRyan Dahlkreiranje web komponenti na strani servera bile su uspješne i pojavila se fundamentalno nova tehnologija.

Node.js – platforma vođena događajima koja se koristi za kreiranje web aplikacija koja pruža mogućnost korištenja JavaScripta na strani servera.

Budući da se prije pojave Node.js-a JavaScript koristio samo na strani klijenta, pojavu takve platforme programeri su dočekali s entuzijazmom. U suštini, ovo je otvorilo nove mogućnosti za kreiranje aplikacija visokih performansi i skalabilnosti.

Mora se priznati da su očekivanja programera ispunjena, a u ovom trenutku Node.js ostaje popularan i nastavlja napredovati.

Da biste to potvrdili, dovoljno je pratiti učestalost oslobađanja ažuriranja i obim izvršenih promjena .

Zajednica Node.js raste i razvija se. Nove ideje se redovno generišu, što rezultira novim alatima i bibliotekama.

Zahvaljujući ovakvom tempu razvoja, programeri imaju na raspolaganju širok spektar okvira, a takva raznolikost, po pravilu, uključuje teške izbore.

U njegovom Zatim ćemo izabrati jedan od tri MVC okvira,koji se koriste za serverski dio (backend) aplikacija na Node.js.

MVC (Model-View-Controller) – obrazac dizajna koji uključuje tri komponente: model, pogled i kontroler. Sve tri komponente se mogu menjati nezavisno jedna od druge. U ovom slučaju, model pruža podatke i kontrolna logička pravila, pogled je odgovoran za prikaz podataka na korisničkom interfejsu, a kontroler obezbeđuje interakciju između modela i pogleda.

Za poređenje u okviru ovog članka, m odabrali ste:

• ekspresno, kao najfleksibilniji, jednostavan i najbrži okvir
• Koa kao verzija Expressnova generacija, kreirana od strane istog razvojnog tima
• Jedra , kao dizajniran za brzi razvoj aplikacija zasnovanih na principimaRuby on Rails I Express.

Svaki od ovih okvira ima svoje sljedbenike i protivnike, koji mogu beskonačno raspravljati jedni s drugima, dajući svoje razloge za i protiv.

Ali u isto vrijeme, sve tri opcije imaju određene karakteristike i karakteristike koje pružaju prednost u određenoj situaciji. acije.

EXPRESS.JS

Započnimo opis s najjednostavnijim okvirom koji se koristi na Node.js platformi.

Express se već dugo koristi za razvoj aplikacija i zahvaljujući svojoj stabilnosti čvrsto zauzima poziciju jednog od naj

Postoji veliki broj detaljnih uputstava i opisa za ovaj okvir, koje su sastavili programeri koji su testirali njegovu efikasnost u praksi. Stoga je saExpressPreporučuje se da počnete ako namjeravate naučiti kako kreirati aplikacije na Node.js platformi.

Slažem se, mnogo je mudrije koristiti nagomilano i dokazano iskustvo nego ponovo izmišljati točak.

Glavna karakteristika ovog okvira je da zaExpress karakteristika mala količina osnovne funkcionalnosti. Sve ostale funkcije koje su vam potrebne morat ćete dobiti preko vanjskih modula. Zapravo,Expressu svom čistom obliku, to je server i možda nema niti jedan modul.

Zahvaljujući ovom minimalizmu, programer u početku ima na raspolaganjulako i brzi alatkoje može proširiti i razviti.

Važno je da izbor modula zaExpressnije povezan ni sa kakvim ograničenjima: ni kvantitativnim ni funkcionalnim.

Kao rezultat, ovaj okvir pruža programeru mogućnost da riješi bilo koji problem bez ograničenja u izboru alata.

S jedne strane, ne može se ne radovati činjenici da nedostatak gotovih univerzalnih rješenja zapravo znači da svakoaplikacija koju kreirate bit će jedinstvena.

S druge strane, programer treba samostalno odabrati i organizirati module, a to podrazumijeva veliki obim posla i, shodno tome, zahtijeva više vremena i truda od programera.

PROS:

✓ jednostavnost

✓ fleksibilnost

✓ dobra skalabilnost

✓ razvijena zajednica

✓ detaljna dokumentacija

✓ širok izbor dodataka

MINUS:

✗ velika količina ručnog rada

✗ Koristi se zastarjeli pristup povratni pozivi funkcije

KOA.JS

Koakreiran od strane tima programera poputokvirna opcijaExpress u novoj generaciji. Ova poboljšana verzija je dizajnirana da vam pomogne u kreiranju web aplikacija i API-ja s poboljšanim performansama. U skladu s tim, kreatori su nastojali uzeti u obzir sve nedostatke svog prethodnika i učiniti ga modernijim i lakšim za korištenje.

Da vidimo koliko je ovo bilo uspješno.

Koaima skoro istu funkcionalnost i superioran jeExpress lakoćom.

Posebnost Koa-e je upotreba ES6 generatora.

Generatori – vrsta funkcije koja se može pokrenuti, zaustaviti i nastaviti bez obzira u kojoj se fazi izvršavanja nalazi, a koja i dalje zadržava svoj sadržaj.

Primjena ES6 generatora uKoaomogućava vam da eliminišete povratne pozive povratni pozivi ), smanjuje količinu rada koda za programere i smanjuje vjerovatnoću grešaka.

Zahvaljujući činjenici da su kreatoriKoanedostatke identifikovane u procesu rada saExpress, ovaj okvir se može pohvaliti svojom primjenomznačajno pojednostavljuje prilagođavanje specifičnim zahtjevima kupaca (prilagođavanje). A takva karakteristika u konačnici može igrati odlučujuću ulogu u procesu odabira: danas, u visoko konkurentnom okruženju, svaka aplikacija teži da koristi svoj vlastiti stil.

Ako govorimo o nedostacima, oni su uglavnom povezani sa relativnom mladošćuKoa(pojavio se u 2013). Okvir ne uživa podršku tako velike zajednice kao što jeExpress, a još nije imao vremena da pokaže sve svoje mogućnosti.

PROS:

✓ lagana

✓ fleksibilan

✓ brzo

✓ ES6 generatori

✓ bolje prilagođavanje

MINUS:

✗ nedovoljna podrška zajednice

SAILS.JS

Ovaj okvir je dizajniran kaokompletan gotov proizvod, koji već uključuje dovoljno funkcionalnosti za početak, a istovremeno koristi minimalan broj vanjskih modula.

Shodno tome, takav okvir će u početku bititeža od prethodna dva.

S jedne strane, od programera je potrebna minimalna količina napora, budući da se za kreiranje aplikacije koristi vlastita funkcionalnost okvira. Nema potrebe da ulazite u zamršenosti procesa - jednostavno možete uzeti gotovo, provjereno rješenje.

S druge strane, razvoj aplikacija će biti ograničen dostupnim okvirnim alatima, budući da su eksterni moduli zaJedramnogo manje nego zaExpress ili Koa.

Posebna karakteristika okvira je ugrađena tehnologija programiranjaWaterline ORM (engleski Object-Relational Mapping), koji se koristi za pružanje komunikacije sa različitim bazama podataka.

Prisutnost takve komponente može se smatrati prednošću, ali u procesu rada možete naići na određena ograničenja. Na primjer,Waterlinene podržava transakcije, nove funkcije i ispravke grešaka se uvode neblagovremeno.

Općenito, sporiji razvoj je donedavno bio karakterističan za cijelu zajednicuJedra, posebno u poređenju sa ostalima koji podržavaju gore opisaneExpress I Koa. Ali treba napomenuti da je u ovom trenutku zajednica Sails počela uzimati zamah i aktivnije se razvijati.

PROS:

✓ bogata funkcionalnost

✓ Podrška za Socket.io

✓ dokumentacija na jednom mjestu

✓ Lakše je pronaći stručnjaka sa iskustvom u jedrima

MINUS:

✗ teška

✗ sporo

✗ Ograničenja vodene linije

✗ nedovoljno detaljna dokumentacija

Opisali smo glavna svojstva karakteristična za tri okvira, koja su sasvim dovoljna da se o njima stvori objektivan utisak.

Ako imate bilo kakvih pitanja, kontaktirajte nas odmah!

Da bismo vam pomogli da jasnije uporedite tri okvira na osnovu gore navedenih karakteristika, kompanijanudi maliuporedna tabela.

Hajde da probamo da uradimoopšti zaključakiz onoga što već znamo o tri okvira koja se razmatraju. Hajde da odredimo za koje je projekte, općenito, svaki od njih prikladniji:

Express.js pogodan za:

• programeri početnici koji su fokusirani na profesionalni razvoj u Node JS;
• veliki projekti koji uključuju prilagođavanje;
• slučajevima kada je potrebna dugoročna podrška aplikacijama.

Sails.js pogodan za:

• brz početak projekta;
• brzi startupi koji ne očekuju širenje u budućnosti;
• aplikacije u realnom vremenu gdje je potreban trenutni odgovor;
• početnici Node.js programeri;
• aplikacije koje ne zahtijevaju dugoročnu podršku.

Da budemo pošteni, napominjemo da se aplikacije u realnom vremenu mogu kreirati i pomoću Expressa. Međutim, kada razvijate takvu aplikaciju koristeći Sails, bit će potrebno mnogo manje vremena i truda za kreiranje i konfiguraciju.

Koa.js pogodan za:

• mali i veliki projekti koji uključuju budući razvoj;
• za projekte sa visokim stepenom prilagođavanja;
• kako bi se olakšala dugoročna podrška aplikacijama.

Sada kada smo detaljno pogledali prednosti i nedostatke svakog od tri okvira, hajde da razgovaramo o tome koji okvir biramo i zašto.

Odabrali smo Koa jer:

• Kao i Express, Koa ne ograničava programere u korištenju ugrađenih modula, već daje mogućnost izbora setoviupravo onaj koji je najprikladniji za određeni projekat;
• Koa uključuje prednosti dokazanog i široko korištenog Express okvira;
• kreatori Koa-e su imali priliku da analiziraju poteškoće sa kojima se susreću programeri koji koriste Express;
• pri stvaranju Koa-e uzeti su u obzir nedostaci njegovog prethodnika;
• Koa je baziran na novim standardima i prati moderne trendove;
• Koa je pogodan za razvoj širokog spektra aplikacija bilo koje veličine, sa bilo kojim stepenom prilagođavanja i sa svim zahtevima podrške;

...i najvažniji argument – ovo je pozitivno iskustvo stručnjaka, stečeno tokom rada sa ovim okvirom.

U svakom slučaju, pristupite odluci sa racionalne tačke gledišta i dajte prednost okviru koji je opremljen prema vašim specifičnim zahtjevima.

Uvijek smo spremni podržati vaš izbor i pomoći vam u realizaciji bilo kojeg projekta. Nemojte to odlagati do sutra i upravo sada!

Ovaj članak je namijenjen programerima početnicima i svima koji su zainteresirani za rad sa Node js Express. Da biste ovo savladali morate znati osnove JavaScripta:

Šta je Node.js?

Node.js je asinhroni JavaScript runtime baziran na Chrome-ovom V8 JavaScript motoru. Dizajniran je za kreiranje skalabilnih mrežnih aplikacija.

Node.js vam omogućava da pišete JavaScript kod na strani servera. Sada se možda pitate kako? JavaScript je jezik koji radi u pretraživaču. Pregledač prihvata JavaScript kod i kompajlira ga u komande. Kreator Node.js je uzeo Chrome motor i napravio runtime ( vrijeme izvođenja) tako da radi na serveru. To je medij u kojem se jezik može tumačiti. Pa šta sad imamo? Način za pisanje JavaScripta u pozadini.

Što se tiče definicije, možda se pitate šta pojam "asinhroni" znači u ovom kontekstu. JavaScript je jednostruki jezik. Stoga, ne želite da događaji prekidaju glavnu nit izvršenja. To znači obradu događaja bez prekidanja glavne niti.

Node.js je zasnovan na ovom dizajnu bez blokiranja, što ga čini jednim od najbržih alata za pravljenje web aplikacija. U sljedećem primjeru "Hello World", mnoge veze se mogu obraditi istovremeno. Svaka veza pokreće povratni poziv.

Ovaj primjer Node js Expressa ima šest jednostavnih koraka.

1. Instalirajte Node.js za vašu platformu (MacOS, Windows ili Linux)

Node.js

Node.js® je JavaScript runtime ugrađen u V8 JavaScript motor za Chrome. Node.js koristi I/O vođen događajima, neblokirajući...

Prvi korak je da dobijete instancu JavaScript-a na vašem lokalnom računaru. Upišite nodejs.org u adresnu traku vašeg pretraživača ili kliknite na link i gotovi ste. Prozor za pokretanje trebao bi vam odmah dati ono što želite. Kada pokrenem Ubuntu na svom računaru, prikazuje se odgovarajuća verzija Node.js za moj operativni sistem. Preuzmite i instalirajte ga. Ovo će vam pružiti alate koji su vam potrebni za pokretanje servera na vašem lokalnom računaru:

1. Otvorite komandnu liniju i otkucajte

mkdir myapp cd myapp

Ove Node js Express Post komande su univerzalne za svaki operativni sistem. Prvi će kreirati novi direktorij unutar direktorija u kojem se trenutno nalazite, mkdir = "make directory" . Potonji će se promijeniti u ovaj novokreirani direktorij, cd = "change directory" .

1. Pokrenite svoj projekat i povežite ga sa npm-om

Nakon kreiranja direktorija pod nazivom myapp, morat ćete pokrenuti projekt i povezati ga sa npm-om.

Npm je skraćenica za node package manager ( Node paket menadžer). Ovdje se nalaze svi Node paketi. Oni se mogu smatrati paketima koda, modulima koji obavljaju određenu funkciju. Koristimo interfejs aplikacijskog programa, API, koji obezbeđuju ovi moduli.

Moduli, zauzvrat, djeluju kao crne kutije s dugmadima i polugama koje se mogu gurnuti i povući kako bi se postigao željeni rezultat. Izvođenje naredbe ispod pokreće vaš projekat:

Kreira datoteku package.json u folderu myapp. Datoteka sadrži veze ka svim npm paketima koji su učitani u projekat.

Naredba će od vas tražiti da unesete nekoliko opcija za akciju. Svoj put možete ući kroz sve njih osim ovog:

ulazna tačka: (index.js)

Željećete ovo promijeniti u:

1. Instalirajte Express u myapp direktorij

Express je minimalan i fleksibilan Node.js okvir web aplikacije koji pruža robustan skup funkcija za web.

Dok ste u myapp direktoriju, pokrenite:

npm install express --save

Naredba za instalaciju će nastaviti traženje paketa datoteka Node js Express za instalaciju. Instalirajte ga u svoj projekat.

Sada je mapa node_modules kreirana u korijenu vašeg projekta. Dodavanje -save omogućava da se paket sačuva na listi zavisnosti koja se nalazi u package.json u direktorijumu myapp.

Express pruža skup alata za kreiranje i pokretanje web aplikacije. Express je postao toliko popularan da je sada standard u velikoj većini Node.js aplikacija. Toplo preporučujem korištenje Expressa.

1. Pokrenite uređivač teksta i kreirajte datoteku pod nazivom app.js

Nakon instaliranja Express Node, dodajte sljedeći kod u kreiranu datoteku:

var express = require("express"); var app = express(); app.get("/", funkcija (req, res) ( res.send("Hello World!"); )); app.listen(3000, function () ( console.log("Primjer slušanja aplikacije na portu 3000!"); ));

Ovdje ćete morati koristiti paket koji je nedavno instaliran. Prvi red deklarira varijablu koja će sadržavati ekspresni modul, koji se nalazi u folderu node_modules.

Modul je funkcija. Dodjeljivanje poziva funkcije drugoj varijabli pruža pristup unaprijed definiranom skupu alata koji olakšavaju budući rad. Možete zamisliti privremenu aplikaciju kao objekt čije metode koristite za kreiranje stvarnog programa.

Metoda slušanja pokreće server i sluša na portu 3000 za veze. On odgovara „Hello World! " za GET zahtjeve do korijenskog URL-a (/). Za bilo koju drugu putanju će odgovoriti sa 404 Nije pronađeno.

1. Pokrenite aplikaciju

Unesite naredbu:

Nakon što pokrenete komandu, unesite http://localhost:3000/ u svoj pretraživač da vidite rezultat. Također biste trebali vidjeti " Primjer slušanja aplikacije na portu 3000».

Gledajući obrazac sintakse, ako želimo dodati novu rutu u aplikaciju, mogli bismo jednostavno učiniti nešto poput sljedećeg:

Router.get("/app", function(req, res) ( res.render("app", ( title: "Express" )); ));

Je li ovo pravac? Je li ovo kontroler?

Najzanimljivije je da je ruta funkcija koja sadrži logiku. Unutar rute je res.render funkcija:

Res.render("foo", ( title: "Express" ));

U predlošku pogleda vidimo ovo:

H1= naslov p Dobro došli u #(naslov)

Ovo su dva primjera kako možemo povući podatke iz kontrolera/rute i prikazati ih u prikazu. U ovom primjeru izlazimo HTML:

Express

Dobrodošli u Express

Čini se da sve ovo proizlazi iz problema - može li ruta također sadržavati informacije kontrolera? To je tačno, zbog čega postoji pokret u zajednici da se promijeni naziv foldera iz ruta u kontrolere.

Sjajan primjer ovoga može se vidjeti u primjeru Express MVC.

Ali radi dosljednosti, u ovom vodiču ćemo se držati trenutnih konvencija.

404 greške

Greške vas već šalju u Express. Datoteka app.js ima sljedeće:

/// uhvatiti 404 i preusmjeriti na rukovalac greškama app.use(function(req, res, next) ( var err = new Error("Nije pronađen"); err.status = 404; next(err); ));

U folderu views/ postoji errors.jade.

Proširuje sadržaj bloka rasporeda h1= poruka h2= error.status pre #(error.stack)

To je jednostavno. Ako želite da prilagodite svoju 404 stranicu, samo uredite ovaj prikaz.