Meteor:skillnad mellan namn på samlingar, variabler, publikationer och prenumerationer?

Låt oss skilja mellan de olika namnen du kan behöva hantera när du programmerar Meteor:

Variabelnamn , såsom Posts = new Meteor.Collection(...) . Dessa används bara så att din kod vet hur man kommer åt denna variabel. Meteor vet inte eller bryr sig inte om vad det är, även om konventionen är att använda stora bokstäver.
Samlingsnamn , såsom new Meteor.Collection("posts") . Detta mappar till namnet på en MongoDB-samling (på servern) eller en minimongo-samling (på klienten).
Publicerings- och prenumerationsnamn , används i Meteor.publish("foo", ...) eller Meteor.subscribe("foo") . Dessa måste matcha för att klienten ska kunna prenumerera på vissa data på servern.

Det finns två saker du behöver för att matcha i Meteor-datamodellen:

Namn på publikationer och deras motsvarande prenumerationer
(vanligtvis) Namn på samlingar på klienten och servern, om standardinsamlingsmodellen används

Ett prenumerationsnamn måste alltid stämma överens med namnet på en publikation. Samlingarna som skickas för en given prenumeration behöver dock inte ha något att göra med prenumerationsnamnet. Faktum är att man kan skicka över flera markörer i en publikation eller en samling över olika publikationer eller till och med flera prenumerationer per publikation , som visas sammanslagna som en i klienten. Du kan också ha olika samlingsnamn i servern och klienten; läs vidare...

Låt oss se över de olika fallen:

Enkel prenumerationsmodell . Det här är den du vanligtvis ser i enkla Meteor-demos.

På klient och server,
```
Posts = new Meteor.Collection("posts");
```
Endast på server:
```
Meteor.publish("postsPub", function() { 
    return Posts.find() 
});
```
Endast på klient:
```
Meteor.subscribe("postsPub")
```
Detta synkroniserar Posts samling (som heter posts i databasen) med hjälp av publikationen postsPub .
Flera samlingar i en publikation . Du kan skicka flera markörer över för en enda publikation, med hjälp av en array.

På klient och server:
```
Posts = new Meteor.Collection("posts");
Comments = new Meteor.Collection("comments");
```
Endast på server:
```
Meteor.publish("postsAndComments", function() { 
    return [ 
        Posts.find(), 
        Comments.find() 
    ]; 
});
```
Endast på klient:
```
Meteor.subscribe("postsAndComments");
```
Detta synkroniserar Posts samlingen samt Comments samling med en enda publikation som heter postsAndComments . Denna typ av publikation är väl lämpad för relationsdata; till exempel där du kanske bara vill publicera vissa inlägg och de kommentarer som bara är kopplade till dessa inlägg. Se ett paket som kan bygga dessa markörer automatiskt .
Flera publikationer för en enda samling . Du kan använda flera publikationer för att skicka olika delar av data för en enda samling som slås samman av Meteor automatiskt.

På server och klient:
```
Posts = new Meteor.Collection("posts");
```
Endast på servern:
```
Meteor.publish("top10Posts", function() { 
    return Posts.find({}, {
        sort: {comments: -1}, 
        limit: 10
    });
});        
Meteor.publish("newest10Posts", function() { 
    return Posts.find({}, {
        sort: {timestamp: -1},
        limit: 10
    }); 
});
```
Endast på klient:
```
Meteor.subscribe("top10Posts");
Meteor.subscribe("newest10Posts");
```
Detta skickar både de 10 inläggen med flest kommentarer såväl som de 10 senaste inläggen på webbplatsen till användaren, som ser båda uppsättningarna data sammanslagna till ett enda Posts samling. Om ett av de senaste inläggen också är ett inlägg med flest kommentarer eller vice versa, visas Posts samlingen kommer att innehålla mindre än 20 föremål. Det här är ett exempel på hur datamodellen i Meteor låter dig göra kraftfulla datasammanslagningsoperationer utan att implementera detaljerna själv.
Flera prenumerationer per publikation. Du kan hämta flera uppsättningar data från samma publikation med olika argument.

På server och klient:
```
Posts = new Meteor.Collection("posts");
```
Endast på servern:
```
Meteor.publish("postsByUser", function(user) { 
    return Posts.find({
        userId: user
    });
});        
```
Endast på klient:
```
Meteor.subscribe("postsByUser", "fooUser");
Meteor.subscribe("postsByUser", "barUser");
```
Detta orsakar inläggen av fooUser och barUser att båda visas i posts samling. Den här modellen är praktisk när du har flera olika beräkningar som tittar på olika delar av din data och kan uppdateras dynamiskt. Observera att när du prenumererar i en Deps.autorun(...) , Meteor anropar stop() på alla tidigare prenumerationer hanteras med samma namn automatiskt, men om du använder dessa prenumerationer utanför en autorun du måste stoppa dem själv. Just nu kan du inte göra två prenumerationer med samma namn i en autorun beräkning, eftersom Meteor inte kan skilja dem åt.
Pusha godtycklig data över en publikation. Du kan helt anpassa publikationer så att de inte kräver samma samlingsnamn på servern och klienten. Faktum är att servern kan publicera data som inte backas upp av en samling alls. För att göra detta kan du använda API:et för publiceringsfunktionerna .

Endast på server:
```
Posts = new Meteor.Collection("posts"); 

Meteor.publish("newPostsPub", function() {
    var sub = this;
    var subHandle = null;

    subHandle = Posts.find({}, {
        sort: {timestamp: -1},
        limit: 10
    })
    .observeChanges({
        added: function(id, fields) {
            sub.added("newposts", id, fields);            
        },
        changed: function(id, fields) {
            sub.changed("newposts", id, fields);            
        },
        removed: function(id) {
            sub.removed("newposts", id);
        }
    });

    sub.ready();

    sub.onStop(function() {
        subHandle.stop();
    })    
});
```
Endast på klient:
```
NewPosts = new Meteor.Collection("newposts");

Meteor.subscribe("newPostsPub");
```
Detta synkroniserar de senaste 10 inläggen från Posts samling på servern (kallas posts i databasen) till NewPosts samling på klienten (kallas newposts i minimongo) med publikationen/prenumerationen som heter newPostsPub . Observera att observeChanges skiljer sig från observe , som kan göra en massa andra saker.

Koden verkar komplicerad, men när du returnerar en markör i en publiceringsfunktion är detta i princip koden som Meteor genererar bakom kulisserna. Att skriva publikationer på detta sätt ger dig mycket mer kontroll över vad som skickas och inte skickas till kunden. Var dock försiktig, eftersom du manuellt måste stänga av observe hanterar och markera när prenumerationen är klar. För mer information, se Matt Debergalis beskrivning av denna process (det inlägget är dock inaktuellt). Naturligtvis kan du kombinera detta med de andra delarna ovan för att potentiellt få väldigt nyanserade och komplicerade publikationer.

Ursäkta uppsatsen :-) men många människor blir förvirrade över detta och jag trodde att det skulle vara användbart att beskriva alla fall.