Tutorial Meteor: creazione di applicazioni Web in tempo reale con Meteor

Pubblicato: 2022-03-11

Meteor è un framework JavaScript completo per applicazioni web e mobili. È in circolazione dal 2011 e ha guadagnato una solida reputazione tra gli sviluppatori di Meteor per essere una soluzione ideale e facile da usare per la prototipazione rapida. Tuttavia, ultimamente gli sviluppatori hanno capito che Meteor non serve più solo per la prototipazione: è pronto per essere utilizzato per lo sviluppo commerciale. Con l'arsenale di pacchetti che fornisce, la solida base mongoDB/node.js su cui fa affidamento e la flessibilità di codifica che offre; Meteor semplifica la creazione di applicazioni Web in tempo reale robuste e sicure, gestendo qualsiasi cosa, dall'app del browser al server o al database.

Questo tutorial di Meteor ti guiderà attraverso la creazione di un'applicazione web di base in Meteor, un semplice catalogo che consente agli utenti di accedere e gestire un elenco di libri.

Perché usare Meteor? La risposta breve è "perché Meteor è divertente". Semplifica lo sviluppo di applicazioni web. È facile da imparare e ti consente di concentrarti maggiormente sulla funzionalità della tua applicazione rispetto alle basi della sincronizzazione dei dati e della pubblicazione delle pagine.

Ha anche molti comportamenti opportunamente integrati. Meteor esegue automaticamente aggiornamenti in tempo reale, quindi le modifiche ai dati vengono visualizzate immediatamente nella finestra del browser e persino le modifiche al codice dell'applicazione stessa vengono inviate a tutti i browser e dispositivi in "tempo reale". Meteor ha una compensazione della latenza integrata, è facile da implementare e dispone di "pacchetti" facili da installare che gestiscono tutti i tipi di funzionalità.

Anche se si tratta di un framework relativamente nuovo, molte startup stanno già creando app Meteor, inclusi servizi su larga scala come Respondly e Telescope.

Installazione e ponteggi di meteoriti

L'installazione di Meteor sui sistemi *nix è semplice:

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

Sebbene non ci sia ancora supporto ufficiale, la loro anteprima per Windows sta andando bene. Si dice che il supporto di Windows verrà distribuito con la versione 1.1, in uscita ad aprile o maggio 2015. Come ci si può aspettare da un framework intelligente come Meteor, il bootstrap di un'applicazione richiede l'invocazione di una singola riga di comando:

 meteor create book-list

Questo creerà una directory denominata "lista libri" e la popolerà con un codice standard e dipendente. Per eseguire l'applicazione, entrare nella directory appena creata ed eseguire:

 meteor

Apri http://localhost:3000 nel tuo browser web e vedrai quanto segue:

Puoi anche controllare la "versione 0" della nostra applicazione su MeteorPad, un sito simile a JSFiddle per Meteor: Elenco libri: App predefinita

Meteor memorizza le sue viste in file HTML. Se apriamo “lista-libro.html”, vedremo:

 <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 utilizza "Blaze", un motore di creazione di modelli, per visualizzare le risposte da questi file HTML. Le doppie parentesi graffe dovrebbero essere familiari a chiunque abbia utilizzato Handlebars.js (o altri motori di modelli simili) e qui svolgono una funzione simile. Blaze esamina le espressioni all'interno di ciascuna coppia di doppie parentesi graffe e le sostituisce ciascuna con il valore prodotto da queste espressioni.

Questo semplice programma di esempio ha solo due espressioni a doppia parentesi:

Il primo, "{{> ciao}}", dice a Blaze di includere un modello chiamato "ciao". Tale modello è definito nella parte inferiore del file, nella sezione <nome modello=”ciao”>.
Il secondo, "{{counter}}", è un po' più complicato. Per vedere da dove proviene questo valore di "contatore" dobbiamo aprire "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 }); }

Alcune cose richiedono una spiegazione qui. Innanzitutto, la suddivisione in "se (Meteor.isClient)" e "se (Meteor.isServer)". Ricorda che meteor è un framework full-stack, quindi il codice che scrivi viene eseguito sia sul server che sul client. Questi condizionali ci consentono di limitarlo: il primo blocco viene eseguito solo sul client e il secondo viene eseguito solo sul server.

