Meteor:perbedaan antara nama untuk koleksi, variabel, publikasi, dan langganan?

Mari kita bedakan nama-nama berbeda yang mungkin harus Anda hadapi saat memprogram Meteor:

Nama variabel , seperti Posts = new Meteor.Collection(...) . Ini hanya digunakan agar kode Anda tahu cara mengakses variabel ini. Meteor tidak tahu atau peduli apa itu, meskipun konvensinya menggunakan huruf besar.
Nama koleksi , seperti new Meteor.Collection("posts") . Ini memetakan ke nama koleksi MongoDB (di server) atau koleksi minimongo (di klien).
Nama publikasi dan langganan , digunakan di Meteor.publish("foo", ...) atau Meteor.subscribe("foo") . Ini harus cocok agar klien dapat berlangganan beberapa data di server.

Ada dua hal yang perlu Anda sesuaikan dalam model data Meteor:

Nama publikasi dan langganan terkaitnya
(biasanya) Nama koleksi pada klien dan server, jika menggunakan model koleksi default

Nama langganan harus selalu cocok dengan nama publikasi. Namun, koleksi yang dikirim untuk langganan tertentu tidak perlu ada hubungannya dengan nama langganan. Bahkan, seseorang dapat mengirim lebih dari beberapa kursor dalam satu publikasi atau satu koleksi di atas publikasi yang berbeda atau bahkan beberapa langganan per publikasi , yang muncul digabungkan sebagai satu di klien. Anda juga dapat memiliki nama koleksi yang berbeda di server dan klien; baca terus...

Mari kita tinjau kasus yang berbeda:

Model langganan sederhana . Ini adalah yang biasanya Anda lihat di demo Meteor langsung.

Di klien dan server,
```
Posts = new Meteor.Collection("posts");
```
Hanya di server:
```
Meteor.publish("postsPub", function() { 
    return Posts.find() 
});
```
Hanya pada klien:
```
Meteor.subscribe("postsPub")
```
Ini menyinkronkan Posts koleksi (yang diberi nama posts dalam database) menggunakan publikasi yang disebut postsPub .
Beberapa koleksi dalam satu publikasi . Anda dapat mengirim beberapa kursor untuk satu publikasi, menggunakan larik.

Di klien dan server:
```
Posts = new Meteor.Collection("posts");
Comments = new Meteor.Collection("comments");
```
Hanya di server:
```
Meteor.publish("postsAndComments", function() { 
    return [ 
        Posts.find(), 
        Comments.find() 
    ]; 
});
```
Hanya pada klien:
```
Meteor.subscribe("postsAndComments");
```
Ini menyinkronkan Posts koleksi serta Comments koleksi menggunakan satu publikasi yang disebut postsAndComments . Jenis publikasi ini sangat cocok untuk data relasional; misalnya, di mana Anda mungkin hanya ingin mempublikasikan posting tertentu dan komentar yang terkait hanya dengan posting tersebut. Lihat paket yang dapat membuat kursor ini secara otomatis .
Beberapa publikasi untuk satu koleksi . Anda dapat menggunakan beberapa publikasi untuk mengirim potongan data yang berbeda untuk satu koleksi yang digabungkan oleh Meteor secara otomatis.

Di server dan klien:
```
Posts = new Meteor.Collection("posts");
```
Hanya di 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
    }); 
});
```
Hanya pada klien:
```
Meteor.subscribe("top10Posts");
Meteor.subscribe("newest10Posts");
```
Ini mendorong 10 pos dengan komentar terbanyak serta 10 pos terbaru di situs kepada pengguna, yang melihat kedua kumpulan data digabungkan menjadi satu Posts koleksi. Jika salah satu postingan terbaru juga merupakan postingan dengan komentar terbanyak atau sebaliknya, Posts koleksi akan berisi kurang dari 20 item. Ini adalah contoh bagaimana model data di Meteor memungkinkan Anda melakukan operasi penggabungan data yang hebat tanpa menerapkan detailnya sendiri.
Beberapa langganan per publikasi. Anda bisa mendapatkan beberapa kumpulan data dari publikasi yang sama menggunakan argumen yang berbeda.

Di server dan klien:
```
Posts = new Meteor.Collection("posts");
```
Hanya di server:
```
Meteor.publish("postsByUser", function(user) { 
    return Posts.find({
        userId: user
    });
});        
```
Hanya pada klien:
```
Meteor.subscribe("postsByUser", "fooUser");
Meteor.subscribe("postsByUser", "barUser");
```
Ini menyebabkan posting oleh fooUser dan barUser untuk keduanya muncul di posts koleksi. Model ini nyaman ketika Anda memiliki beberapa perhitungan berbeda yang melihat irisan data Anda yang berbeda dan dapat diperbarui secara dinamis. Perhatikan bahwa ketika Anda berlangganan di dalam Deps.autorun(...) , Meteor memanggil stop() pada pegangan langganan sebelumnya dengan nama yang sama secara otomatis, tetapi jika Anda menggunakan langganan ini di luar autorun Anda harus menghentikan mereka sendiri. Mulai sekarang, Anda tidak dapat melakukan dua langganan dengan nama yang sama di dalam autorun perhitungan, karena Meteor tidak dapat membedakannya.
Mendorong data arbitrer melalui publikasi. Anda dapat sepenuhnya menyesuaikan publikasi untuk tidak memerlukan nama koleksi yang sama di server dan klien. Bahkan, server dapat mempublikasikan data yang tidak didukung oleh koleksi sama sekali. Untuk melakukannya, Anda dapat menggunakan API untuk fungsi publikasi .

Hanya di 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();
    })    
});
```
Hanya pada klien:
```
NewPosts = new Meteor.Collection("newposts");

Meteor.subscribe("newPostsPub");
```
Ini menyinkronkan 10 posting terbaru dari Posts koleksi di server (disebut posts dalam database) ke NewPosts koleksi pada klien (disebut newposts in minimongo) menggunakan publikasi/langganan yang disebut newPostsPub . Perhatikan bahwa observeChanges berbeda dari observe , yang dapat melakukan banyak hal lainnya.

Kodenya tampak rumit, tetapi ketika Anda mengembalikan kursor di dalam fungsi publikasikan, ini pada dasarnya adalah kode yang dihasilkan Meteor di belakang layar. Menulis publikasi dengan cara ini memberi Anda lebih banyak kontrol atas apa yang dikirim dan tidak dikirim ke klien. Namun berhati-hatilah, karena Anda harus mematikan observe secara manual menangani dan menandai saat langganan siap. Untuk informasi lebih lanjut, lihat deskripsi Matt Debergalis tentang proses ini (Namun, posting itu sudah ketinggalan zaman). Tentu saja, Anda dapat menggabungkan ini dengan bagian lain di atas untuk berpotensi mendapatkan publikasi yang sangat bernuansa dan rumit.

Maaf untuk esainya :-) tetapi banyak orang menjadi bingung tentang ini dan saya pikir itu akan berguna untuk menggambarkan semua kasus.