वेब पर डेटा की सूचियों के साथ काम करना

डेटाबेस का रेफ़रंस पाना

डेटाबेस से डेटा पढ़ने या उसमें डेटा लिखने के लिए, आपको firebase.database.Reference के इंस्टेंस की ज़रूरत होगी:

import { getDatabase } from "firebase/database";

const database = getDatabase();
rtdb_get_reference.js

var database = firebase.database();
index.js

रीडिंग और राइटिंग लिस्ट

डेटा की सूची में जोड़ना

मल्टीयूज़र ऐप्लिकेशन में किसी सूची में डेटा जोड़ने के लिए, push() तरीके का इस्तेमाल करें. push() तरीके से, हर बार एक यूनीक कुंजी जनरेट होती है. ऐसा तब होता है, जब किसी बच्चे को तय किए गए Firebase रेफ़रंस में जोड़ा जाता है. सूची में मौजूद हर नए एलिमेंट के लिए, अपने-आप जनरेट होने वाली इन कुंजियों का इस्तेमाल करके, कई क्लाइंट एक ही समय में एक ही जगह पर बच्चों को जोड़ सकते हैं. इससे, लिखने से जुड़ी समस्याएं नहीं होती हैं. push() से जनरेट की गई यूनीक कुंजी, टाइमस्टैंप पर आधारित होती है. इसलिए, सूची के आइटम अपने-आप क्रम से लग जाते हैं.

push() तरीके से मिले नए डेटा के रेफ़रंस का इस्तेमाल करके, बच्चे के अपने-आप जनरेट होने वाले कुंजी की वैल्यू पाई जा सकती है या बच्चे के लिए डेटा सेट किया जा सकता है. push() के रेफ़रंस की .key प्रॉपर्टी में, अपने-आप जनरेट हुई कुंजी होती है.

अपने-आप जनरेट होने वाली इन कुंजियों का इस्तेमाल करके, डेटा स्ट्रक्चर को आसानी से फ़्लैट किया जा सकता है. ज़्यादा जानकारी के लिए, डेटा फ़ैन-आउट का उदाहरण देखें.

उदाहरण के लिए, push() का इस्तेमाल, किसी सोशल ऐप्लिकेशन में पोस्ट की सूची में नई पोस्ट जोड़ने के लिए किया जा सकता है:

import { getDatabase, ref, push, set } from "firebase/database";

// Create a new post reference with an auto-generated id
const db = getDatabase();
const postListRef = ref(db, 'posts');
const newPostRef = push(postListRef);
set(newPostRef, {
    // ...
});
rtdb_social_push.js

// Create a new post reference with an auto-generated id
var postListRef = firebase.database().ref('posts');
var newPostRef = postListRef.push();
newPostRef.set({
    // ...
});
lists-of-data.js

बच्चों के लिए बने इवेंट को मॉनिटर करने की अनुमति

किसी नोड के बच्चों के साथ होने वाली खास कार्रवाइयों के जवाब में, चाइल्ड इवेंट ट्रिगर होते हैं. जैसे, push() तरीके से जोड़ा गया नया बच्चा या update() तरीके से अपडेट किया गया बच्चा.

इन सभी का एक साथ इस्तेमाल करके, डेटाबेस में किसी खास नोड में हुए बदलावों के बारे में सुना जा सकता है. उदाहरण के लिए, सोशल ब्लॉगिंग ऐप्लिकेशन इन तरीकों का इस्तेमाल एक साथ कर सकता है, ताकि किसी पोस्ट की टिप्पणियों में होने वाली गतिविधि को मॉनिटर किया जा सके. इसे यहां दिखाया गया है:

import { getDatabase, ref, onChildAdded, onChildChanged, onChildRemoved } from "firebase/database";

const db = getDatabase();
const commentsRef = ref(db, 'post-comments/' + postId);
onChildAdded(commentsRef, (data) => {
  addCommentElement(postElement, data.key, data.val().text, data.val().author);
});

onChildChanged(commentsRef, (data) => {
  setCommentValues(postElement, data.key, data.val().text, data.val().author);
});

onChildRemoved(commentsRef, (data) => {
  deleteComment(postElement, data.key);
});
rtdb_social_listen_children.js

var commentsRef = firebase.database().ref('post-comments/' + postId);
commentsRef.on('child_added', (data) => {
  addCommentElement(postElement, data.key, data.val().text, data.val().author);
});

commentsRef.on('child_changed', (data) => {
  setCommentValues(postElement, data.key, data.val().text, data.val().author);
});