In secondo luogo, c'è la chiamata "Session.setDefault" - questo inizializza una variabile di sessione chiamata "counter" nel browser. Le variabili di sessione agiscono un po' come le globali in Meteor (nel bene e nel male). Tuttavia, quella variabile di sessione non viene visualizzata direttamente in "{{counter}}". Invece, quell'espressione "contatore" è un "aiutante", definito nella sezione "Template.hello.helpers". Questo helper prende semplicemente il valore della variabile di sessione e lo restituisce.

Nota che l'helper è "reattivo". Ciò significa che ogni volta che la variabile di sessione cambia, Meteor riesegue automaticamente questa funzione di supporto a cui fa riferimento e Blaze aggiorna automaticamente il browser con il nuovo contenuto.

Il codice client controlla anche gli eventi, tramite “Template.hello.events”. Identifichiamo l'evento in base al tipo di evento e al selettore (in questo caso, "clicca sul pulsante"), quindi diciamo a Meteor cosa dovrebbe fare quell'evento. In questo caso, viene incrementata la variabile di sessione, che esegue nuovamente la funzione di supporto e, a sua volta, esegue nuovamente il rendering del contenuto.

Visualizzazione di dati statici

Tutto questo va bene, ma non è l'applicazione Meteor che vogliamo per questo tutorial.

Iniziamo a modificare questa applicazione: visualizzeremo un elenco di libri statico e codificato. Per ora, conserveremo l'elenco dei libri in una variabile di sessione. Nel codice "isClient", useremo "Template.hello.rendered" per impostare la variabile di sessione non appena il modello bookList viene renderizzato:

 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"} ]); };

Quindi, restituiamo quella variabile di sessione con un nuovo helper nel modello "ciao":

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

E visualizzalo sullo schermo tramite interpolazione variabile nel modello "ciao":

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

Puoi controllare questo codice in azione su Meteorpad: Elenco libri: Mostra variabile di sessione

La prima cosa da notare è che il server Meteor ha rilevato automaticamente le modifiche alla nostra base di codice, ha inviato il nuovo codice ai client e ha richiesto al client di ricaricare. Anche dopo aver distribuito un'applicazione, possiamo distribuire le modifiche e aggiornare automaticamente i nostri client tramite push hot-code.

distribuire le modifiche automaticamente

Finora, questo è ciò che otteniamo:

Spiacenti, stiamo visualizzando i dati in modo errato. Blaze ottiene punti per la precisione qui (perché sì, è una serie di oggetti), ma dovremo essere un po' più intelligenti se vogliamo visualizzare il nostro elenco di libri in modo utile. Fortunatamente, Blaze rende molto facile lavorare con array di dati usando la direttiva "#each":

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

In Blaze, "#each" funziona un po' come la direttiva "ng-repeat" di Angular: scorre la struttura dell'array, impostando il contesto corrente sull'oggetto corrente nell'array e visualizzando ripetutamente l'HTML all'interno di "{{#each …}}”. Ecco come appare ora la nostra lista di libri:

Su MeteorPad: mostra correttamente la variabile di sessione

Un po' di pulizia

Prima di andare oltre, puliamo un po' il nostro codice.

Meteor offre un enorme margine di manovra nell'organizzazione della tua base di codice. Come vedrai, ci sono solo alcune regole ferree: ovunque metti il tuo HTML e JavaScript, Meteor lo troverà. Questa flessibilità è buona, ma significa che spetta a te organizzare il tuo codice in un modo sensato, quindi non sei bloccato a mantenere un gigantesco pasticcio disordinato.

Per prima cosa, rinominiamo questo modello "ciao" in qualcosa di significativo, come "lista libri", e sostituiamo l'HTML standard con questo:

 <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>

In secondo luogo, dividiamo le parti "client" e "server" in file separati. Nella nostra directory dell'applicazione, imposteremo una sottodirectory "client" e una sottodirectory "server" - Meteor saprà automaticamente eseguire i file "/client/" sul client ed eseguire i file "/server/" sul server. È una buona convenzione inserire il codice del modello in un file JavaScript che prende il nome dal modello, quindi mettiamo il codice del nostro client in "client/bookList.js". Possiamo inserire il nostro codice di avvio del server attualmente vuoto in "server/startup.js". Infine, spostiamo il "

Nota che anche dopo tutto questo passaggio, Meteor troverà automaticamente tutti i nostri file HTML e JavaScript. Finché un file è da qualche parte in "/client/", Meteor saprà eseguirlo sul client. Finché un file è da qualche parte in "/server/", meteor saprà di eseguirlo sul server. Ancora una volta, spetta allo sviluppatore mantenere le cose organizzate.

Quindi ora il nostro codice dovrebbe assomigliare a questo:

lista-libro.html:

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

client/listalibri.html:

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

client/listalibri.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/avvio.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");

All'interno della finestra del browser puntata su http://localhost:3000, vai alla console dello sviluppatore e controlla il valore di "Libri". Ora dovrebbe essere una collezione Mongo! Prova a eseguire "Books.find().fetch()" e otterrai un array vuoto, il che ha senso, dal momento che non abbiamo ancora aggiunto nessun libro. Possiamo provare ad aggiungere elementi ad esso nella console:

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

Aggiungere cose nella console è piuttosto noioso. Invece, imposteremo le cose in modo che all'avvio del server inseriamo automaticamente i dati del dispositivo nel database. Quindi torniamo a "server/startup.js" e aggiungiamo questo:

 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"}); } });

Ora, all'avvio del server, se non sono presenti dati, aggiungeremo i dati dell'apparecchiatura. Possiamo verificarlo tornando al nostro terminale, arrestando il server meteor ed eseguendo questo comando:

 meteor reset

Nota: raramente avrai bisogno di questo comando, perché reimposta, ovvero cancella , il database utilizzato da Meteor. Se la tua applicazione Meteor ha dati utente nel database, non dovresti eseguire questo comando. Ma in questo caso, cancelleremo tutti i dati di test che abbiamo.

Ora riavvieremo il server:

 meteor

All'avvio, Meteor eseguirà la routine di avvio, vedrà che il database è vuoto e aggiungerà i dati dell'apparecchiatura. A questo punto, se andiamo alla console e digitiamo “Books.find().fetch()”, otteniamo i cinque libri che avevamo prima.

Tutto ciò che resta per questo passaggio è visualizzare i libri sullo schermo. Fortunatamente, è semplice come sostituire "return Session.get('books');" con quanto segue nell'helper "libri":

 return Books.find();

E siamo tornati in attività! L'applicazione ora visualizza i dati da un cursore di database, invece che dalla variabile di sessione.

Dai un'occhiata su MeteorPad: Passare al database

Problemi di sicurezza

Premetterò questo dicendo: "non farlo".

Cosa pensi accadrebbe se qualcuno avviasse questa app nel proprio browser, andasse alla console e digitasse "Books.remove({})"?

La risposta è: cancellerebbero la collezione.

Quindi, questo è un problema di sicurezza piuttosto grande: i nostri utenti hanno troppo accesso al nostro database. Qualsiasi cliente può accedere all'intero database. Non solo, qualsiasi client può apportare qualsiasi modifica all'intero database, incluso il wipeout dei dati ".remove({})".

Questo non va bene, quindi sistemiamolo.

Meteor utilizza i cosiddetti "pacchetti" per aggiungere funzionalità. Ciò che i moduli sono per Node.js e le gemme per Ruby, i pacchetti sono una funzionalità in bundle per Meteor. Ci sono pacchetti per ogni genere di cose. Per sfogliare ciò che è disponibile, controlla atmosfera.js.

L'app meteor predefinita che abbiamo realizzato con "meteor create" include due pacchetti chiamati "autopublish" e "insecure". Il primo pacchetto fa in modo che i client abbiano accesso automatico all'intero database e il secondo fa in modo che gli utenti possano eseguire qualsiasi azione su quel database.

Rimuoviamo quelli. Possiamo farlo eseguendo quanto segue dalla directory dell'app:

 meteor remove autopublish insecure

Al termine, vedrai i dati dell'elenco dei libri scomparire dallo schermo (poiché non hai più accesso ad esso) e se provi una chiamata "Books.insert", riceverai l'errore: "insert failed : Accesso negato". Su MeteorPad: sicurezza eccessiva

Se non prendi nient'altro da questo tutorial di Meteor, ricorda questo: quando stai implementando un'app Meteor, assicurati di rimuovere i pacchetti di pubblicazione automatica e non sicuri. Meteor ha molte buone precauzioni di sicurezza, ma tutte sono inutili se lasci questi due pacchetti installati.

Quindi, perché Meteor include automaticamente questi pacchetti, se rappresentano un tale pericolo per la sicurezza? Il motivo è che, soprattutto per i principianti, questi due pacchetti facilitano l'avvio: puoi facilmente eseguire il debug e modificare il database dalla console di un browser. Ma è una buona pratica abbandonare la pubblicazione automatica e l'insicurezza il prima possibile.

Pubblica e iscriviti

