Meteor:verschil tussen namen voor collecties, variabelen, publicaties en abonnementen?

Laten we een onderscheid maken tussen de verschillende namen waarmee u mogelijk te maken krijgt bij het programmeren van Meteor:

Variabelenamen , zoals Posts = new Meteor.Collection(...) . Deze worden alleen gebruikt zodat uw code weet hoe deze variabele te benaderen. Meteor weet niet of het kan schelen wat het is, hoewel de conventie is om met een hoofdletter te schrijven.
Collectienamen , zoals new Meteor.Collection("posts") . Dit verwijst naar de naam van een MongoDB-verzameling (op de server) of een minimongo-verzameling (op de client).
Publicatie- en abonnementsnamen , gebruikt in Meteor.publish("foo", ...) of Meteor.subscribe("foo") . Deze moeten overeenkomen zodat de client zich kan abonneren op bepaalde gegevens op de server.

Er zijn twee dingen die u moet matchen in het Meteor-gegevensmodel:

Namen van publicaties en de bijbehorende abonnementen
(meestal) Namen van collecties op de client en server, als het standaard collectiemodel wordt gebruikt

Een abonnementsnaam moet altijd overeenkomen met de naam van een publicatie. De incasso's die voor een bepaald abonnement worden verzonden, hoeven echter niets te maken te hebben met de abonnementsnaam. In feite kan men meerdere cursors in één publicatie . verzenden of één verzameling over verschillende publicaties of zelfs meerdere abonnementen per publicatie , die in de client als één geheel worden weergegeven. U kunt ook verschillende collectienamen in de server en client hebben; lees verder...

Laten we de verschillende gevallen bekijken:

Eenvoudig abonnementsmodel . Dit is degene die je meestal ziet in eenvoudige Meteor-demo's.

Op client en server,
```
Posts = new Meteor.Collection("posts");
```
Alleen op server:
```
Meteor.publish("postsPub", function() { 
    return Posts.find() 
});
```
Alleen voor klanten:
```
Meteor.subscribe("postsPub")
```
Dit synchroniseert de Posts collectie (met de naam posts in de database) met behulp van de publicatie genaamd postsPub .
Meerdere collecties in één publicatie . U kunt meerdere cursors naar een enkele publicatie sturen met behulp van een array.

Op client en server:
```
Posts = new Meteor.Collection("posts");
Comments = new Meteor.Collection("comments");
```
Alleen op server:
```
Meteor.publish("postsAndComments", function() { 
    return [ 
        Posts.find(), 
        Comments.find() 
    ]; 
});
```
Alleen voor klanten:
```
Meteor.subscribe("postsAndComments");
```
Dit synchroniseert de Posts collectie en de Comments verzameling met behulp van een enkele publicatie genaamd postsAndComments . Dit type publicatie is zeer geschikt voor relationele gegevens; bijvoorbeeld, waar u misschien alleen bepaalde berichten wilt publiceren en de opmerkingen die alleen aan die berichten zijn gekoppeld. Bekijk een pakket dat deze cursors automatisch kan bouwen .
Meerdere publicaties voor één collectie . U kunt meerdere publicaties gebruiken om verschillende gegevenssegmenten voor één verzameling te verzenden die automatisch door Meteor worden samengevoegd.

Op server en client:
```
Posts = new Meteor.Collection("posts");
```
Alleen op server:
```
Meteor.publish("top10Posts", function() { 
    return Posts.find({}, {
        sort: {comments: -1}, 
        limit: 10
    });
});        
Meteor.publish("newest10Posts", function() { 
    return Posts.find({}, {
        sort: {timestamp: -1},
        limit: 10
    }); 
});
```
Alleen voor klanten:
```
Meteor.subscribe("top10Posts");
Meteor.subscribe("newest10Posts");
```
Hierdoor worden zowel de 10 berichten met de meeste reacties als de 10 nieuwste berichten op de site naar de gebruiker gepusht, waarbij beide gegevenssets worden samengevoegd tot één Posts verzameling. Als een van de nieuwste berichten ook een bericht is met de meeste reacties of vice versa, worden de Posts collectie zal minder dan 20 items bevatten. Dit is een voorbeeld van hoe u met het gegevensmodel in Meteor krachtige bewerkingen voor het samenvoegen van gegevens kunt uitvoeren zonder de details zelf te implementeren.
Meerdere abonnementen per publicatie. U kunt meerdere gegevenssets uit dezelfde publicatie halen met verschillende argumenten.

Op server en client:
```
Posts = new Meteor.Collection("posts");
```
Alleen op server:
```
Meteor.publish("postsByUser", function(user) { 
    return Posts.find({
        userId: user
    });
});        
```
Alleen voor klanten:
```
Meteor.subscribe("postsByUser", "fooUser");
Meteor.subscribe("postsByUser", "barUser");
```
Dit zorgt ervoor dat de berichten van fooUser en barUser om beide te verschijnen in de posts verzameling. Dit model is handig wanneer u verschillende berekeningen hebt die naar verschillende segmenten van uw gegevens kijken en dynamisch kunnen worden bijgewerkt. Merk op dat wanneer u zich abonneert binnen een Deps.autorun(...) , Meteor roept stop() op elk vorig abonnement wordt automatisch met dezelfde naam verwerkt, maar als u deze abonnementen buiten een autorun gebruikt je zult ze zelf moeten stoppen. Vanaf nu kun je geen twee abonnementen met dezelfde naam in een autorun doen berekening, omdat Meteor ze niet uit elkaar kan houden.
Willekeurige gegevens over een publicatie schuiven. U kunt publicaties volledig aanpassen om niet dezelfde collectienamen op de server en client te vereisen. In feite kan de server gegevens publiceren die helemaal niet door een verzameling worden ondersteund. Om dit te doen, kunt u de API gebruiken voor de publicatiefuncties .

Alleen op 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();
    })    
});
```
Alleen voor klanten:
```
NewPosts = new Meteor.Collection("newposts");

Meteor.subscribe("newPostsPub");
```
Dit synchroniseert de nieuwste 10 berichten van de Posts verzameling op de server (genaamd posts in de database) naar de NewPosts verzameling op de client (genaamd newposts in minimongo) met behulp van de publicatie/abonnement genaamd newPostsPub . Merk op dat observeChanges verschilt van observe , die een heleboel andere dingen kan doen.

De code lijkt ingewikkeld, maar als je een cursor in een publicatiefunctie plaatst, is dit in feite de code die Meteor achter de schermen genereert. Het schrijven van publicaties op deze manier geeft je veel meer controle over wat wel en niet naar de klant wordt gestuurd. Wees echter voorzichtig, want u moet observe handmatig uitschakelen handvatten en markeer wanneer het abonnement klaar is. Voor meer informatie, zie Matt Debergalis' beschrijving van dit proces (maar dat bericht is verouderd). Je kunt dit natuurlijk combineren met de andere stukken hierboven om mogelijk zeer genuanceerde en gecompliceerde publicaties te krijgen.

Sorry voor het essay :-) maar veel mensen raken hierdoor in de war en ik denk dat het nuttig zou zijn om alle gevallen te beschrijven.