commentsRef.on('child_removed', (data) => {
  deleteComment(postElement, data.key);
});
lists-of-data.js

वैल्यू इवेंट के लिए लिसनर

डेटा की सूचियों को पढ़ने के लिए, चाइल्ड इवेंट को सुनने का सुझाव दिया जाता है. हालांकि, कुछ मामलों में सूची के रेफ़रंस पर वैल्यू इवेंट को सुनना फ़ायदेमंद होता है.

डेटा की सूची में value ऑब्ज़र्वर को अटैच करने पर, डेटा की पूरी सूची एक स्नैपशॉट के तौर पर दिखेगी. इसके बाद, इस स्नैपशॉट को लूप करके, अलग-अलग बच्चों का डेटा ऐक्सेस किया जा सकता है.

क्वेरी के लिए सिर्फ़ एक मैच होने पर भी, स्नैपशॉट एक सूची होती है. इसमें सिर्फ़ एक आइटम होता है. आइटम को ऐक्सेस करने के लिए, आपको नतीजे पर लूप करना होगा:

import { getDatabase, ref, onValue } from "firebase/database";

const db = getDatabase();
const dbRef = ref(db, '/a/b/c');

onValue(dbRef, (snapshot) => {
  snapshot.forEach((childSnapshot) => {
    const childKey = childSnapshot.key;
    const childData = childSnapshot.val();
    // ...
  });
}, {
  onlyOnce: true
});
rtdb_social_listen_value.js

ref.once('value', (snapshot) => {
  snapshot.forEach((childSnapshot) => {
    var childKey = childSnapshot.key;
    var childData = childSnapshot.val();
    // ...
  });
});
lists-of-data.js

यह पैटर्न तब काम आ सकता है, जब आपको किसी सूची के सभी बच्चों को एक ही ऑपरेशन में फ़ेच करना हो. इसके बजाय, आपको बच्चों के जोड़े जाने की अतिरिक्त घटनाओं को सुनना हो.

डेटा को क्रम से लगाना और फ़िल्टर करना

Realtime Database Query क्लास का इस्तेमाल करके, कुंजी, वैल्यू या चाइल्ड की वैल्यू के हिसाब से क्रम से लगाया गया डेटा वापस पाया जा सकता है. क्रम से लगाए गए नतीजों को, नतीजों की किसी खास संख्या या कुंजियों या वैल्यू की किसी सीमा के हिसाब से भी फ़िल्टर किया जा सकता है.

डेटा को क्रम से लगाना

क्रम से लगाया गया डेटा वापस पाने के लिए, सबसे पहले क्रम से लगाने के तरीकों में से किसी एक को चुनें. इससे यह तय किया जा सकेगा कि नतीजों को किस क्रम में लगाया जाए:

एक बार में, सिर्फ़ एक order-by तरीके का इस्तेमाल किया जा सकता है. एक ही क्वेरी में order-by तरीके को कई बार कॉल करने पर गड़बड़ी होती है.

यहां दिए गए उदाहरण में बताया गया है कि किसी उपयोगकर्ता की सबसे ज़्यादा स्टार वाली पोस्ट की सूची कैसे वापस पाई जा सकती है:

import { getDatabase, ref, query, orderByChild } from "firebase/database";
import { getAuth } from "firebase/auth";

const db = getDatabase();
const auth = getAuth();

const myUserId = auth.currentUser.uid;
const topUserPostsRef = query(ref(db, 'user-posts/' + myUserId), orderByChild('starCount'));
rtdb_social_most_starred.js

var myUserId = firebase.auth().currentUser.uid;
var topUserPostsRef = firebase.database().ref('user-posts/' + myUserId).orderByChild('starCount');
lists-of-data.js

इससे ऐसी क्वेरी तय होती है जिसे चाइल्ड लिसनर के साथ जोड़ने पर, क्लाइंट को डेटाबेस में मौजूद पाथ से उपयोगकर्ता की पोस्ट के साथ सिंक किया जाता है. ऐसा उपयोगकर्ता के आईडी के आधार पर किया जाता है. साथ ही, पोस्ट को मिले स्टार की संख्या के हिसाब से क्रम में लगाया जाता है. आईडी को इंडेक्स की के तौर पर इस्तेमाल करने की इस तकनीक को डेटा फ़ैन आउट कहा जाता है. इसके बारे में ज़्यादा जानने के लिए, अपने डेटाबेस को व्यवस्थित करें लेख पढ़ें.

