Tutorial Meteor: Construirea de aplicații web în timp real cu Meteor

Publicat: 2022-03-11

Meteor este un cadru JavaScript complet pentru aplicații web și mobile. Acesta există din 2011 și și-a câștigat o reputație puternică în rândul dezvoltatorilor Meteor pentru a fi o soluție ideală, ușor de utilizat pentru prototipare rapidă. Cu toate acestea, în ultimul timp, dezvoltatorii au realizat că Meteor nu mai este doar pentru prototipare: este gata să fie folosit pentru dezvoltare comercială. Cu arsenalul de pachete pe care îl oferă, baza solidă mongoDB/node.js pe care se bazează și flexibilitatea de codare pe care o oferă; Meteor facilitează construirea de aplicații web robuste și sigure în timp real, gestionând totul, de la aplicația browser la server sau bază de date.

Acest tutorial Meteor vă va ghida prin crearea unei aplicații web de bază în Meteor - un catalog simplu care permite utilizatorilor să se autentifice și să gestioneze o listă de cărți.

De ce să folosiți Meteor? Răspunsul scurt este „pentru că Meteor este distractiv”. Face dezvoltarea aplicațiilor web simplă. Este ușor de învățat și vă permite să vă concentrați mai mult pe funcționalitatea aplicației dvs. decât pe elementele de bază ale sincronizării datelor și difuzării paginilor.

Are, de asemenea, o mulțime de comportamente încorporate convenabil. Meteor efectuează automat actualizări live, astfel încât modificările datelor apar imediat în fereastra browserului și chiar și modificările codului aplicației în sine sunt transmise tuturor browserelor și dispozitivelor în „timp real”. Meteor are o compensare a latenței încorporată, este ușor de implementat și are „pachete” ușor de instalat care gestionează tot felul de funcționalități.

Chiar dacă este un cadru relativ nou, multe startup-uri construiesc deja aplicații Meteor, inclusiv servicii la scară relativ mare, cum ar fi Respondly și Telescope.

Instalare și schele Meteor

Instalarea Meteor pe sisteme *nix este o singură linie:

 curl https://install.meteor.com/ | sh

Deși încă nu există suport oficial, previzualizarea lor pentru Windows vine bine. Zvonurile spun că suportul Windows va fi livrat cu versiunea 1.1, care va fi lansată în aprilie sau mai 2015. După cum vă puteți aștepta de la un cadru inteligent precum Meteor, pornirea unei aplicații necesită invocarea unei singure linii de comandă:

 meteor create book-list

Acest lucru va crea un director numit „listă de cărți” și îl va popula cu niște coduri standard și dependente. Pentru a rula aplicația, introduceți directorul nou creat și executați:

 meteor

Deschideți http://localhost:3000 în browserul dvs. web și veți vedea următoarele:

De asemenea, puteți consulta „versiunea 0” a aplicației noastre pe MeteorPad, un site care este ca JSFiddle pentru Meteor: Listă de cărți: aplicație implicită

Meteor își stochează vederile în fișiere HTML. Dacă deschidem „book-list.html”, vom vedea:

 <head> <title>book-list</title> </head> <body> <h1>Welcome to Meteor!</h1> {{> hello}} </body> <template name="hello"> <button>Click Me</button> <p>You've pressed the button {{counter}} times.</p> </template>

Meteor folosește „Blaze”, un motor de șabloane, pentru a reda răspunsurile din aceste fișiere HTML. Acoladele duble ar trebui să fie familiare oricui a folosit Handlebars.js (sau alte motoare de șabloane similare) și au o funcție similară aici. Blaze examinează expresiile din interiorul fiecărei perechi de acolade duble și le înlocuiește pe fiecare cu valoarea pe care o produc aceste expresii.

Acest exemplu de program simplu are doar două expresii cu două bretele:

