Meteor:Unterschied zwischen Namen für Sammlungen, Variablen, Publikationen und Abonnements?

Lassen Sie uns zwischen den verschiedenen Namen unterscheiden, mit denen Sie möglicherweise zu tun haben, wenn Sie Meteor programmieren:

Variablennamen , wie z. B. Posts = new Meteor.Collection(...) . Diese werden nur verwendet, damit Ihr Code weiß, wie er auf diese Variable zugreifen kann. Meteor weiß nicht oder kümmert sich nicht darum, was es ist, obwohl die Konvention großgeschrieben werden soll.
Sammlungsnamen , wie z. B. new Meteor.Collection("posts") . Dies wird dem Namen einer MongoDB-Sammlung (auf dem Server) oder einer Minimongo-Sammlung (auf dem Client) zugeordnet.
Veröffentlichungs- und Abonnementnamen , verwendet in Meteor.publish("foo", ...) oder Meteor.subscribe("foo") . Diese müssen übereinstimmen, damit der Client einige Daten auf dem Server abonnieren kann.

Es gibt zwei Dinge, die Sie im Meteor-Datenmodell abgleichen müssen:

Namen von Veröffentlichungen und ihren entsprechenden Abonnements
(normalerweise) Namen von Sammlungen auf dem Client und Server, wenn das Standardsammlungsmodell verwendet wird

Ein Abonnementname muss immer mit dem Namen einer Publikation übereinstimmen. Die Sammlungen, die für ein bestimmtes Abonnement gesendet werden, müssen jedoch nichts mit dem Abonnementnamen zu tun haben. Tatsächlich kann man mehrere Cursor in einer Veröffentlichung senden oder eine Sammlung über verschiedene Publikationen oder sogar mehrere Abonnements pro Publikation , die im Client zusammengeführt angezeigt werden. Sie können auch unterschiedliche Sammlungsnamen in Server und Client haben; weiterlesen...

Sehen wir uns die verschiedenen Fälle an:

Einfaches Abonnementmodell . Dies ist diejenige, die Sie normalerweise in einfachen Meteor-Demos sehen.

Auf Client und Server,
```
Posts = new Meteor.Collection("posts");
```
Nur auf dem Server:
```
Meteor.publish("postsPub", function() { 
    return Posts.find() 
});
```
Nur auf dem Client:
```
Meteor.subscribe("postsPub")
```
Dadurch werden die Posts synchronisiert Sammlung (die posts heißt in der Datenbank) mit der Publikation namens postsPub .
Mehrere Sammlungen in einer Publikation . Sie können mehrere Cursor für eine einzelne Veröffentlichung senden, indem Sie ein Array verwenden.

Auf Client und Server:
```
Posts = new Meteor.Collection("posts");
Comments = new Meteor.Collection("comments");
```
Nur auf dem Server:
```
Meteor.publish("postsAndComments", function() { 
    return [ 
        Posts.find(), 
        Comments.find() 
    ]; 
});
```
Nur auf dem Client:
```
Meteor.subscribe("postsAndComments");
```
Dadurch werden die Posts synchronisiert Sammlung sowie die Comments Sammlung mit einer einzigen Veröffentlichung namens postsAndComments . Diese Art der Veröffentlichung eignet sich gut für relationale Daten; wenn Sie beispielsweise nur bestimmte Posts und die nur mit diesen Posts verknüpften Kommentare veröffentlichen möchten. Siehe ein Paket, das diese Cursor automatisch erstellen kann .
Mehrere Veröffentlichungen für eine einzige Sammlung . Sie können mehrere Publikationen verwenden, um verschiedene Datenausschnitte für eine einzelne Sammlung zu senden, die von Meteor automatisch zusammengeführt werden.