orderByChild() तरीके को कॉल करने पर, नतीजे क्रम से लगाने के लिए चाइल्ड की तय की जाती है. इस मामले में, पोस्ट को उनके "starCount" चाइल्ड की वैल्यू के हिसाब से क्रम में लगाया जाता है. अगर आपके पास इस तरह का डेटा है, तो क्वेरी को नेस्ट किए गए बच्चों के हिसाब से भी क्रम में लगाया जा सकता है:

"posts": {
  "ts-functions": {
    "metrics": {
      "views" : 1200000,
      "likes" : 251000,
      "shares": 1200,
    },
    "title" : "Why you should use TypeScript for writing Cloud Functions",
    "author": "Doug",
  },
  "android-arch-3": {
    "metrics": {
      "views" : 900000,
      "likes" : 117000,
      "shares": 144,
    },
    "title" : "Using Android Architecture Components with Firebase Realtime Database (Part 3)",
    "author": "Doug",
  }
},

इस मामले में, हम अपनी सूची के एलिमेंट को metrics कुंजी में नेस्ट की गई वैल्यू के हिसाब से क्रम में लगा सकते हैं. इसके लिए, हमें अपने orderByChild() कॉल में नेस्ट किए गए चाइल्ड का रिलेटिव पाथ तय करना होगा.

import { getDatabase, ref, query, orderByChild } from "firebase/database";

const db = getDatabase();
const mostViewedPosts = query(ref(db, 'posts'), orderByChild('metrics/views'));
rtdb_social_most_viewed.js

var mostViewedPosts = firebase.database().ref('posts').orderByChild('metrics/views');
lists-of-data.js

अन्य डेटा टाइप को क्रम से लगाने के तरीके के बारे में ज़्यादा जानने के लिए, क्वेरी डेटा को क्रम से कैसे लगाया जाता है लेख पढ़ें.

डेटा फ़िल्टर करना

डेटा को फ़िल्टर करने के लिए, क्वेरी बनाते समय सीमा या रेंज के किसी भी तरीके को क्रम से लगाने के तरीके के साथ जोड़ा जा सकता है.

order-by के तरीकों के उलट, limit या range फ़ंक्शन को एक साथ इस्तेमाल किया जा सकता है. उदाहरण के लिए, startAt() और endAt() तरीकों को मिलाकर, नतीजों को वैल्यू की तय की गई सीमा तक सीमित किया जा सकता है.

नतीजों की संख्या सीमित करना

limitToFirst() और limitToLast() तरीकों का इस्तेमाल करके, किसी इवेंट के लिए सिंक किए जाने वाले बच्चों की ज़्यादा से ज़्यादा संख्या सेट की जा सकती है. उदाहरण के लिए, अगर आपने limitToFirst() का इस्तेमाल करके 100 की सीमा तय की है, तो आपको शुरुआत में सिर्फ़ 100 child_added इवेंट मिलेंगे. अगर आपके Firebase डेटाबेस में 100 से कम आइटम सेव हैं, तो हर आइटम के लिए child_added इवेंट ट्रिगर होता है.

आइटम में बदलाव होने पर, आपको क्वेरी में शामिल होने वाले आइटम के लिए child_added इवेंट और क्वेरी से बाहर निकलने वाले आइटम के लिए child_removed इवेंट मिलते हैं. इससे आइटम की कुल संख्या 100 बनी रहती है.

यहां दिए गए उदाहरण में बताया गया है कि ब्लॉगिंग ऐप्लिकेशन का उदाहरण, सभी उपयोगकर्ताओं की 100 सबसे नई पोस्ट की सूची पाने के लिए क्वेरी को कैसे तय करता है:

import { getDatabase, ref, query, limitToLast } from "firebase/database";

const db = getDatabase();
const recentPostsRef = query(ref(db, 'posts'), limitToLast(100));
rtdb_social_recent.js

var recentPostsRef = firebase.database().ref('posts').limitToLast(100);
lists-of-data.js

इस उदाहरण में सिर्फ़ एक क्वेरी तय की गई है. डेटा को असल में सिंक करने के लिए, इसमें लिसनर अटैच होना चाहिए.

कुंजी या वैल्यू के हिसाब से फ़िल्टर करना

क्वेरी के लिए आर्बिट्रेरी स्टार्टिंग, एंडिंग, और इक्विवेलेंस पॉइंट चुनने के लिए, startAt(), startAfter(),endAt(), endBefore(), और equalTo() का इस्तेमाल किया जा सकता है. यह डेटा को पेज के हिसाब से बांटने या उन आइटम को ढूंढने के लिए काम आ सकता है जिनमें किसी खास वैल्यू वाले बच्चे मौजूद हों.