Primul, „{{> hello}}”, îi spune lui Blaze să includă un șablon numit „hello”. Acel șablon este definit în partea de jos a fișierului, în secțiunea <template name="hello">.
Al doilea, „{{counter}}”, este puțin mai complicat. Pentru a vedea de unde vine această valoare „contor”, trebuie să deschidem „book-list.js”:

 if (Meteor.isClient) { // counter starts at 0 Session.setDefault('counter', 0); Template.hello.helpers({ counter: function () { return Session.get('counter'); } }); Template.hello.events({ 'click button': function () { // increment the counter when button is clicked Session.set('counter', Session.get('counter') + 1); } }); } if (Meteor.isServer) { Meteor.startup(function () { // code to run on server at startup }); }

Unele lucruri necesită explicații aici. Mai întâi, împărțirea în „dacă (Meteor.isClient)” și „dacă (Meteor.isServer)”. Amintiți-vă că meteor este un cadru full-stack, astfel încât codul pe care îl scrieți este rulat atât pe server, cât și pe client. Aceste condiționale ne permit să limităm: primul bloc rulează doar pe client, iar al doilea rulează doar pe server.

În al doilea rând, există apelul „Session.setDefault” - aceasta inițializează o variabilă de sesiune numită „counter” în browser. Variabilele de sesiune acționează un pic ca globalele în Meteor (la bine și la rău). Cu toate acestea, acea variabilă de sesiune nu apare direct în „{{counter}}”. În schimb, acea expresie „contra” este un „ajutor”, unul care este definit în secțiunea „Șablon.hello.helpers”. Acest ajutor pur și simplu preia valoarea variabilei de sesiune și o returnează.

Rețineți că ajutorul este „reactiv”. Aceasta înseamnă că de fiecare dată când variabila de sesiune se modifică, Meteor re-execută automat această funcție de ajutor care o face referire, iar Blaze actualizează automat browserul cu noul conținut.

Codul clientului monitorizează și evenimentele, prin „Template.hello.events”. Identificăm evenimentul după tipul de eveniment și selector (în acest caz, „clic pe butonul”), apoi îi spunem lui Meteor ce ar trebui să facă acel eveniment. În acest caz, variabila de sesiune este incrementată, care rulează din nou funcția de ajutor și, la rândul său, redă din nou conținutul.

Afișarea datelor statice

Toate acestea sunt bune și bune, dar nu este aplicația Meteor pe care o dorim pentru acest tutorial.

Să începem să modificăm această aplicație - vom afișa o listă statică, codificată de cărți. Deocamdată, vom păstra lista de cărți într-o variabilă de sesiune. În codul „isClient”, vom folosi „Template.hello.rendered” pentru a seta variabila de sesiune de îndată ce șablonul bookList este redat:

 Template.hello.rendered = function() { Session.setDefault('books', [ {title: "To Kill a Mockingbird", author: "Harper Lee"}, {title: "1984", author: "George Orwell"}, {title: "The Lord of the Rings", author: "JRR Tolkien"}, {title: "The Catcher in the Rye", author: "JD Salinger"}, {title: "The Great Gatsby", author: "F. Scott Fitzgerald"} ]); };

Apoi, returnăm acea variabilă de sesiune cu un nou ajutor în șablonul „hello”:

 Template.hello.helpers({ books: function () { return Session.get('books'); } });

Și afișați-l pe ecran prin interpolare variabilă în șablonul „bună ziua”:

 <template name="hello"> <h3>Here are your books:</h3> {{ books }} </template>

Puteți verifica acest cod în acțiune pe Meteorpad: Book-List: Show Session Variable

Primul lucru de observat este că serverul Meteor a detectat automat modificările la baza noastră de cod, a împins noul cod către clienți și a solicitat clientului să reîncarce. Chiar și după ce am implementat o aplicație, putem implementa modificări și putem actualiza automat clienții noștri prin push-code.

Până acum, iată ce obținem:

Hopa, afișăm greșit datele. Blaze obține puncte pentru acuratețe aici (de ce da, este o serie de obiecte), dar va trebui să fim puțin mai deștepți dacă vrem să afișăm lista noastră de cărți într-un mod util. Din fericire, Blaze face foarte ușor să lucrezi cu matrice de date folosind directiva „#each”:

 <h3>Here are your books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL>

În Blaze, „#each” funcționează un pic ca directiva „ng-repeat” a lui Angular - iterează prin structura matricei, setând contextul curent la obiectul curent din matrice și afișând în mod repetat codul HTML în interiorul „{{#each”. …}}”. Iată cum arată acum lista noastră de cărți:

Pe MeteorPad: Afișați corect variabila de sesiune

Unele curățenie

Înainte de a merge mai departe, hai să ne curățăm puțin codul.

Meteor oferă o marjă de manevră extraordinară în modul în care vă organizați baza de cod. După cum veți vedea, există doar câteva reguli stricte și rapide: oriunde vă puneți HTML și JavaScript, Meteor le va găsi. Această flexibilitate este plăcută, dar înseamnă că îți revine mai mult să-ți organizezi codul într-un mod care să aibă sens, astfel încât să nu fii blocat să menții o mizerie uriașă dezordonată.

Mai întâi, să redenumim acest șablon „bună ziua” cu ceva semnificativ, cum ar fi „bookList”, și să înlocuim codul HTML standard cu acesta:

 <head> <title>book-list</title> </head> <body> {{> bookList}} </body> <template name="bookList"> <h3>Here are some books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL> </template>

În al doilea rând, să împărțim părțile „client” și „server” în fișiere separate. În directorul aplicației noastre, vom configura un subdirector „client” și un subdirector „server” - Meteor va ști automat să ruleze fișierele „/client/” pe client și să ruleze fișierele „/server/” pe Server. Este o convenție bună să puneți codul șablonului într-un fișier JavaScript numit după șablon, așa că haideți să punem codul nostru client în „client/bookList.js”. Putem pune codul de pornire a serverului gol în „server/startup.js”. În cele din urmă, să ieșim din „

Rețineți că, chiar și după toate aceste schimbări, Meteor va găsi în continuare automat toate fișierele noastre HTML și JavaScript. Atâta timp cât un fișier se află undeva în „/client/”, Meteor va ști să-l ruleze pe client. Atâta timp cât un fișier este undeva în „/server/”, meteor va ști să-l ruleze pe server. Din nou, depinde de dezvoltator să mențină lucrurile organizate.

Deci acum codul nostru ar trebui să arate astfel:

book-list.html:

 <head> <title>book-list</title> </head> <body> {{> bookList}} </body>

client/bookList.html:

 <template name="bookList"> <h3>Here are some books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL> </template>

client/bookList.js:

 Template.bookList.rendered = function() { Session.setDefault('books', [ {title: "To Kill a Mockingbird", author: "Harper Lee"}, {title: "1984", author: "George Orwell"}, {title: "The Lord of the Rings", author: "JRR Tolkien"}, {title: "The Catcher in the Rye", author: "JD Salinger"}, {title: "The Great Gatsby", author: "F. Scott Fitzgerald"} ]); }; Template.bookList.helpers({ books: function () { return Session.get('books'); } });

server/startup.js:

 Meteor.startup(function () { // code to run on server at startup }); ~~~ Check it out on MeteorPad: [Initial Code Cleanup](http://meteorpad.com/pad/MwvMcsBAzfbWwEXp3/Book-List:%20Initial%20Code%20Cleanup) Verify that everything's running correctly by checking the browser window and then we're good to move on to the next step. ## Using the Database in Meteor The Meteor server runs on top of a MongoDB database. In this section of our tutorial, we will move the static list of books out of the session variable and into that database. First, delete the Template.bookList.rendered code, so that we're no longer putting stuff into that session variable. Next, we should add that list of books to the database as fixture data when the server initializes. As you'd expect for MongoDB, Meteor stores data in "collections". So, we'll create a new collection for our books. To keep things simple we will name it "books". It turns out that both the client and the server will want to know about this collection, so we'll put this code in a new subfolder: "/lib/". Meteor knows automatically that files in "/lib/" run on the client and the server. We'll create a file called "lib/collections/books.js", and give it just one line of code: ~~~ js Books = new Meteor.Collection("books");

În fereastra browserului orientată către http://localhost:3000, accesați consola pentru dezvoltatori și verificați valoarea „Cărți”. Acum ar trebui să fie o colecție Mongo! Încercați să rulați „Books.find().fetch()”, și veți obține o matrice goală – ceea ce are sens, deoarece nu am adăugat încă nicio carte la el. Putem încerca să adăugăm elemente la acesta în consolă:

 Books.insert({title: "To Kill a Mockingbird", author: "Harper Lee"})

Adăugarea de lucruri în consolă este destul de obositoare. În schimb, vom configura lucrurile astfel încât, atunci când serverul pornește, să introducem automat datele de fixare în baza de date. Deci, să revenim la „server/startup.js” și să adăugăm asta:

 Meteor.startup(function () { if (!Books.findOne()) { Books.insert({title: "To Kill a Mockingbird", author: "Harper Lee"}); Books.insert({title: "1984", author: "George Orwell"}); Books.insert({title: "The Lord of the Rings", author: "JRR Tolkien"}); Books.insert({title: "The Catcher in the Rye", author: "JD Salinger"}); Books.insert({title: "The Great Gatsby", author: "F. Scott Fitzgerald"}); } });

Acum, când serverul pornește, dacă nu sunt date prezente, vom adăuga datele dispozitivului. Putem verifica acest lucru revenind la terminalul nostru, oprind serverul meteor și rulând această comandă:

 meteor reset

Notă: rareori veți avea nevoie de această comandă, deoarece resetează - adică șterge - baza de date pe care o folosește Meteor. Dacă aplicația dvs. Meteor are date despre utilizator în baza de date, nu ar trebui să rulați această comandă. Dar în acest caz, vom șterge toate datele de testare pe care le avem.

Acum vom porni din nou serverul:

 meteor

La pornire, Meteor va rula rutina de pornire, va vedea că baza de date este goală și va adăuga datele de fixare. În acest moment, dacă mergem la consolă și scriem „Books.find().fetch()”, obținem cele cinci cărți pe care le aveam înainte.

Tot ce a mai rămas pentru acest pas este să afișați cărțile pe ecran. Din fericire, este la fel de simplu ca înlocuirea „return Session.get('books');” cu următorul ajutor în „cărți”:

 return Books.find();

Și ne-am întors în afaceri! Aplicația afișează acum date dintr-un cursor de bază de date, în loc de din variabila de sesiune.

Verificați-l pe MeteorPad: Mutarea la baza de date

Preocupările legate de securitate

O să prefațez acest lucru spunând: „nu face asta”.

Ce crezi că s-ar întâmpla dacă cineva ar porni această aplicație în browser, ar merge la consolă și ar introduce „Books.remove({})”?

Răspunsul este: ar șterge colecția.

Deci, aceasta este o problemă de securitate destul de mare - utilizatorii noștri au prea mult acces la baza noastră de date. Orice client poate accesa întreaga bază de date. Nu numai că, orice client poate face orice modificare a întregii baze de date, inclusiv acea ștergere a datelor „.remove({})”.

Acest lucru nu este bun, așa că haideți să o reparăm.

Meteor folosește așa-numitele „pachete” pentru adăugarea de funcționalități. Ce sunt modulele pentru Node.js și pietrele prețioase pentru Ruby, pachetele sunt un pachet bun de funcționalitate pentru Meteor. Există pachete pentru tot felul de lucruri. Pentru a naviga prin ceea ce este disponibil, accesați atmosfera.js.

Aplicația implicită meteor pe care am făcut-o cu „meteor create” include două pachete numite „autopublish” și „nesecure”. Primul pachet face ca clienții să aibă acces automat la întreaga bază de date, iar al doilea îl face astfel încât utilizatorii să poată efectua orice acțiuni asupra acelei baze de date.

Să le eliminăm. Putem face asta rulând următoarele din directorul aplicației:

 meteor remove autopublish insecure

Când ați terminat, veți vedea că datele listei de cărți dispar de pe ecran (din moment ce nu mai aveți acces la ele), iar dacă încercați un apel „Books.insert”, veți primi eroarea: „inserat failed : Acces interzis". Pe MeteorPad: Excesul de securitate

Dacă nu luați nimic altceva din acest tutorial Meteor, vă rugăm să rețineți acest lucru: atunci când implementați o aplicație Meteor, asigurați-vă că eliminați pachetele autopublicate și nesigure. Meteor are multe măsuri de siguranță bune, dar toate sunt degeaba dacă lăsați acele două pachete instalate.

Deci, de ce Meteor include în mod automat aceste pachete, dacă reprezintă un astfel de pericol pentru securitate? Motivul este că, mai ales pentru începători, aceste două pachete facilitează începerea - puteți depana și modifica cu ușurință baza de date din consola unui browser. Dar este o practică bună să renunți la publicarea automată și la nesiguranță cât mai curând posibil.

Publicați și abonați-vă

Așa că am remediat acea gaură de securitate, dar am introdus două probleme. În primul rând, acum nu avem acces la baza de date. În al doilea rând, nu avem nicio modalitate de a interacționa cu baza de date.

Să abordăm aici prima problemă. Meteor oferă acces securizat la o bază de date prin faptul că serverul „publică” un subset al bazei de date, iar clientul „se abonează” la publicația respectivă.

Mai întâi, să creăm „/server/publications.js”:

 Meteor.publish('books', function() { return Books.find({}); });

Și vom crea „/client/subscriptions.js”:

 Meteor.subscribe('books');

Verificați-l pe MeteorPad: Publicați și abonați-vă

Serverul „publică” un cursor care are acces la toate datele, iar clientul „se abonează” la el la celălalt capăt. Clientul folosește acest abonament pentru a popula o copie în oglindă a bazei de date cu toate datele cursorului. Când accesăm „Books.find().fetch()”, vedem toate cele cinci obiecte și le vedem afișate pe ecran ca înainte.

Diferența acum este că este foarte ușor să limitezi ceea ce pot accesa clienții. Încercați să comutați publicația „find()” la un subset de date:

 Meteor.publish('books', function() { return Books.find({}, {limit:3}); });

Acum clientul vede doar trei din cele cinci cărți și nu există nicio modalitate de a ajunge la restul. Nu numai că este o mare avantaj pentru securitate (nu pot vedea conturile bancare ale altora), dar o puteți folosi pentru a împărți datele și a evita supraîncărcarea unui client.

Adăugarea de cărți noi

Am văzut cum să oferim clienților acces de citire la baza de date într-un mod limitat și sigur. Acum, să ne uităm la a doua problemă: cum îi lăsăm pe utilizatori să modifice baza de date fără a le permite să facă ceea ce doresc? Eliminarea pachetului nesigur a făcut ca clienții să nu aibă deloc acces - să încercăm să permitem din nou adăugarea de cărți. În meteor, facem acest lucru adăugând o „metodă” la server. Să adăugăm o metodă, una care adaugă o carte nouă, la „/lib/collections/books.js”:

 Meteor.methods({ addBook: function(bookData) { var bookID = Books.insert(bookData); return bookID; } });

După cum puteți vedea, acesta preia „bookData” - în acest caz, acesta este un obiect cu câmpuri „titlu” și „autor” - și îl adaugă la baza de date. Odată ce clientul se reîncarcă, putem apela această metodă de la client. Puteți merge la consolă și introduceți ceva de genul acesta:

 Meteor.call('addBook', {title: "A Tale of Two Cities", author: "Charles Dickens"})

Și prest! Mai primești o carte pe lista de cărți. Utilizarea consolei este intolerabil de greoaie, așa că haideți să adăugăm un formular simplu la sfârșitul șablonului „bookList” care ne va permite să adăugăm cărți noi:

 <form class="add-book"> Title:<br> <input type="text" name="title"> <br> Author:<br> <input type="text" name="author"> <input type="submit" value="Add Book"> </form>

Și putem conecta asta la JavaScript folosind un caz de eveniment, așa cum am avut în aplicația de testare originală:

 Template.bookList.events({ "submit .add-book": function(event) { event.preventDefault(); // this prevents built-in form submission Meteor.call('addBook', {title: event.target.title.value, author: event.target.author.value}) } });

Puteți vedea acest lucru în acțiune pe MeteorPad: Metode

Când aveam în loc publicarea nesigură și automată, clienții puteau accesa și modifica întreaga bază de date. Acum, cu publicarea nesigură și automată, dar cu publicațiile, abonamentele și metodele, clienții pot accesa baza de date și pot interacționa cu ea într-un mod controlat.

Pe o notă laterală: puteți aborda și problemele de securitate în Meteor utilizând „permite și refuza regulile”. Puteți afla mai multe despre acestea și despre câteva motive pentru care prefer abordarea de mai sus la discovermeteor.com.

Autentificarea utilizatorului

Poate părea că tocmai ne-am întors de unde am început, dar există o diferență importantă: este foarte ușor pentru noi să limităm acum accesul la baza de date. Pentru a vedea cum funcționează, să încercăm să adăugăm utilizatori la această aplicație. Vom adăuga un sistem de conectare la aplicația noastră și apoi, în loc să avem toți clienții să lucreze cu o singură listă de cărți la nivelul întregului sistem, vom face ca fiecare utilizator să poată adăuga sau citi doar propria listă de cărți.

Accesați directorul aplicației și instalați două pachete:

 meteor add accounts-ui accounts-password

Acolo. Tocmai ați adăugat un sistem de conectare la aplicație. Acum trebuie doar să adăugăm interfața de conectare la book-list.html. Puneți această singură linie în partea de sus a corpului:

 {{> loginButtons}}

Ar trebui să vedeți o solicitare de conectare în partea de sus a ecranului:

Observați că, dacă faceți clic pe linkul de conectare, acesta vă va cere o adresă de e-mail și o parolă. Putem trece la un sistem simplu de conectare cu nume de utilizator/parolă creând „/client/config.js” cu următoarele:

 Accounts.ui.config({ passwordSignupFields: "USERNAME_ONLY" });

În acest moment, puteți tasta „Meteor.userId()” în consolă și va returna „null”. Puteți încerca să dați clic pe link pentru a crea un cont. Apelarea „Meteor.userId()” ar trebui să returneze acum un șir de ID. Serverul are acces la aceeași informație (ca „this.userId”), așa că este trivial ca metoda „adăugați cărți” să forțeze utilizatorul să fie conectat și să includă un câmp userID:

 Meteor.methods({ addBook: function(bookData) { if (this.userId) { bookData.userID = this.userId; var bookID = Books.insert(bookData); return bookID; } } });

Tot ce rămâne acum este să limităm clientul, arătând doar cărțile pe care acest utilizator le-a adăugat. Folosim capacitatea publicației de a restrânge la ce are acces clientul:

 Meteor.publish('books', function() { return Books.find({userID: this.userId}); });

Acum, publicația găsește doar cărți de la acest utilizator anume. Putem accesa chiar și userId-ul din expresiile Blaze ca „{{currentUser}}”; și putem folosi aceasta, cu o directivă „{{#if}}” (care face exact ceea ce crezi că face), pentru a afișa date numai atunci când utilizatorul este conectat:

 <template name="bookList"> {{#if currentUser}} <h3>Here are your books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL> <form class="add-book"> Title:<br> <input type="text" name="title"> <br> Author:<br> <input type="text" name="author"> <input type="submit" value="Add Book"> </form> {{else}} <h3>Please log in to see your books</h3> {{/if}} </template>

Vezi rezultatul final pe MeteorPad: Utilizatori

Implementare

Acum putem implementa această aplicație Meteor pe Internet. Facem acest lucru mergând la directorul aplicației de pe un terminal și executând:

 meteor deploy <your app's name>.meteor.com

Asigurați-vă că înlocuiți „<numele aplicației dvs.>” cu un nume real, scurt pentru instanța aplicației. Rularea acestei comenzi vă va solicita să configurați un cont cu Meteor, iar apoi va pune noua aplicație pe serverele de testare ale Meteor, astfel încât să o puteți încerca pe Internet.

Pentru o demonstrație rapidă, această soluție meteor.com este tot ce aveți nevoie. Echipa Meteor nu a anunțat nicio limită explicită pentru stocare sau lățime de bandă pe serverele lor. Singura limitare notabilă este că, dacă aplicația dvs. rămâne nefolosită pentru o lungă perioadă de timp, site-ul durează câteva secunde să se rotească pentru următorul utilizator.

Acestea fiind spuse, meteor.com nu este destinat utilizării comerciale. Dar atunci când treceți la producție, există companii de platformă ca serviciu, cum ar fi Modulus și Digital Ocean, care facilitează implementarea aplicațiilor Meteor. Dacă doriți să implementați o aplicație meteor pe propriul dvs. server, „meteor up” face și acest proces simplu.

Pasii urmatori

Felicitări! În încercarea ta de a învăța Meteor, ai creat și implementat o aplicație web Meteor foarte simplă în timp real. Evident, acesta este doar un mic prim pas într-un întreg univers de caracteristici și funcționalități. Dacă vă place ceea ce ați văzut până acum, vă recomand cu căldură Your First Meteor Application de David Turnbull, care îi ghidează pe cititori prin crearea unei aplicații mai complicate, cu mai multe informații despre caracteristicile meteorilor pe parcurs. Este disponibilă ca carte Kindle la un preț mic și ca PDF gratuit pe site-ul web al Turnbull.

De asemenea, veți dori să explorați pachetele disponibile pentru Meteor. De nouă ori din zece, răspunsul la „cum fac <x> în Meteor?” este „există un pachet pentru asta”. „Cum adaug rutare la aplicația mea?” Folosești Iron Router. „Cum ofer un API RESTful?” Folosiți RESTivus. „Cum includ testarea unitară?” Folosești Velocity. „Cum adaug validări de schemă?” Folosești Collection2. Vă puteți pierde cu ușurință pe Atmosphere.js uitându-vă la toate pachetele disponibile.

De ce să nu folosiți Meteor?

După cum puteți vedea din acest tutorial, Meteor este simplu și distractiv pentru a scrie aplicații, dar aș fi neglijent dacă nu aș menționa dezavantajele.

Meteorul este încă relativ imatur. A ajuns la 1.0 în octombrie trecut și asta duce la unele probleme. Dacă doriți să faceți ceva obscur, este posibil ca nimeni să nu fi scris încă un pachet pentru această funcționalitate. Pachetele care există sunt mai susceptibile de a avea erori, pur și simplu pentru că nu au existat suficient de mult pentru a rezolva toate problemele.

Scalare poate fi, de asemenea, oarecum necunoscută cu Meteor. Există o mulțime de site-uri Meteor care se extind până la un număr rezonabil de utilizatori, dar puține site-uri foarte mari - nimic de la ordinea Facebook sau LinkedIn, cu zeci sau sute de milioane de utilizatori.

Cu toate acestea, pentru majoritatea aplicațiilor, Meteor este o alegere perfectă, deoarece este o șansă de a reduce timpul de dezvoltare și de a participa la începutul unui lucru grozav.