Auf Server und Client:
```
Posts = new Meteor.Collection("posts");
```
Nur auf dem 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
    }); 
});
```
Nur auf dem Client:
```
Meteor.subscribe("top10Posts");
Meteor.subscribe("newest10Posts");
```
Dadurch werden sowohl die 10 Posts mit den meisten Kommentaren als auch die 10 neuesten Posts auf der Website an den Benutzer gesendet, der beide Datensätze zu einem einzigen Posts zusammengeführt sieht Sammlung. Wenn einer der neusten Posts auch der Post mit den meisten Kommentaren ist oder umgekehrt, werden die Posts Sammlung wird weniger als 20 Artikel enthalten. Dies ist ein Beispiel dafür, wie Sie mit dem Datenmodell in Meteor leistungsstarke Datenzusammenführungsvorgänge durchführen können, ohne die Details selbst implementieren zu müssen.
Mehrere Abonnements pro Veröffentlichung. Sie können mehrere Datensätze aus derselben Publikation mit unterschiedlichen Argumenten abrufen.

Auf Server und Client:
```
Posts = new Meteor.Collection("posts");
```
Nur auf dem Server:
```
Meteor.publish("postsByUser", function(user) { 
    return Posts.find({
        userId: user
    });
});        
```
Nur auf dem Client:
```
Meteor.subscribe("postsByUser", "fooUser");
Meteor.subscribe("postsByUser", "barUser");
```
Dies verursacht die Beiträge von fooUser und barUser damit beide in den posts erscheinen Sammlung. Dieses Modell ist praktisch, wenn Sie mehrere unterschiedliche Berechnungen haben, die unterschiedliche Slices Ihrer Daten betrachten und dynamisch aktualisiert werden können. Beachten Sie das, wenn Sie innerhalb eines Deps.autorun(...) abonnieren , Meteor ruft stop() auf auf alle vorherigen Abonnement-Handles mit demselben Namen automatisch, aber wenn Sie diese Abonnements außerhalb eines autorun verwenden Sie müssen sie selbst stoppen. Ab sofort können Sie innerhalb eines autorun keine zwei Abonnements mit demselben Namen erstellen Berechnung, weil Meteor sie nicht auseinanderhalten kann.
Beliebige Daten über eine Veröffentlichung schieben. Sie können Veröffentlichungen vollständig so anpassen, dass auf Server und Client nicht dieselben Sammlungsnamen erforderlich sind. Tatsächlich kann der Server Daten veröffentlichen, die überhaupt nicht durch eine Sammlung gestützt werden. Dazu können Sie die API für die Veröffentlichungsfunktionen verwenden .

Nur auf dem 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();
    })    
});
```
Nur auf dem Client:
```
NewPosts = new Meteor.Collection("newposts");

Meteor.subscribe("newPostsPub");
```
Dies synchronisiert die neuesten 10 Beiträge aus den posts Sammlung auf dem Server (genannt posts in der Datenbank) zu den NewPosts Sammlung auf dem Client (genannt newposts in minimongo) mit der Veröffentlichung/dem Abonnement namens newPostsPub . Beachten Sie, dass observeChanges unterscheidet sich von observe , das eine Menge anderer Dinge tun kann.

Der Code scheint kompliziert, aber wenn Sie einen Cursor innerhalb einer Veröffentlichungsfunktion zurückgeben, ist dies im Grunde der Code, den Meteor hinter den Kulissen generiert. Wenn Sie Publikationen auf diese Weise schreiben, haben Sie viel mehr Kontrolle darüber, was an den Client gesendet wird und was nicht. Seien Sie jedoch vorsichtig, da Sie observe manuell deaktivieren müssen Griffe und markieren Sie, wann das Abonnement fertig ist. Weitere Informationen finden Sie in der Beschreibung dieses Vorgangs von Matt Debergalis (Dieser Beitrag ist jedoch veraltet). Natürlich können Sie dies mit den anderen oben genannten Elementen kombinieren, um möglicherweise sehr nuancierte und komplizierte Veröffentlichungen zu erhalten.

Entschuldigung für den Aufsatz :-), aber viele Leute sind verwirrt darüber und ich dachte, es wäre nützlich, alle Fälle zu beschreiben.