Meteor:rozdíl mezi názvy sbírek, proměnných, publikací a předplatných?

Pojďme rozlišovat mezi různými názvy, se kterými se můžete při programování Meteoru potýkat:

Názvy proměnných , například Posts = new Meteor.Collection(...) . Používají se pouze proto, aby váš kód věděl, jak k této proměnné přistupovat. Meteor neví a nezajímá, co to je, i když konvencí je používat velká písmena.
Názvy sbírek , například new Meteor.Collection("posts") . To se mapuje na název kolekce MongoDB (na serveru) nebo kolekce minimongo (na klientovi).
Názvy publikací a předplatného , používané v Meteor.publish("foo", ...) nebo Meteor.subscribe("foo") . Ty se musí shodovat, aby se klient mohl přihlásit k odběru některých dat na serveru.

V datovém modelu Meteor musíte sladit dvě věci:

Názvy publikací a jejich odpovídající odběry
(obvykle) Názvy kolekcí na klientovi a serveru, pokud používáte výchozí model kolekce

Název předplatného se musí vždy shodovat s názvem publikace. Kolekce odeslané pro dané předplatné však nemusí mít nic společného s názvem předplatného. Ve skutečnosti lze odeslat přes více kurzorů v jedné publikaci nebo jedna sbírka v různých publikacích nebo dokonce více odběrů na publikaci , které se v klientovi zobrazí sloučené jako jeden. Na serveru a klientovi můžete mít také různé názvy kolekcí; čtěte dále...

Pojďme se podívat na různé případy:

Jednoduchý model předplatného . To je ten, který obvykle vidíte v přímých ukázkách Meteor.

Na klientovi a serveru
```
Posts = new Meteor.Collection("posts");
```
Pouze na serveru:
```
Meteor.publish("postsPub", function() { 
    return Posts.find() 
});
```
Pouze pro klienta:
```
Meteor.subscribe("postsPub")
```
Tím se synchronizují Posts kolekce (která se jmenuje posts v databázi) pomocí publikace nazvané postsPub .
Více sbírek v jedné publikaci . Pro jednu publikaci můžete odeslat více kurzorů pomocí pole.

Na klientovi a serveru:
```
Posts = new Meteor.Collection("posts");
Comments = new Meteor.Collection("comments");
```
Pouze na serveru:
```
Meteor.publish("postsAndComments", function() { 
    return [ 
        Posts.find(), 
        Comments.find() 
    ]; 
});
```
Pouze pro klienta:
```
Meteor.subscribe("postsAndComments");
```
Tím se synchronizují Posts kolekce a také Comments sběr pomocí jediné publikace nazvané postsAndComments . Tento typ publikace je vhodný pro relační data; například tam, kde můžete chtít publikovat pouze určité příspěvky a komentáře související pouze s těmito příspěvky. Podívejte se na balík, který dokáže tyto kurzory sestavit automaticky .
Více publikací pro jednu sbírku . Můžete použít více publikací k odeslání různých částí dat pro jednu kolekci, které jsou automaticky sloučeny Meteorem.

Na serveru a klientovi:
```
Posts = new Meteor.Collection("posts");
```
Pouze na serveru:
```
Meteor.publish("top10Posts", function() { 
    return Posts.find({}, {
        sort: {comments: -1}, 
        limit: 10
    });
});        
Meteor.publish("newest10Posts", function() { 
    return Posts.find({}, {
        sort: {timestamp: -1},
        limit: 10
    }); 
});
```
Pouze pro klienta:
```
Meteor.subscribe("top10Posts");
Meteor.subscribe("newest10Posts");
```
Tím se uživateli předá jak 10 příspěvků s největším počtem komentářů, tak 10 nejnovějších příspěvků na webu, čímž se obě sady dat sloučí do jednoho Posts sbírka. Pokud je jeden z nejnovějších příspěvků také příspěvek s největším počtem komentářů nebo naopak, Posts sbírka bude obsahovat méně než 20 položek. Toto je příklad toho, jak vám datový model v Meteoru umožňuje provádět výkonné operace slučování dat, aniž byste sami implementovali podrobnosti.
Více odběrů na publikaci. Můžete získat více sad dat ze stejné publikace pomocí různých argumentů.

Na serveru a klientovi:
```
Posts = new Meteor.Collection("posts");
```
Pouze na serveru:
```
Meteor.publish("postsByUser", function(user) { 
    return Posts.find({
        userId: user
    });
});        
```
Pouze pro klienta:
```
Meteor.subscribe("postsByUser", "fooUser");
Meteor.subscribe("postsByUser", "barUser");
```
To způsobí, že příspěvky od uživatele fooUser a barUser aby se obě zobrazovaly v posts sbírka. Tento model je vhodný, když máte několik různých výpočtů, které sledují různé části vašich dat a mohou být dynamicky aktualizovány. Pamatujte, že když se přihlásíte k odběru v Deps.autorun(...) , Meteor volá stop() na libovolném předchozím ovladači předplatného se stejným názvem automaticky, ale pokud tato předplatná používáte mimo autorun budete je muset zastavit sami. V tuto chvíli nemůžete v rámci autorun vytvořit dvě předplatná se stejným názvem výpočet, protože Meteor je nedokáže od sebe rozlišit.
Přesun libovolných dat do publikace. Publikace můžete zcela přizpůsobit tak, aby na serveru a klientovi nevyžadovaly stejné názvy kolekcí. Ve skutečnosti může server publikovat data, která nejsou vůbec podložena kolekcí. K tomu můžete použít API pro funkce publikování .

Pouze na serveru:
```
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();
    })    
});
```
Pouze pro klienta:
```
NewPosts = new Meteor.Collection("newposts");

Meteor.subscribe("newPostsPub");
```
Tím se synchronizuje 10 nejnovějších příspěvků z Posts sbírka na serveru (nazývaná posts v databázi) do NewPosts sběr na klientovi (nazývaný newposts v minimongo) pomocí publikace/předplatného s názvem newPostsPub . Všimněte si, že observeChanges se liší od observe , který umí spoustu dalších věcí.

Kód se zdá komplikovaný, ale když vrátíte kurzor do funkce publikování, je to v podstatě kód, který Meteor generuje v zákulisí. Psaní publikací tímto způsobem vám dává mnohem větší kontrolu nad tím, co je a co není zasíláno klientovi. Buďte však opatrní, protože observe musíte ručně vypnout zpracovává a označte, když je předplatné připraveno. Další informace naleznete v části Matt Debergalis popis tohoto procesu (ten příspěvek je však zastaralý). Samozřejmě to můžete zkombinovat s ostatními výše uvedenými částmi a potenciálně tak získat velmi jemné a komplikované publikace.

Omlouvám se za esej :-), ale mnoho lidí je z toho zmateno a myslím, že by bylo užitečné popsat všechny případy.