Quindi abbiamo risolto quella lacuna di sicurezza, ma abbiamo introdotto due problemi. Innanzitutto, ora non abbiamo accesso al database. In secondo luogo, non abbiamo modo di interagire con il database.

Affrontiamo qui il primo problema. Meteor fornisce un accesso sicuro a un database facendo in modo che il server "pubblichi" un sottoinsieme del database e facendo "abbonarsi" al client a quella pubblicazione.

Innanzitutto, creiamo "/server/publications.js":

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

E creeremo "/client/subscriptions.js":

 Meteor.subscribe('books');

Dai un'occhiata su MeteorPad: Pubblica e Iscriviti

Il server "pubblica" un cursore che ha accesso a tutti i dati e il client "si iscrive" ad esso dall'altra parte. Il client utilizza questa sottoscrizione per popolare una copia speculare del database con tutti i dati del cursore. Quando accediamo a "Books.find().fetch()", vediamo tutti e cinque gli oggetti e li vediamo visualizzati sullo schermo come prima.

La differenza ora è che è davvero facile limitare ciò a cui i client possono accedere. Prova a cambiare la pubblicazione "find()" in un sottoinsieme di dati:

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

Ora il cliente vede sempre e solo tre dei cinque libri e non c'è modo di arrivare al resto. Non solo questo è un grande vantaggio per la sicurezza (non riesco a vedere i conti bancari di tutti gli altri), ma puoi usarlo per distribuire i dati ed evitare di sovraccaricare un cliente.

Aggiunta di nuovi libri

Abbiamo visto come fornire ai clienti l'accesso in lettura al database in modo limitato e sicuro. Ora, diamo un'occhiata al secondo problema: come possiamo consentire agli utenti di modificare il database senza consentire loro di fare tutto ciò che vogliono? L'eliminazione del pacchetto insicuro ha impedito ai clienti di accedervi: proviamo a consentire di nuovo l'aggiunta di libri. In meteor, lo facciamo aggiungendo un "metodo" al server. Aggiungiamo un metodo, uno che aggiunga un nuovo libro, a "/lib/collections/books.js":

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

Come puoi vedere, questo prende "bookData" - in questo caso, si tratta di un oggetto con i campi "title" e "author" - e lo aggiunge al database. Una volta che il tuo client si è ricaricato, possiamo quindi chiamare questo metodo dal client. Puoi andare alla console e inserire qualcosa del genere:

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

E presto! Ottieni un altro libro nell'elenco dei libri. L'uso della console è intollerabilmente goffo, quindi andiamo avanti e aggiungiamo un semplice modulo alla fine del modello "lista libri" che ci consentirà di aggiungere nuovi libri:

 <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>

E possiamo collegarlo a JavaScript usando un caso di evento, come avevamo nell'applicazione di test originale:

 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}) } });

Puoi vederlo in azione su MeteorPad: Metodi

Quando non avevamo la sicurezza e la pubblicazione automatica, i clienti potevano accedere e modificare l'intero database. Ora, con l'insicurezza e la pubblicazione automatica scomparse, ma con pubblicazioni, abbonamenti e metodi, i clienti possono accedere al database e interagire con esso in modo controllato.

Una nota a margine: puoi anche affrontare i problemi di sicurezza in Meteor usando "regole di consenso e di rifiuto". Puoi scoprire di più su questi e alcuni motivi per cui preferisco l'approccio di cui sopra invece su discoverymeteor.com.

Autenticazione utente

Può sembrare che siamo appena tornati al punto di partenza, ma c'è una differenza importante: è davvero facile per noi ora limitare l'accesso al database. Per vedere come funziona, proviamo ad aggiungere utenti a questa app. Aggiungeremo un sistema di accesso alla nostra app e quindi, invece di far lavorare tutti i clienti con un elenco di libri a livello di sistema, faremo in modo che ogni utente possa solo aggiungere o leggere il proprio elenco di libri.

Vai alla directory dell'app e installa due pacchetti:

 meteor add accounts-ui accounts-password

Là. Hai appena aggiunto un sistema di accesso all'app. Ora dobbiamo solo aggiungere l'interfaccia utente di accesso a book-list.html. Metti questa singola linea nella parte superiore del corpo:

 {{> loginButtons}}

Dovresti vedere una richiesta di accesso nella parte superiore dello schermo:

Si noti che se si fa clic sul collegamento di accesso, verranno richiesti un indirizzo e-mail e una password. Possiamo passare a un semplice sistema di accesso con nome utente/password creando "/client/config.js" con quanto segue:

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

