Share
Sails.js este un cadru Node.js în curs de dezvoltare, cu accent pe libertate și implicite inteligente. În acest articol vom arunca o privire la unele caracteristici de date Sails oferă out-of-the-box, pentru a face cu ușurință aplicații complexe.
Motivul pentru a alege Sails este cel mai bine pus de creatorul de Sail, Mike McNeil, "Sails a fost creat din necesitate". Multe cadre pe care le vedeți în jurul dvs. sunt construite aproape în ceea ce privește aspectul academic al acestor lucruri, aceste cadre, de obicei, promovează cele mai bune practici și creează o platformă pentru dezvoltatori de a crea lucruri mai repede sau mai bine.
Sails, pe de altă parte, a fost creat pentru producție, nu încearcă să vă hrănească o nouă sintaxă sau platformă, este o bază solidă, menită să creeze cu viteză "munca clientului". Contrastul poate fi subtil, dar există câteva diferențe distincte.
Pentru a ilustra ce mă refer, să aruncăm o privire la Meteor. Meteor este probabil cea mai importantă platformă JS în jurul valorii de astăzi, dar este un prim exemplu al unui cadru, de dragul unui cadru. Acum nu este un lucru rau, eu sunt un mare sustinator al Meteor, ceea ce vreau sa spun este ca au incercat sa construiasca un cadru si au facut o treaba buna la asta, Mike pe de alta parte a plecat sa faca clientul sa munceasca mai repede . Vapoarele sunt doar un mijloc de a ajunge la un sfârșit.
În Meteor, aproape totul este extras și folosiți JavaScript plus Meteor API pentru a codifica totul. În timp ce Sails nu este o nouă platformă, nimic nu este ascuns.
Acesta se află pe partea de sus a Socket.io și cadrul popular Express și aveți acces la ele în întregime, nativ. Începi să vezi diferența?
În plus, deoarece Sails este destinat mai întâi pentru producție, este construit cu mai multe opțiuni pentru scalare și securitate.
Există multe despre care să vorbim, dar în acest articol aș dori să mă concentrez asupra felului în care Sails se ocupă de date și cum puteți folosi unele dintre caracteristicile mai avansate ale Sails pentru a efectua unele acțiuni foarte cool.
Doar în cazul în care nu aveți încă înălțimea Sails, puteți face acest lucru prin intermediul NPM rulând:
sudo npm install -g vele
Acum hai să vorbim puțin despre Socket.io și Express înainte să intrăm în Sails. Există o serie de premii bune despre Express de Andrew Burgess dacă sunteți interesat, dar voi trece prin elementele de bază relevante ale ambelor biblioteci aici:
Socket.io este o bibliotecă pub / sub, care se execută atât pe server, cât și pe client și le permite să vorbească prin prize web.
Un exemplu scurt ar putea arăta astfel:
Accentsconagua
// Cod pentru Server var io = necesită ("socket.io"); io.sockets.on ("conexiune", funcție (sock)) sock.emit ("welcomeMessage", hello: "world"); io.listen (80); Acest cod începe prin solicitarea socket.io biblioteca, ascultarea pentru o conexiune, iar atunci când se conectează un alt soclu, acesta îi va trimite un mesaj adresat mesaj de intampinare eveniment, și în cele din urmă trecând de-a lungul unor JSON.
Apoi, pe client ați scrie ceva de genul:
// Cod pentru client Var sock = io.connect ('http: // localhost'); sock.on ('welcomeMessage', funcția (json) // Handle Event Received); Aici ne conectăm la server și ascultăm pentru asta mesaj de intampinare eveniment pe care l-am creat. După cum puteți vedea, este un server destul de simplu de publicare / abonare, care este bidirecțional (clientul ar putea emite și mesaje pentru server).
Acum, să aruncăm o privire la Express:
Cea mai simplă formă a unui traseu Express ar putea fi:
app.get ('/ users', funcția (req, res) res.send ("Hello from '/ users'!);); Aceasta definește un traseu simplu, astfel încât atunci când un utilizator merge la adresa site-ului dvs. și încearcă să acceseze / utilizatori , vor fi prezentate cu mesajul "Bună ziua de la" / utilizatori "!".
Deci Express este un cadru pentru manipularea cererilor HTTP și Socket.io este o bibliotecă de comunicații websocket. Ceea ce a facut echipa Sails este harta tuturor rutelor Express catre Socket.io intern. Ce înseamnă asta, puteți apela oricare dintre rutele HTTP prin prize web.
Acum e destul de cool! Dar, mai este încă o bucată de puzzle lipsă și asta este Sails Blueprints.
Sailurile vă permit să generați modele la fel ca în alte cadre, diferența fiind că, Sails poate genera, de asemenea, un API complet de producție RESTfull pentru a merge cu ele. Aceasta înseamnă că dacă generezi un model numit "utilizatori'puteți rula imediat RESTceleple interogări pe'/ utilizatori"resursă fără codificare necesară.
Dacă sunteți nou în API-urile RESTful, este doar o modalitate de a accesa datele, unde operațiile CRUD sunt mapate la diverse metode HTTP.
Deci a OBȚINE cererea de a "/ utilizatori"va primi toți utilizatorii, a POST cererea va crea un utilizator nou, etc.
Deci, ce înseamnă toate acestea?
Aceasta înseamnă că avem un API complet RESTfull, mapat la Socket.io prin Sails, fără a scrie o singură linie de cod!
Dar de ce socket-urile sunt mai bune la recuperarea datelor, atunci o solicitare Ajax? Ei bine, pe lângă faptul că sunt un protocol mai slab, prizele sunt deschise pentru comunicarea bidirecțională, iar Sails a profitat de acest lucru. Sails nu va transmite doar datele dvs., dar vă va abona automat la actualizări din respectiva bază de date și, ori de câte ori se vor adăuga, elimina sau actualiza ceva, clientul dvs. va primi o notificare prin intermediul site-ului web, permițându-vă să știți despre el.
De aceea, Sails este atât de minunat!
Următorul subiect pe care aș dori să-l acordez este integrarea Backbone, deoarece dacă nu utilizați un cadru JavaScript, faceți acest lucru greșit.
Având în vedere acest lucru, Sails și Backbone sunt perechea perfectă. Spinele, ca și Sails, este extrem de discret, toate caracteristicile sale sunt disponibile, pot fi suprasolicitate și opționale.
Dacă ați folosit Backbone înainte de a ști că se conectează în mod natural cu API-urile REST, astfel că puteți ieși din cutie, puteți sincroniza datele din front-end cu aplicația Sails.
Dar să vorbiți destul pentru moment, să aruncăm o privire la toate acestea în acțiune creând o aplicație de bază de chat. Pentru a începe, deschideți o fereastră terminal și tastați:
sails noi ChatApp cd ChatApp sailuri generare model utilizatori sailuri generare mesaje mesaje sailuri generare controler mesaje navigabile genera controler principal
Aceasta va crea o aplicație nouă și va genera câteva fișiere pentru noi. Puteți vedea de sus, există două resurse diferite pe care le puteți genera; modele și controlori. Dacă sunteți familiarizat cu modelul de proiectare MVC, atunci ar trebui să știți care sunt acestea, dar pe scurt, modelele sunt datele dvs. și controlorii țineți codul logic. Așadar, vom avea nevoie de două colecții, una pentru a ține utilizatorii și una pentru mesaje.
Apoi, pentru controlorii, avem nevoie de unul pentru a gestiona rutele paginii, l-am numit "principal', atunci avem un al doilea controler numit'mesaje“. Acum vă puteți întreba de ce am creat un controler cu același nume ca al nostru mesaje model? Dacă îți amintești, am spus că Sails poate crea un API REST pentru tine. Ce se întâmplă este crearea unui controler gol, cu același nume ca un model, Sails va ști să renunțe și să construiască un API REST pentru resursa corespunzătoare.
Deci, am creat un controlor pentru noi mesaje model, dar nu este nevoie să creați unul pentru modelul utilizatorilor, așa că am lăsat-o afară. Și asta este tot ce trebuie să faceți pentru a crea modele și controlori.
Apoi, să stabilim câteva rute.
Rutele sunt întotdeauna un loc sigur pentru a începe, pentru că aveți, de obicei, o idee bună despre paginile care vor fi făcute.
Așa că deschideți routes.js fișier care se află în config , ar putea părea puțin copleșitor la început, dar dacă eliminați toate comentariile și adăugați-le în următoarele rute, veți rămâne cu ceva similar:
"/": control: 'main', action: 'signup', '/ login': controler: 'main', acțiune: 'login', '/ chat': controller: 'main', acțiune: 'chat';
Avem o pagină de pornire, o pagină de chat și apoi două pagini pentru a gestiona atât paginile de conectare, cât și paginile de înscriere. Le-am pus pe toate în același controler, dar în Sails, puteți crea cât mai mulți controlori pe cât doriți.
Apoi, să aruncăm o privire la generat mesaje model care poate fi localizat la "api> modele> Messages.js"Trebuie să adăugăm coloanele necesare modelului nostru.Acum, acest lucru nu este absolut necesar, dar va crea câteva funcții de ajutor pentru noi pe care le putem folosi:
// Mesaje Modelul module.exports = atribute: userId: 'INT', numele utilizatorului: 'STRING', mesaj: 'STRING';
Pentru mesaje model, începem cu id a utilizatorului din care face parte acest mesaj, a nume de utilizator așa că nu va trebui să interogăm acest lucru separat și apoi real mesaj.
Acum să completăm modelul utilizatorului:
// Modele utilizator module.exports = atribute: nume utilizator: 'STRING', parola: 'STRING';
Și asta este, noi avem doar nume de utilizator și parola atribute. Următorul pas este de a crea funcțiile noastre de rută în interiorul MainController.
Așa că deschideți MainController, care poate fi găsit la "API> controlere> MainController.js"Să începem prin crearea unei funcții pentru fiecare dintre rutele definite mai sus:
var MainController = index: funcția (req, res) , înscriere: funcția (req, res) , login: funcția (req, res) , chat: funcția (req, res) ; module.exports = MainController;
Dacă sunteți familiarizat cu Express, atunci veți fi bucuroși să vedeți că aceste funcții sunt funcții standard ale expresiei rutei. Ei primesc două variabile, req pentru solicitarea HTTP și res pentru a crea răspunsul.
Urmând modelul MVC, Sails oferă o funcție de vizualizare. Pagina de start nu are nevoie de ceva special, așa că trebuie să facem vizualizarea.
index: funcție (req, res) res.view (); ,
Sailurile se bazează mai mult pe convenție asupra configurației, deci atunci când sunați res.view (); Sails va căuta un fișier de vizualizare (cu .Ejs extensie în mod prestabilit) utilizând următorul model: "vizualizări> controllerName> methodName.ejs“. Deci, pentru acest apel, va căuta "vizualizări> principale> index.ejs“. De asemenea, merită remarcat faptul că aceste vizionări conțin doar părțile specifice ale paginii. Dacă aruncați o privire la "vizualizări> layout.ejs', veți vedea un apel în mijloc pentru <%- body %>, acesta este locul în care va fi inserat fișierul dvs. de vizualizare. În mod implicit,layout.ejs', dar puteți utiliza și alte fișiere de aspect doar prin trecerea numelui de layout în res.view () funcție, sub proprietatea denumită "layout". De exemplu: 'res.view (layout: "other.ejs");'.
Voi folosi fișierul cu layout implicit cu o mică ajustare, voi adăuga jQuery, Backbone și Underscore. Deci,layout.ejs"înainte de închidere tag, adăugați următoarele rânduri:
Cu asta, suntem gata să creăm pagina de pornire.
Să creăm un nou dosar în interiorul vizualizari dosarul numit principal, și în interiorul noului nostru principal , vom crea un nou fișier numit 'index.ejs'.
În interiorul fișierului, să creăm doar un formular de logare și de înregistrare:
Cod de discuție
Logare
Inscrie-te
Destul de simplu, doar esențiale.
Apoi trebuie să adăugăm un mic JS pentru a obține comunicarea cu serverul. Acum, acest lucru nu va fi Sails specific, vom trimite doar o cerere AJAX prin jQuery la serverul Sails.
Acest cod poate fi inclus pe pagina însăși sau încărcat printr-un fișier separat JS. Din motive de comoditate, o să o pun în partea de jos a aceleiași pagini:
Toate acestea sunt doar standard JS și jQuery, ascultăm pentru evenimentul de clic pe butonul de conectare, asigurându-ne că sunt completate câmpurile de nume de utilizator și parola și postarea datelor în "/Logare' traseu. Dacă datele de conectare au succes, redirecționăm utilizatorul la pagina de chat, altfel vom afișa eroarea returnată de server.
Apoi, să creăm același lucru pentru zona de înscriere:
$ ("# signupButton") faceți clic pe (funcția () var username = $ ("# signupName" # (nume utilizator, parolă: parolă, funcție () fereastră. ("Eroare:" + res.getResponseHeader ("error"));); altceva alert ("Parolele nu se potrivesc") ; altceva alert ("Este necesar un nume de utilizator și o parolă");); Acest cod este aproape identic, atât de mult, încât probabil puteți doar să abstracți întregul Ajax în funcția sa proprie, dar pentru acest tutorial este bine.
Acum trebuie să ne întoarcem la "MainController"și de a gestiona aceste două rute, dar înainte de a face acest lucru, vreau să instalați un modul Nod. Va trebui să ștergem parola, așa cum sunt parolele textului simplu nu un lucru bun, nici măcar pentru demonstrație! Am găsit un modul frumos numit "parola-hash" de David Wood, care va funcționa frumos.
Pentru ao instala, trebuie doar să accesați rădăcina aplicației dvs. Sails, din interiorul terminalului și să tastați: npm instalează parola-hash.
Odată ce se instalează, hai să deschidem MainController și să pună în aplicare cele două căi necesare. Sa incepem cu Inscrie-te:
înscriere: funcția (req, res) var username = req.param ("username"); var parola = req.param ("parola"); Utilizator.findByUsername (username) .done (functie (err, usr) if (err) res.send (500, eroare: "DB Error" eroare: "Utilizator deja luat"); altceva var hasher = solicita ("parola-hash"), password = hasher.generate (parola); făcut (funcția (eroare, utilizator) if (eroare) res.send (500, eroare: "eroare DB"); );); Este un pic verbose, dar tot ceea ce facem aici este citirea numelui de utilizator și a parolei din cererea POST și asigurarea că numele de utilizator nu este deja luat. Puteți vedea că folosesc și parola-hasher pe care tocmai am instalat-o, este foarte simplu de folosit, trebuie doar să treci parola în metoda de generare și o să-l folosești folosind o sare aleatorie.
De asemenea, merită menționat faptul că, în orice locație posibilă în care se întâmpină o eroare sau o problemă, trimitem înapoi un cod de eroare HTTP și returnează un mesaj printr-un antet personalizat numit "eroare"care, dacă vă aduceți aminte, afișăm într-un mesaj de alertă pe pagina index.
Un alt punct demn de remarcat este faptul că folosim o funcție "magică" numită "findByUsername", acest lucru este posibil datorită faptului că avem nume de utilizator în interiorul modelului utilizatorilor noștri.
În final, în partea de jos puteți vedea dacă totul a mers bine, stocăm utilizatorul într-o variabilă de sesiune și îl returnează cu un cod de stare implicit de 200, ceea ce îi va spune jQuery că cererea AJAX a avut succes.
În continuare, să scriem funcția de conectare:
login: funcția (req, res) var username = req.param ("username"); var parola = req.param ("parola"); Utilizatorul.findByUsername (username) .done (functie (err, usr) if (err) res.send (500, eroare: DB Error; "parola hash"); if (hasher.verify (parola, usr.password)) req.session.user = usr; res.send (usr); res.send 400, eroare: Parola); altceva res.send (404, eroare: "Utilizatorul nu a fost găsit");); Din nou, aceasta este foarte asemănătoare cu cea anterioară Inscrie-te funcția, căutăm un utilizator cu același nume de utilizator care a fost postat din formular și dacă acesta se găsește, verificăm dacă parola se potrivește cu cea a lui hasher verifica metodă. Motivul pentru care nu putem restabili parola din nou și îl putem transfera în modele găsi funcția se datorează faptului că șahul folosește o sare aleatorie, așadar dacă am reintrodus parola, ar fi egală cu altceva.
Restul codului este același; dacă totul verifică, stocăm utilizatorul într-o sesiune și îl returnează, altfel trimitem un mesaj de eroare.
Sistemul de conectare este acum complet și, în sfârșit, putem trece la crearea funcției de chat.
Deoarece vom folosi Backbone pentru a obține mesajele, funcția de rutare reală va fi foarte simplă. Iată funcția completă de chat:
chat: funcția (req, res) if (req.session.user) res.view (username: req.session.user.username); altceva res.redirect ('/'); Începem prin a verifica dacă utilizatorul este conectat sau nu, în cazul în care acesta verifică, atunci acesta va încărca vizualizarea, trecându-l numele de utilizator care a fost în sesiune, altfel noi redirecționează doar la pagina de start.
Acum, să creați o nouă vizualizare numită "chat.ejs"în interiorul principal pliant. Deschideți-l și să creați un formular simplu pentru a posta mesaje noi și a div container pentru afișarea tuturor acestora.
Bine ati venit <%= username %>
Deci, pentru această vizualizare, am folosit doar câteva standard HTML standard. Singurul lucru care poate necesita o explicație este <%= username %> cod, acest stil de codificare nu este specific pentru Sails, este de fapt sintaxa pentru EJS. Această sintaxă este foarte asemănătoare cu etichetele scurte ale PHP. <% este echivalentul lui în PHP și <%= este la fel ca . Primul fragment al EJS vă permite să integrați codul JS standard pe pagină, în timp ce cel de-al doilea imprima codul înăuntru. Aici tipăm numele de utilizator pe care l-am trimis de la operator.
Restul funcției noastre de chat vor fi toate JavaScript. Pentru a începe, să aruncăm o privire asupra modului în care veți scrie funcția de chat utilizând standardul Backbone și apoi vom vedea cum să profitați de prizele Web.
În partea de jos a paginii, adăugați următoarele JS:
Deoarece Sails creează automat un API pe care Backbone îl înțelege nativ, nu trebuie să fie scris un cod de server suplimentar, acesta nu este mult mai ușor decât acesta. Despre asta am vorbit când am spus că Sails nu a fost făcut ca un "cadru". Nu încearcă să te facă să-ți folosești propria sintaxă, a fost făcută pentru a face lucrurile și după cum puteți vedea, ea oferă.
Pentru a le testa, deschideți o fereastră de terminal și navigați la folderul App Sails, apoi tastați "navighează înălțime"să o pornească. Implicit se va lansa la http: // localhost: 1337. Acum, doar înregistrați și postați câteva mesaje.
Pentru a vedea mesajele postate puteți console.log variabila mesajelor sau să o priviți în interiorul consolei browserului. Acum, următorul lucru pe care ar trebui să-l implementăm este o vizualizare pentru a putea vedea mesajele afișate în browser.
_.templateSettings = interpolate: /\\(.+?)\\/g; var MesajeView = Backbone.View.extend (el: '#messagesContainer', initialize: function () this.collection.on ('adauga', this.render, this); this.render (); _.template (“message
"), render: funcția () this. $ el.html (" "); this.collection.each (funcția (msg) this. $ el.append (this.template (msg.toJSON ()); ,); var mView = Mesaje noi (colecție: mesaje); Începem prin definirea unei vizualizări, atașând-o la div-ul pe care l-am creat mai devreme, apoi adăugăm un handler de evenimente pe colecție pentru a re-reda div-ul de fiecare dată când un nou model se adaugă colecției.
Puteți vedea în partea de sus, a trebuit să modific setările implicite Underscore de la utilizarea sintaxei EJS din interiorul șabloanelor, în schimb, utilizați sintaxa Mustache. Acest lucru se datorează faptului că pagina este deja un document EJS, deci ar fi procesat pe server și nu în Underscore.
Notă: Nu am venit cu Regex pentru asta, că creditul se duce la documentele Subscore.
În sfârșit, în partea de jos puteți vedea că am creat o nouă instanță a acestei vizualizări, trecând-o cu variabila de colectare.
Dacă totul a mers bine, ar trebui să vedeți mesajele dvs. în browser și ar trebui să se actualizeze ori de câte ori creați un post nou.
Acum ați fi observat că nu o stabilim numele de utilizator sau nume de utilizator atunci când trimitem mesajele, iar acest lucru este în scopuri de securitate.
Nu doriți să puneți acest tip de control pe partea clientului. Dacă cineva trebuie să facă este să modificați o variabilă JavaScript pentru a controla contul altui utilizator, veți avea o problemă majoră.
Deci, cum ar trebui să rezolvi asta? Ei bine, cu politicile desigur.
Politicile sunt, în principiu, middleware, care se desfășoară înainte de solicitarea web reală, unde puteți opri, modifica sau chiar redirecționa solicitarea, după cum este necesar.
Pentru această aplicație, să elaborăm o politică pentru mesajele noastre. Politicile sunt aplicate controlorilor, astfel încât acestea pot fi chiar rulate pe pagini normale, dar pentru acest tutorial trebuie doar să rămânem cu unul pentru noi mesaje Model.
Creați un fișier numit "MessagesPolicy.js" în interiorul "api> politici'și introduceți următoarele:
modul.exports = functie (req, res, urmatoarea) if (req.session.user) var action = req.param ('action'); dacă (acțiune == "crea") req.body.userId = req.session.user.id; req.body.username = req.session.user.username; Următor →(); altceva res.send ("Trebuie să fiți logat", 403); ; Deci, ce se întâmplă aici? Puteți vedea că această funcție seamănă cu o funcție normală a rutei, însă diferența este al treilea parametru, care va apela următorul middleware din stivă. Dacă sunteți nou la ideea de middleware, vă puteți gândi la ea ca pe o păpușă rusă. Fiecare nivel primește cererea împreună cu variabilele de răspuns și le poate modifica după cum consideră potrivit. Dacă îndeplinesc toate cerințele, stratul poate trece mai departe, până când ajunge la centru, care este funcția de traseu.
Deci, aici suntem, verificând dacă utilizatorul este conectat, dacă utilizatorul nu este, vom afișa o eroare 403 și cererea se termină aici. În caz contrar, (adică utilizatorul este conectat) sunăm Următor →(); să o transmiteți. În mijlocul codului de mai sus, este locul unde vom injecta unele variabile post. Aplicăm acest lucru la toate apelurile de la controlerul "mesaje" (în principiu API-ul), deci primim acțiunea și verificăm dacă această solicitare încearcă să creeze un mesaj nou, caz în care adăugăm câmpurile pentru mesajele utilizatorilor id și nume de utilizator.
Apoi, deschideți policies.js fișier care se află în dosarul Config și adăugați politica pe care tocmai am creat-o. Deci, fișierul dvs. ar trebui să arate astfel:
module.exports.policies = '*': true, 'mesaje': 'MessagesPolicy';
Cu acest lucru pus în loc, va trebui să ștergem toate înregistrările vechi, deoarece acestea nu au aceste noi informații. Deci, închideți serverul Sails (ctrl-c) și în același tip de fereastră: rm -r .tmp pentru a elimina baza de date temporară oferindu-ne o ardezie curată.
Apoi, să adăugăm numele de utilizator la postările reale, așa că în "chat.ejs" schimbați șablonul pentru a:
template: _.template (" nume de utilizator : message
„), Reporniți serverul Sails (din nou folosind navighează înălțime) și să înscrieți un alt utilizator nou pentru al testa. Dacă totul funcționează corect, ar trebui să puteți adăuga mesaje și să vedeți numele dvs. în post.
În acest moment avem o configurație destul de bună, luăm automat postul folosind Backbone și API, plus avem o siguranță de bază în vigoare. Problema este că nu se va actualiza atunci când alte persoane vor posta mesaje. Acum puteți rezolva acest lucru prin crearea unui interval JavaScript și a sondajului pentru actualizări, dar putem face mai bine.
Am menționat mai devreme că Sails folosește abilitățile bidirecționale ale site-urilor pentru a posta actualizări privind datele abonate. Folosind aceste actualizări, putem asculta noi adăugări la tabelul de mesaje și actualizăm colecția în consecință.
Deci, în chat.ejs fișier, să creăm un nou tip de colecție; o SailsCollection:
var SailsCollection = Backbone.Collection.extend (sailsCollection: "", socket: null, sync: function (metoda, modelul, optiunile) var unde = ; unde dacă (tipul de acest.sailsCollection === "string" && this.sailsCollection! == "") this.socket = io.connect (); this.socket.on (" function () this.socket.request ("/" + this.sailsCollection, unde, _.bind (function (users) this.set (users);)); this.socket.on ", _.bind (funcția (msg)) var m = msg.uri.split (" / ") pop (); altfel dacă (m === "actualizare") this.get (msg.data.id) .set (msg.data); altceva dacă (m === "distruge") this.remove (this.get ("Eroare: Imposibil de recuperat modelele deoarece proprietatea" sailsCollection "nu este setată pe colecție");), aceasta)); ); Acum poate că este lung, dar de fapt este foarte simplu, să trecem prin el. Începem prin adăugarea a două proprietăți noi în obiectul Colecție, unul care să dețină numele modelului Sails și unul pentru a ține socketul web. Apoi, modificăm sincronizați Dacă sunteți familiarizat cu Backbone, atunci veți ști că aceasta este funcția care interfețează cu serverul atunci când apelați lucruri cum ar fi aduce. De obicei, se declanșează cererile Ajax, dar o vom personaliza pentru comunicarea cu socket-uri.
Acum, nu folosim cea mai mare parte a funcționalității sincronizați ofertele de funcții, în principal pentru că nu am adăugat abilitatea utilizatorilor de a actualiza sau șterge mesaje, ci doar să fie complete, le voi include în definiția funcțiilor.
Să aruncăm o privire la prima parte a paginii sincronizați funcţie:
var unde = ; dacă (opțiuni unde) where = where: options.where
Acest cod verifică mai întâi dacă există "Unde"au fost trimise clauze, aceasta vă va permite să faceți lucruri precum: messages.fetch (unde: id: 4); pentru a prelua numai rânduri în cazul în care ID-ul este egal cu patru.
După aceea, avem apoi un cod care asigură că "sailsCollection'a fost setată, altfel vom înregistra un mesaj de eroare. Ulterior, vom crea un nou socket și vom conecta la server, ascultând pentru conexiunea cu pe ( „conecta“) eveniment.
După conectare, solicităm indexul "sailsCollection"specificat pentru a trage în lista actuală de modele. Când primește datele, folosim colecțiile a stabilit pentru a seta inițial modelele.
Bine, acum, până acum, avem echivalentul standardului aduce comanda. Următorul bloc de cod este locul în care se produc notificările push:
acest lucru este incomplet si incomplet, dar nu inseamna ca acest lucru este incomplet. adăugați (msg.data); altceva dacă (m === "actualizare") this.get (msg.data.id) .set (msg.data); altceva dacă (m === "distruge") this.remove (this.get (msg.data.id));, aceasta));
Acum, acțiunea care se realizează (indiferent dacă creăm, actualizăm sau distrugem un mesaj) poate fi găsită în interiorul msg, care este apoi în interiorul uri. Pentru a obține acțiunea, împărțim URI pe slash-urile din față ('/') și luăm doar ultimul segment folosind pop funcţie. Apoi, încercăm să o combinăm cu cele trei posibile acțiuni ale lui crea, Actualizați, sau distruge.
Restul este standardul Backbone, adăugăm, edificăm sau eliminăm modelul specificat. Cu noua noastră clasă aproape completă, tot ce trebuie să faceți este să schimbați curentul MessageCollection. În loc să extinde colecția Backbone, trebuie să extindem noua noastră colecție, cum ar fi:
var MessageCollection = SailsCollection.extend (sailsCollection: 'mesaje', model: MessageModel);
În plus față de extinderea noii colecții, vom face o altă modificare, astfel încât, în loc să setăm proprietatea adresei URL, vom seta acum proprietatea sailsCollection. Și asta e totul pentru asta. Deschideți aplicația în două browsere diferite (de exemplu, Chrome și Safari) și înregistrați doi utilizatori separați. Ar trebui să vedeți că mesajele postate de la oricare dintre browsere se afișează imediat pe cealaltă, fără a fi verificate, fără probleme.
Sails este o gură de aer proaspăt, într-o aglomerație de cadre. Ea își verifică ego-ul la ușă și face tot ce poate pentru a ajuta dezvoltatorul în locul brandului. Am vorbit cu Sails devs și pot să vă spun că există și mai multe minunate lucrări și va fi interesant să vedem unde merge acest cadru.
Deci, în concluzie, ați învățat cum să configurați, să utilizați și să vă securizați datele din Sailuri, precum și cum să le interfați cu biblioteca populară Backbone.
Ca de obicei, dacă aveți comentarii, nu ezitați să le lăsați mai jos sau să vă alăturați pe canalul IRt Nettuts + ("#nettuts" pe freenode). Mulțumesc că ați citit.
