Share
Sails.js är en uppåtgående Node.js ram, med fokus på frihet och smarta standardinställningar. I den här artikeln tar vi en titt på några av de datafunktioner som Sails ger ut ur rutan, för att enkelt göra komplexa appar.
Anledningen till att välja seglar är bäst av Segel skaparen Mike McNeil, "Seglar skapades av nödvändighet". Många ramverk som du ser runt är byggda nästan för akademiska sidan av saker, dessa ramar brukar skapa bästa praxis och skapa en plattform för utvecklare att skapa saker snabbare eller bättre.
Seglar å andra sidan skapades för produktion, det försöker inte ge dig en ny syntax eller plattform, det är en solid bas, avsedd för att skapa "klientarbete" med fart. Kontrasten kan vara subtil, men det finns några tydliga skillnader.
För att illustrera vad jag hänvisar till, låt oss ta en titt på Meteor. Meteor är förmodligen den ledande JS-plattformen runt idag, men det är ett utmärkt exempel på ett ramverk, för en rams skull. Nu är det inte dåligt, jag är en stor supporter av Meteor, vad jag menar är att de satt upp för att bygga en ram och de gjorde ett bra jobb åt det, men Mike bestämde sig för att göra klientarbetet snabbare . Segel är bara ett sätt att nå ett slut.
I Meteor är nästan allt allting abstrakt och du använder JavaScript plus Meteor API för att koda allt. Segel är inte tänkt att vara en ny plattform, så ingenting är dolt.
Den ligger på toppen av Socket.io och den populära Express-ramen, och du har tillgång till dem i sin helhet, nationellt. Börjar du se skillnaden?
Eftersom Sails är inriktad på produktion först, är den byggd med flera alternativ för skalning och säkerhet.
Det finns mycket att prata om, men i den här artikeln vill jag fokusera på hur Sails hanterar data och hur du kan utnyttja några av Sails mer avancerade funktioner för att utföra några riktigt coola åtgärder.
Bara om du inte har Sails påpekat än, kan du göra det via NPM genom att springa:
sudo npm installera -g segel
Låt oss nu prata lite om Socket.io och Express innan vi kommer in i Segel. Det finns en bra premiumserie på Express av Andrew Burgess om du är intresserad, men jag går igenom de relevanta grunderna i båda dessa bibliotek här:
Socket.io är ett pub / sub-bibliotek, som körs på både servern och klienten, och det låter dem prata via webbuttag.
Ett kort exempel kan se ut så här:
Accentsconagua
// Kod för server var io = kräver ("socket.io"); io.sockets.on ("connection", funktion (sock) sock.emit ("welcomeMessage", hej: "world"); io.listen (80); Denna kod börjar genom att kräva socket.io bibliotek, lyssnar på en anslutning, och sedan när ett annat uttag ansluts kommer det att skicka det ett meddelande, adresserat till välkomstmeddelande händelse, och slutligen passerar längs några JSON.
Därefter skriver du på klienten något som:
// Kod för klient var sock = io.connect ('http: // localhost'); sock.on ('welcomeMessage', funktion (json) // Handle Event Received); Här kopplar vi oss till servern och lyssnar på det välkomstmeddelande händelse som vi just skapat. Som du kan se är det en ganska enkel publicerings- / prenumerationsserver, som är dubbelriktad (klienten kan också skicka meddelanden till servern).
Låt oss nu ta en titt på Express:
Den enklaste formen av ett Express-rutt kan vara något som:
app.get ('/ users', funktionen (req, res) res.send ("Hej från" / användare "!");); Detta definierar en enkel rutt, så att när en användare går till din webbplatsadress och försöker komma åt / användare sida kommer de att presenteras med meddelandet "Hej från" / användare "!".
Så Express är ett ramverk för hantering av HTTP-förfrågningar och Socket.io är ett webbsockelkommunikationsbibliotek. Vad segellaget har gjort, är dock alla Express-rutter till Socket.io internt. Vad det här betyder är att du kan ringa någon av HTTP-rutterna via webbuttag.
Nu är det ganska coolt! Men det finns fortfarande en del av pusslet saknas och det är Sails Blueprints.
Seglar kan du skapa modeller precis som i andra ramar, skillnaden är, Seglar kan också generera en produktionsklar RESTfull API för att gå med dem. Det innebär att om du skapar en modell som heter "användare"du kan omedelbart köra RESTfull frågor på"/ användare"resurs utan kodning är nödvändig.
Om du är ny till RESTful APIs, är det bara ett sätt att komma åt data, till var CRUD-operationer är mappade till olika HTTP-metoder.
Så a SKAFFA SIG begära att '/ användare"kommer att få alla användare, a POSTA begäran kommer att skapa en ny användare, etc.
Så vad betyder allt detta?
Det betyder att vi har ett helt RESTfull API, mappat till Socket.io via Seglar, utan att skriva en enda kodlinje!
Men varför är uttag bättre för att hämta data då en Ajax-förfrågan? Tja, förutom att vara ett smidigare protokoll, håller du öppet för dubbelriktad kommunikation, och Sails har utnyttjat detta. Inte bara kommer Sails att skicka data till dig, men det kommer automatiskt att prenumerera på uppdateringar i den databasen, och när något läggs till, tas bort eller uppdateras kommer din klient att få en anmälan via nätkontakten och låta dig veta om det.
Det är därför Sails är så häftigt!
Nästa ämne som jag skulle vilja täcka är Backbone integration, för om du inte använder en JavaScript-ram gör du det fel.
Med detta i åtanke är Sails och Backbone det perfekta paret. Ryggraden, som Seglar, är extremt diskret, alla dess funktioner är tillgängliga, kan överträffas och valfria.
Om du har använt Backbone innan du kanske vet att den är ansluten med REST API, så kan du synkronisera data i fronten med din Sails applikation.
Men tillräckligt tal för nu, låt oss ta en titt på allt detta i åtgärd genom att skapa en grundläggande chattprogram. För att komma igång, öppna ett terminalfönster och skriv:
seglar nya ChatApp-cd ChatApp-seglar generera modellanvändare seglar generera modellmeddelanden seglar generera controllermeddelanden seglar generera controller huvud
Det här skapar en ny app och genererar några filer för oss. Du kan se ovanifrån, det finns två olika resurser som du kan generera; modeller och kontroller. Om du är bekant med MVC-designmönstret, bör du veta vad det är, men kort sagt, modeller är dina data och kontroller hålla din logik kod. Så vi behöver två samlingar, en för att hålla användarna och en för meddelandena.
Därefter behöver vi en för att styra sidorna, för kontrollerna, jag kallade den "huvud', då har vi en andra controller som heter'meddelanden'. Nu kanske du undrar varför jag skapade en controller med samma namn som vår meddelanden modell? Tja, om du kommer ihåg, sa jag att Segel kan skapa ett REST API för dig. Vad som händer är att, genom att skapa en blank kontroller med samma namn som en modell, kommer Sails att veta att falla tillbaka och bygga ett REST API för motsvarande resurs.
Så, vi har skapat en kontroller för vår meddelanden modell, men det finns inget behov av att skapa en för användarnas modell, så jag har bara lämnat den. Och det är allt det finns att skapa modeller och controllers.
Låt oss sedan konfigurera några vägar.
Rutter är alltid ett säkert ställe att börja, för du brukar ha en bra uppfattning om vilka sidor som ska göras.
Så öppna upp routes.js fil som finns i config mappen kan det vara lite överväldigande först, men om du tar bort alla kommentarer och lägger till i följande rutter kommer du att vara kvar med något av följande:
module.exports.routes = '/': controller: 'main', åtgärd: 'index', '/ signup': controller: 'main', åtgärd: 'signup', '/ login' controller: 'main', action: 'login', '/ chat': controller: 'main', åtgärd: 'chat';
Vi har en hemsida, en chattsida och sedan två sidor för hantering av både inloggnings- och registreringssidor. Jag sätter dem alla i samma kontroller, men i Seglar kan du skapa så många controllers som du vill.
Låt oss nu ta en titt på den genererade meddelanden modell som kan placeras vid "api> modeller> Messages.js"Vi behöver lägga till de nödvändiga kolumnerna till vår modell. Nu är det inte absolut nödvändigt, men det kommer att skapa några hjälpfunktioner för oss som vi kan använda:
// Meddelanden Modell module.exports = attribut: userId: 'INT', användarnamn: 'STRING', meddelande: 'STRING';
För meddelanden modell börjar vi med id av användaren som detta meddelande tillhör, a Användarnamn så vi behöver inte fråga detta separat och sedan själva meddelande.
Låt oss nu fylla i användarens modell:
// Användare Modell module.exports = attribut: användarnamn: 'STRING', lösenord: 'STRING';
Och det är det, vi har bara Användarnamn och Lösenord attribut. Nästa steg är att skapa våra färdfunktioner inuti MainController.
Så öppna upp MainController, som finns på "api> controllers> MainController.js". Låt oss börja med att skapa en funktion för var och en av de rutter vi definierade ovan:
Var MainController = index: funktion (req, res) , registrering: funktion (req, res) , inloggning: funktion (req, res) , chatt: funktion (req, res) ; module.exports = MainController;
Om du är bekant med Express, så ser du gärna att dessa funktioner är standard Express-rutfunktioner. De får två variabler, req för HTTP-förfrågan och res för att skapa svaret.
Efter MVC-mönstret erbjuder Sails en funktion för att göra visningar. Hemsidan behöver inget speciellt, så låt oss bara göra vyn.
index: funktion (req, res) res.view (); ,
Seglar lutar mer mot konvention över konfiguration, så när du ringer res.view (); Seglarna letar efter en visningsfil (med en .EJS förlängning som standard) med följande mönster: 'visningar> controllerName> methodName.ejs'. Så för det här samtalet kommer det att söka efter "visningar> main> index.ejs'. Det är också värt att notera, dessa synpunkter innehåller bara de visningsspecifika delarna av sidan. Om du tittar på "visningar> layout.ejs', du kommer att se ett samtal i mitten för <%- body %>, Det här är var din visningsfil kommer att införas. Som standard använder den här "layout.ejs'fil, men du kan använda andra layoutfiler bara genom att skicka layoutnamnet till res.view () funktion, under egenskapen "layout". Till exempel: 'res.view (layout: "other.ejs");'.
Jag ska använda standardlayoutfilen med en liten justering, jag ska lägga till jQuery, Backbone och Underscore. Så i "layout.ejs'filen precis före stängningen tagg, lägg till följande rader:
Med det på plats är vi nu redo att skapa hemsidan.
Låt oss skapa en ny mapp inuti visningar mapp heter huvud, och inuti vårt nya huvud mapp skapar vi en ny fil med namnet index.ejs.
Inne i filen kan vi bara skapa en inloggnings- och anmälningsblankett:
Kod Chat
Logga in
Bli Medlem
Ganska enkelt, bara de viktigaste.
Nästa måste vi lägga till en liten JS för att få det att kommunicera med servern. Nu kommer det inte att vara Sails specifikt, vi ska bara skicka en AJAX-förfrågan via jQuery till Sails-servern.
Denna kod kan antingen inkluderas på själva sidan eller laddas in via en separat JS-fil. För enkelhets skull kommer jag bara att lägga den längst ner på samma sida:
Det här är bara standard JS och jQuery, vi lyssnar på klickhändelsen på inloggningsknappen och ser till att användarnamnet och lösenordsfälten fylls i och skickar data till "/logga in"rutt. Om inloggningen lyckas, omdirigerar vi användaren till chattsidan, annars kommer vi att visa felet som returneras av servern.
Låt oss sedan skapa samma sak för registreringsområdet:
val (); var lösenord = $ ("# signupPassword") .val (); var confirmPassword = $ ("# signupButton"). #signupConfirmPassword ") .val (); om (användarnamn och & lösenord) if (password === confirmPassword) $ .post ('/ signup', användarnamn: användarnamn, lösenord: lösenord, funktion location = "/ chat";) .fail (funktion (res) alert ("Fel:" + res.getResponseHeader ("error")); else alert ("Lösenorden matchar inte") ; else alert ("Ett användarnamn och lösenord krävs");); Koden är nästan identisk, så mycket att du förmodligen bara kan sammanfatta hela Ajax-delen ut i sin egen funktion, men för den här handledningen är det bra.
Nu måste vi gå tillbaka till vår "MainController'och hantera dessa två vägar, men innan vi gör det vill jag installera en nodmodul. Vi kommer att behöva ha hash lösenordet, som vanliga text lösenord är inte en bra sak, inte ens för demonstration! Jag hittade en bra modul som heter "password-hash" av David Wood som kommer att fungera snyggt.
För att installera det, gå till roten till din Sails-app, från din terminal och typ: npm installera lösenord-hash.
När det är installerat, låt oss öppna MainController och genomföra de två nödvändiga rutterna. Låt oss börja med Bli Medlem:
registrering: funktion (req, res) var användarnamn = req.param ("användarnamn"); var lösenord = req.param ("lösenord"); Användare.findByUsername (användarnamn) .done (funktion (err, usr) om (err) res.send (500, error: "DB Error"); annars om (usr) res.send (400, error: "Användarnamn som redan tagits"); else var hasher = require ("password-hash"); lösenord = hasher.generate (lösenord); Users.create (användarnamn: användarnamn, lösenord: lösenord). gjort (funktion (fel, användare) if (error) res.send (500, error: "DB Error"; annat req.session.user = användare; res.send (användare); );); Det är lite verbose, men allt vi gör här läser användarnamnet och lösenordet från POST-förfrågan och ser till att användarnamnet inte redan är taget. Du kan se att jag också använder lösenordshackaren som vi just installerat, den är super enkel att använda, bara skicka lösenordet till genereringsmetoden och det kommer att ha det med ett slumpmässigt salt.
Det är också värt att nämna att vi på alla möjliga platser där vi kan stöta på ett fel eller problem, skickar tillbaka en HTTP-felkod och returnerar ett meddelande via en anpassad rubrik med namnet "fel", som, om du kommer ihåg, visas vi i ett varningsmeddelande på indexsidan.
En annan anmärkningsvärd punkt är att vi använder en "magisk" funktion som heter "findByUsername', detta är möjligt eftersom vi har en Användarnamn kolumn inuti vår användarmodell.
Slutligen kan du se om allt gick bra, vi lagrar användaren i en session variabel och returnerar den med en standardstatuskod på 200, vilket kommer att berätta för jQuery att AJAX-förfrågan var framgångsrik.
Sedan skriver vi inloggningsfunktionen:
inloggning: funktion (req, res) var användarnamn = req.param ("användarnamn"); var lösenord = req.param ("lösenord"); Användare.findByUsername (användarnamn) .done (funktion (err, usr) om (err) res.send (500, error: "DB Error"; annat if (usr) var hasher = require "password-hash"), om (hasher.verify (lösenord, usr.password)) req.session.user = usr; res.send (usr); annars res.send (400, error: "Wrong Lösenord "); annat res.send (404, error:" User not Found ");); Återigen, det här är mycket likt det föregående Bli Medlem funktion söker vi efter en användare med samma användarnamn som postades från formuläret och om det finns en, kontrollerar vi om lösenordet matchar med användning av hashers kontrollera metod. Anledningen till att vi inte bara kan ha lösenordet igen och överföra det till modellerna hitta funktionen är att hasheren använder ett slumpmässigt salt, så om vi har fått lösenordet igen skulle det vara lika med något annat.
Resten av koden är densamma; Om allt checkar ut, lagrar vi användaren i en session och returnerar den, annars skickar vi tillbaka ett felmeddelande.
Inloggningssystemet är nu komplett och vi kan äntligen fortsätta bygga chattfunktionen.
Eftersom vi använder ryggraden för att få meddelandena kommer den faktiska ruttfunktionen att vara mycket enkel. Här är den fullständiga chattfunktionen:
chatt: funktion (req, res) if (req.session.user) res.view (användarnamn: req.session.user.username); annars res.redirect ('/'); Vi börjar med att kontrollera om användaren är inloggad eller inte, om det här checkar ut, kommer det att läsa in vyn och överföra det användarnamnet som var i sessionen, annars omdirigerar vi bara till hemsidan.
Låt oss nu skapa en ny vy med namnet "chat.ejs"inuti huvud mapp. Öppna den och låt oss skapa en enkel blankett för att skicka nya meddelanden och a div behållare för att visa dem alla.
Välkommen <%= username %>
Så för den här vyn använde vi bara en ganska vanlig HTML. Det enda som kan kräva en förklaring är <%= username %> kod, den här typen av kodning är inte specifik för seglar, det är faktiskt syntaxen för EJS. Denna syntax ligner mycket på PHP: s korta taggar. <% motsvarar i PHP och <%= är det samma som . Det första stycket av EJS låter dig integrera standard JS-kod på sidan medan den andra skriver ut koden inom. Här skriver vi bara ut användarnamnet som vi passerade in från regulatorn.
Resten av vår chattfunktion blir alla JavaScript. För att komma igång, låt oss ta en titt på hur du skulle skriva chattfunktionen med hjälp av standard Ryggraden, och sedan får vi se hur man utnyttjar nätuttag.
Längst ner på sidan lägger du till följande JS:
Eftersom Sails automatiskt skapar ett API som Backbone förstår native, behöver ingen extra serverkod skrivas, det blir inte mycket lättare än det. Det här var vad jag pratade om när jag sa att Segel inte gjordes för att vara en "ram". Det försöker inte göra att du använder sin egen syntax, den gjordes för att få saker och ting, och som du kan se levererar den.
För att testa det, öppna ett terminalfönster och navigera till din Sails app mapp, skriv sedan "segellyft"för att starta upp det. Som standard kommer det att lanseras till http: // localhost: 1337. Nu registrerar du bara och skickar några meddelanden.
För att se dina meddelade meddelanden kan du console.log Meddelandena variabler, eller titta på det inuti webbläsarens konsol. Nu är nästa sak vi ska implementera en vy så att vi kan se de meddelade meddelandena i webbläsaren.
_.templateSettings = interpolate: /\\(.+?)\\/g; var MessagesView = Backbone.View.extend (el: '#messagesContainer', initiera: funktion () this.collection.on ('add', this.render, this); this.render ();, mall: _.mall("message
"), render: funktion () this. $ el.html (" "); this.collection.each (funktion (msg) this. $ el.append (this.template (msg.toJSON ())); , det här); var mView = nya meddelandenView (samling: meddelanden); Vi börjar med att definiera en vy och bifoga den till den div som vi skapade tidigare, då lägger vi till en händelsehanterare på samlingen för att återställa diven varje gång en ny modell läggs till i samlingen.
Du kan se överst, jag var tvungen att ändra standard Underscore-inställningar från att använda EJS-syntaxen inuti mallarna, istället använda mustaschens syntax. Detta beror på att sidan redan är ett EJS-dokument, så det skulle behandlas på servern och inte i Underscore.
Notera: Jag kom inte med Regex för det här, den här krediten går till Underscore docs själv.
Slutligen, längst ner kan du se att vi skapade en ny instans av denna vy, genom att överföra den samlingsvariabeln.
Om allt gick bra borde du nu se dina meddelanden i webbläsaren, och den ska uppdateras när du skapar ett nytt inlägg.
Nu har du kanske märkt att vi inte ställer in användar ID eller den Användarnamn när vi skickar in tjänsterna, och detta är för säkerhetsändamål.
Du vill inte sätta den här typen av kontroll på klientsidan. Om alla någon behöver göra är att ändra en JavaScript-variabel för att kontrollera en annan användares konto, har du ett stort problem.
Så hur ska du hantera detta? Tja, med politik självklart.
Politiken är i grunden middleware, som kör före den faktiska webbförfrågan, där du kan stoppa, ändra eller till och med omdirigera begäran, efter behov.
För den här appen, låt oss skapa en policy för våra meddelanden. Policy tillämpas på kontroller, så de kan även köras på normala sidor, men för den här handledningen kan vi bara hålla fast vid en för vår meddelanden Modell.
Skapa en fil med namnet 'MessagesPolicy.js' inuti 'api> policy'mapp och ange följande:
module.exports = funktion (req, res, nästa) if (req.session.user) var action = req.param ('action'); om (åtgärd == "skapa") req.body.userId = req.session.user.id; req.body.username = req.session.user.username; Nästa(); annars res.send ("Du måste vara inloggad", 403); ; Så vad händer här? Du kan se att denna funktion liknar en vanlig rutefunktion, skillnaden är dock den tredje parametern, som kommer att ringa nästa middleware i stapeln. Om du är ny på idén om middleware, kan du tänka på det som en rysk nestdocka. Varje lager får begäran, tillsammans med svarvariablerna och de kan ändra dem som de passar. Om de överensstämmer med alla krav, kan skiktet passera det vidare tills det når mitten, vilket är rutfunktionen.
Så här kontrollerar vi om användaren är inloggad, om användaren inte är, visar vi ett 403-fel och begäran slutar här. Annars (dvs. användaren är inloggad) ringer vi Nästa(); att vidarebefordra den. Mitt i ovanstående kod är där vi injicerar några postvariabler. Vi tillämpar detta på alla samtal på meddelandestyraren (i princip API), så vi får åtgärden och kontrollera om den här förfrågan försöker skapa ett nytt meddelande, i så fall lägger vi in postfälten för användarens id och Användarnamn.
Öppna sedan upp policies.js fil som finns i config-mappen och lägg till den policy som vi just skapat. Så din fil ska se ut så här:
module.exports.policies = '*': true, 'messages': 'MeddelandenPolicy';
Med det här inlägget måste vi ta bort alla gamla dokument, eftersom de inte har dessa nya bitar av information. Så stäng Sails-servern (ctrl-c) och i samma terminalfönster typ: rm -r.tmp att ta bort den temporära databasen som ger oss en ren skiffer.
Låt oss sedan lägga till användarnamnet till de aktuella inläggen, så i 'chat.ejs' ändras mallen till:
mall: _.template (" Användarnamn : message
"), Starta om serverns servern (igen med hjälp av segellyft) och registrera en annan ny användare för att testa det. Om allt fungerar korrekt ska du kunna lägga till meddelanden och se ditt namn i posten.
Vid denna tidpunkt har vi en ganska bra inställning, vi hämtar posten automatiskt med hjälp av Backbone och API, plus vi har viss grundläggande säkerhet på plats. Problemet är att det inte kommer att uppdateras när andra människor skickar in meddelanden. Nu kan du lösa detta genom att skapa ett JavaScript-intervall och en enkät för uppdateringar, men vi kan göra det bättre.
Jag nämnde tidigare att Sails utnyttjar websockets bidirectionella förmågor att lägga upp uppdateringar på den prenumererade data. Med hjälp av dessa uppdateringar kan vi lyssna på nya tillägg till meddelandetabellen och uppdatera samlingen i enlighet med detta.
Så i chat.ejs fil, låt oss skapa en ny typ av samling; en segelsamling:
var SailsCollection = Backbone.Collection.extend (sailsCollection: "" socket: null, synkronisering: funktion (metod, modell, alternativ) var where = ; if (options.where) where = where: options. var om (typ av this.sailsCollection === "string" && this.sailsCollection! == "") this.socket = io.connect (); this.socket.on ("connect", _.bind funktion () this.socket.request ("/" + this.sailsCollection, där, _.bind (funktion (användare) this.set (users);, this)); this.socket.on ("message ", _.bind (funktion (msg) var m = msg.uri.split (" / "). pop (); om (m ===" skapa ") this.add (msg.data); annars om (m === "uppdatering") this.get (msg.data.id) .set (msg.data); annars om (m === "förstör") this.remove (this.get (msg.data.id));, det här));, det här)); else console.log ("Fel: kan inte hämta modeller eftersom egenskapseglarna" inte anges i samlingen "); ); Nu kan det vara länge, men det är faktiskt väldigt enkelt, låt oss gå igenom det. Vi börjar med att lägga till två nya egenskaper i samlingsobjektet, en för att hålla namnet på segelmodellen och en för att hålla nätuttaget. Därefter ändrar vi synkronisera funktion, om du är bekant med Backbone så vet du att det här är den funktion som gränsar till servern när du ringer saker som hämta. Vanligtvis bränder den av Ajax-förfrågningar, men vi ska anpassa den till socket-kommunikation.
Nu använder vi inte de flesta av funktionaliteten som synkronisera funktion erbjudanden, främst för att vi inte har lagt till möjligheten för användare att uppdatera eller radera meddelanden, men bara för att vara komplett kommer jag att inkludera dem inom funktionsdefinitionen.
Låt oss ta en titt på den första delen av synkronisera fungera:
var var = ; om (options.where) where = where: options.where
Denna kod kontrollerar först om någon "var"klausuler skickades genom, det här låter dig göra saker som: messages.fetch (where: id: 4); att bara hämta rader där id är lika med fyra.
Därefter har vi någon kod som gör att "sailsCollection'Egenskapen har ställts in, annars loggar vi ett felmeddelande. Efteråt skapar vi ett nytt uttag och kopplar till servern, lyssnar på anslutningen med på ( 'ansluter') händelse.
När vi är anslutna, begär vi indexet för "sailsCollection'anges för att dra in den aktuella listan över modeller. När den tar emot data använder vi samlingens uppsättning funktion för att initiera modellerna.
Okej, nu hittills har vi motsvarande standarden hämta kommando. Nästa block av kod är där push-anmälningarna händer:
this.socket.on ("message", _.bind (funktion (msg) var m = msg.uri.split ("/"). pop (); om (m === "skapa") this. lägg till (msg.data); annars om (m === "uppdatering") this.get (msg.data.id) .set (msg.data); annars om (m === "förstör") this.remove (this.get (msg.data.id));, detta)); Nu är den åtgärd som utförs (om vi skapar, uppdaterar eller förstör ett meddelande) kan hittas inuti själva msg, vilken är då inuti uri. För att få åtgärden delas vi URI på framåt snedstreck ('/') och ta bara det sista segmentet med pop- fungera. Vi försöker sedan matcha det med de tre möjliga åtgärderna av skapa, uppdatering, eller förstöra.
Resten är standard Ryggrad, vi lägger till, redigerar eller tar bort den angivna modellen. Med vår nya klass nästan avslutad är allt som är kvar att göra, att ändra strömmen MessageCollection. I stället för att utvidga Backbone-samlingen måste den utvidga vår nya samling, så här:
var MessageCollection = SailsCollection.extend (sailsCollection: 'messages', modell: MessageModel);
Förutom att vi utvidgar vår nya samling gör vi en annan förändring så att vi istället för att ange URL-egenskapen ställer in egenskapen segelCollection. Och det är allt som finns där. Öppna programmet i två olika webbläsare (t.ex. Chrome och Safari) och registrera två separata användare. Du bör se att meddelade meddelanden från någon av webbläsarna visas omedelbart på den andra, ingen omröstning, inga problem.
Seglar är ett friskt luft, inom ramar av ramar. Det kontrollerar sitt ego vid dörren och gör vad det kan för att hjälpa utvecklaren istället för varumärket. Jag har chattat med seglarna devs och jag kan säga att det finns ännu mer awesomeness i verken, och det blir intressant att se var denna ram går.
Såsom slutsats har du lärt dig hur du konfigurerar, använder och säkrar dina data från Sails, liksom hur du kan gränsa det med det populära Backbone-biblioteket.
Som alltid, om du har några kommentarer, kan du lämna dem nedan, eller gå med på nätet + IRC-kanalen ("#nettuts" på freenode). Tack för att du läste.