A questo punto, puoi digitare "Meteor.userId()" nella console e restituirà "null". Puoi provare a fare clic sul collegamento per creare un account. La chiamata a "Meteor.userId()" dovrebbe ora restituire una stringa ID. Il server ha accesso a questa stessa informazione (come "this.userId"), quindi è banale fare in modo che il metodo "aggiungi libri" costringa l'utente ad accedere e includa un campo ID utente:

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

Non resta che limitare il client, mostrando solo i libri che questo utente ha aggiunto. Usiamo la capacità della pubblicazione per restringere ciò a cui il cliente ha accesso:

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

Ora, la pubblicazione trova solo libri di questo particolare utente. Possiamo persino accedere allo userId dalle espressioni Blaze come "{{currentUser}}"; e possiamo usarlo, con una direttiva "{{#if}}" (che fa esattamente quello che pensi), per mostrare i dati solo quando l'utente ha effettuato l'accesso:

 <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>

Scopri il risultato finale su MeteorPad: Utenti

Distribuzione

Ora possiamo distribuire questa applicazione Meteor su Internet. Lo facciamo andando nella directory dell'applicazione su un terminale ed eseguendo:

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

Assicurati di sostituire "<nome della tua app>" con un nome breve e effettivo per l'istanza dell'applicazione. L'esecuzione di questo comando ti chiederà di configurare un account con Meteor, quindi metterà la tua nuova applicazione sui server di test di Meteor in modo che tu possa provarla su Internet.

Per una rapida demo, questa soluzione meteor.com è tutto ciò di cui hai bisogno. Il team di Meteor non ha annunciato alcun limite esplicito allo spazio di archiviazione o alla larghezza di banda sui propri server. L'unica limitazione notevole è che se la tua app rimane inutilizzata per molto tempo, il sito impiega alcuni secondi per girare per l'utente successivo.

Detto questo, meteor.com non è destinato all'uso commerciale. Ma quando si passa alla produzione, ci sono società di piattaforma come servizio come Modulus e Digital Ocean che semplificano l'implementazione delle app Meteor. Se desideri distribuire un'app meteor sul tuo server, anche "meteor up" rende semplice questo processo.

Prossimi passi

Congratulazioni! Nella tua ricerca per imparare Meteor ora hai creato e distribuito un'applicazione Web Meteor in tempo reale molto semplice. Ovviamente, questo è solo un piccolo primo passo in un intero universo di caratteristiche e funzionalità. Se ti piace quello che hai visto finora, consiglio vivamente Your First Meteor Application di David Turnbull, che guida i lettori attraverso la creazione di un'applicazione più complicata, con ulteriori informazioni sulle funzionalità di meteor lungo il percorso. È disponibile come libro Kindle a un piccolo prezzo e come PDF gratuito sul sito Web di Turnbull.

Ti consigliamo anche di esplorare i pacchetti disponibili per Meteor. Nove volte su dieci, la risposta a "come faccio a <x> in Meteor?" è "c'è un pacchetto per quello". "Come aggiungo il routing alla mia applicazione?" Tu usi Iron Router. "Come faccio a fornire un'API RESTful?" Tu usi RESTivus. "Come faccio a includere i test unitari?" Tu usi la velocità. "Come aggiungo le convalide dello schema?" Tu usi Collection2. Puoi facilmente perderti su Atmosphere.js guardando tutti i pacchetti disponibili.

Perché non usare Meteor?

Come puoi vedere da questo tutorial, Meteor è semplice e divertente su cui scrivere applicazioni, ma sarei negligente se non menzionassi gli svantaggi.

Meteor è ancora relativamente immaturo. Ha raggiunto 1.0 lo scorso ottobre e questo porta ad alcuni problemi. Se stai cercando di fare qualcosa di oscuro, è possibile che nessuno abbia ancora scritto un pacchetto per quella funzionalità. È più probabile che i pacchetti che esistono abbiano dei bug, semplicemente perché non sono in circolazione da abbastanza tempo per scoprire tutti i problemi.

Il ridimensionamento può anche essere in qualche modo sconosciuto con Meteor. Ci sono molti siti Meteor che scalano fino a quantità ragionevoli di utenti, ma pochi siti molto grandi - niente nell'ordine di Facebook o LinkedIn, con decine o centinaia di milioni di utenti.

Tuttavia, per la maggior parte delle applicazioni Meteor è una scelta perfetta, poiché è un'opportunità per ridurre i tempi di sviluppo e partecipare all'inizio di qualcosa di eccezionale.