क्वेरी के डेटा को कैसे क्रम से लगाया जाता है

इस सेक्शन में बताया गया है कि Query क्लास में, ऑर्डर करने के हर तरीके से डेटा को कैसे क्रम से लगाया जाता है.

orderByChild

orderByChild() का इस्तेमाल करने पर, दी गई चाइल्ड की के हिसाब से डेटा को इस तरह से क्रम में लगाया जाता है:

1. जिन बच्चों के लिए, दी गई चाइल्ड की की null वैल्यू है वे सबसे पहले दिखते हैं.
2. इसके बाद, चाइल्ड की तय की गई कुंजी के लिए false वैल्यू वाले बच्चे दिखते हैं. अगर कई चाइल्ड में false की वैल्यू है, तो उन्हें कुंजी के हिसाब से लेक्सिकोग्राफ़िक क्रम में लगाया जाता है.
3. इसके बाद, चाइल्ड की तय की गई कुंजी के लिए true वैल्यू वाले बच्चे दिखते हैं. अगर कई चाइल्ड में true वैल्यू है, तो उन्हें कुंजी के हिसाब से लेक्सिकोग्राफ़िक क्रम में लगाया जाता है.
4. इसके बाद, संख्या वाली वैल्यू वाले बच्चे आते हैं. इन्हें बढ़ते क्रम में लगाया जाता है. अगर एक से ज़्यादा चाइल्ड नोड के लिए, तय किए गए चाइल्ड नोड की संख्यात्मक वैल्यू एक जैसी है, तो उन्हें कुंजी के हिसाब से क्रम में लगाया जाता है.
5. स्ट्रिंग, संख्याओं के बाद आती हैं और इन्हें लेक्सिकोग्राफ़िक क्रम में बढ़ते क्रम में लगाया जाता है. अगर कई बच्चों के लिए, चाइल्ड नोड की वैल्यू एक जैसी है, तो उन्हें कुंजी के हिसाब से लेक्सिकोग्राफ़िक क्रम में लगाया जाता है.
6. ऑब्जेक्ट आखिर में आते हैं और उन्हें कुंजी के हिसाब से, लेक्सिकोग्राफ़िक क्रम में बढ़ते क्रम में लगाया जाता है.

orderByKey

अपने डेटा को क्रम से लगाने के लिए orderByKey() का इस्तेमाल करने पर, डेटा को कुंजी के हिसाब से बढ़ते क्रम में दिखाया जाता है.

1. जिन बच्चों की कुकी में मौजूद कुंजी को 32-बिट पूर्णांक के तौर पर पार्स किया जा सकता है उन्हें सबसे ऊपर दिखाया जाता है. इन्हें बढ़ते क्रम में लगाया जाता है.
2. इसके बाद, उन बच्चों को दिखाया जाता है जिनकी कुंजी के तौर पर स्ट्रिंग वैल्यू होती है. इन्हें लेक्सिकोग्राफ़िक क्रम में बढ़ते क्रम में क्रमबद्ध किया जाता है.

orderByValue

orderByValue() का इस्तेमाल करने पर, बच्चों को उनकी वैल्यू के हिसाब से क्रम में लगाया जाता है. क्रम से लगाने के मानदंड, orderByChild() में दिए गए मानदंडों के जैसे ही होते हैं. हालांकि, इसमें किसी तय की गई चाइल्ड की के मान के बजाय, नोड की वैल्यू का इस्तेमाल किया जाता है.

लिसनर को अलग करना

अपने Firebase डेटाबेस रेफ़रंस पर off() तरीके को कॉल करके, कॉलबैक हटाए जाते हैं.

off() में पैरामीटर के तौर पर पास करके, किसी एक लिसनर को हटाया जा सकता है. बिना किसी आर्ग्युमेंट के off() को कॉल करने पर, उस जगह पर मौजूद सभी श्रोता हट जाते हैं.

माता-पिता के तौर पर सेट किए गए लिसनर पर off() को कॉल करने से, उसके चाइल्ड नोड पर रजिस्टर किए गए लिसनर अपने-आप नहीं हटते; कॉलबैक हटाने के लिए, किसी भी चाइल्ड लिसनर पर भी off() को कॉल करना होगा.

अगले चरण

• डेटा को स्ट्रक्चर करने का तरीका जानें
• डेटा को ऑफ़लाइन सेव करना