डेटा वापस लाया जा रहा है

GET की मदद से डेटा पढ़ना

हम अपने Firebase डेटाबेस से डेटा पढ़ सकते हैं. इसके लिए, हमें अपने Firebase डेटाबेस के यूआरएल एंडपॉइंट पर GET अनुरोध करना होगा. पिछले सेक्शन में दिए गए ब्लॉग के उदाहरण पर चलते हैं और अपनी ब्लॉग पोस्ट का सारा डेटा पढ़ते हैं: 

curl 'https://docs-examples.firebaseio.com/fireblog/posts.json?print=pretty'

अनुरोध पूरा होने पर, 200 OK एचटीटीपी स्टेटस कोड दिखेगा. साथ ही, रिस्पॉन्स में वह डेटा दिखेगा जिसे हम वापस पा रहे हैं.

यूआरआई पैरामीटर जोड़ना

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

auth

auth अनुरोध पैरामीटर की मदद से, Firebase Realtime Database Security Rules से सुरक्षित किए गए डेटा को ऐक्सेस किया जा सकता है. साथ ही, यह सभी तरह के अनुरोधों के साथ काम करता है. आर्ग्युमेंट, आपके Firebase ऐप्लिकेशन का पासवर्ड या पुष्टि करने वाला टोकन हो सकता है. इस बारे में Firebase प्रोजेक्ट में उपयोगकर्ता में बताया गया है. नीचे दिए गए उदाहरण में, हम auth के साथ GET अनुरोध भेजते हैं पैरामीटर, जहां CREDENTIAL आपके Firebase ऐप्लिकेशन का गुप्त पासवर्ड या पुष्टि करने वाला टोकन है: 

curl 'https://docs-examples.firebaseio.com/auth-example.json?auth=CREDENTIAL'

प्रिंट करें

print=pretty का इस्तेमाल करने पर, डेटा को ऐसे फ़ॉर्मैट में दिखाया जाता है जिसे कोई भी व्यक्ति आसानी से पढ़ सकता है. 

curl 'https://docs-examples.firebaseio.com/fireblog/posts.json?print=pretty'

print=silent तय करने पर, सफल होने पर 204 No Content दिखता है. 

curl 'https://docs-examples.firebaseio.com/fireblog/posts.json?print=silent'

कॉलबैक

किसी वेब ब्राउज़र से सभी डोमेन पर REST कॉल करने के लिए, रिस्पॉन्स को JavaScript कॉलबैक फ़ंक्शन में रैप करने के लिए, JSONP का इस्तेमाल किया जा सकता है. callback= जोड़ें, ताकि REST API, आपके बताए गए कॉलबैक फ़ंक्शन में, रिटर्न किए गए डेटा को रैप कर सके. उदाहरण के लिए: 

<script>
  function gotData(data) {
    console.log(data);
  }
</script>
<script src="https://docs-examples.firebaseio.com/fireblog/posts.json?callback=gotData">

कम

यह एक बेहतर सुविधा है. इसे इस तरह से डिज़ाइन किया गया है कि आपको बड़े डेटासेट के साथ काम करने के लिए, सब कुछ डाउनलोड करने की ज़रूरत न पड़े. इसका इस्तेमाल करने के लिए, shallow=true को पैरामीटर के तौर पर जोड़ें. इससे, दिखाए जाने वाले डेटा की जानकारी कम हो जाएगी. अगर जगह पर मौजूद डेटा, JSON प्राइमटिव (स्ट्रिंग, संख्या या बूलियन) है, तो उसकी वैल्यू ही दिखाई जाएगी. अगर जगह पर मौजूद डेटा स्नैपशॉट एक JSON ऑब्जेक्ट है, तो हर कुंजी की वैल्यू को true पर काट दिया जाएगा. उदाहरण के लिए, यहां दिए गए डेटा का इस्तेमाल करके: 

{
  "message": {
    "user": {
      "name": "Chris"
    },
    "body": "Hello!"
  }
}

// A request to /message.json?shallow=true
// would return the following:
{
  "user": true,
  "body": true
}

// A request to /message/body.json?shallow=true
// would simply return:
"Hello!"

इस curl अनुरोध के साथ आज़माएं: 

curl 'https://docs-examples.firebaseio.com/rest/retrieving-data.json?shallow=true&print=pretty'

टाइम आउट

इसका इस्तेमाल करके, यह तय करें कि सर्वर साइड पर कितना समय लगेगा. अगर पढ़ने का अनुरोध तय समय में पूरा नहीं होता है, तो वह HTTP 400 गड़बड़ी के साथ खत्म हो जाता है. यह तब फ़ायदेमंद होता है, जब आपको थोड़ा डेटा ट्रांसफ़र करना हो और आपको बड़े सबट्री को फ़ेच करने के लिए बहुत इंतज़ार न करना हो. डेटा के साइज़ और कैश मेमोरी के आधार पर, पढ़ने में लगने वाला असल समय अलग-अलग हो सकता है.

timeouts की वैल्यू, इस फ़ॉर्मैट में डालें: 3ms, 3s या 3min. साथ ही, संख्या और इकाई भी डालें. अगर timeout की वैल्यू नहीं दी गई है, तो 15min की वैल्यू लागू की जाएगी. अगर timeout कोई सकारात्मक संख्या नहीं है या यह तय सीमा से ज़्यादा है, तो अनुरोध को एचटीटीपी 400 गड़बड़ी के साथ अस्वीकार कर दिया जाएगा. नीचे दिए गए उदाहरण में, GET अनुरोध में 10 सेकंड का timeout शामिल है. 

curl 'https://docs-examples.firebaseio.com/rest/retrieving-data.json?timeout=10s'

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

हम अलग-अलग फ़ैक्टर के आधार पर डेटा को फ़िल्टर करने के लिए क्वेरी बना सकते हैं. सबसे पहले, आपको orderBy पैरामीटर का इस्तेमाल करके यह तय करना होगा कि आपको अपना डेटा कैसे फ़िल्टर करना है. इसके बाद, orderBy को इन पांच पैरामीटर में से किसी एक के साथ जोड़ें: limitToFirst, limitToLast, startAt, endAt, और equalTo.

Firebase में हम सभी को डायनासोर बहुत पसंद हैं. इसलिए, हम डायनासोर के बारे में तथ्यों के सैंपल डेटाबेस के स्निपेट का इस्तेमाल करके, यह दिखाएंगे कि डेटा को कैसे फ़िल्टर किया जा सकता है: 

{
  "lambeosaurus": {
    "height": 2.1,
    "length": 12.5,
    "weight": 5000
  },
  "stegosaurus": {
    "height": 4,
    "length": 9,
    "weight": 2500
  }
}

डेटा को तीन में से किसी एक तरीके से फ़िल्टर किया जा सकता है: चाइल्ड की, की या वैल्यू के हिसाब से. क्वेरी इनमें से किसी एक पैरामीटर से शुरू होती है. इसके बाद, उसे इनमें से एक या उससे ज़्यादा पैरामीटर के साथ जोड़ा जाना चाहिए: startAt, endAt, limitToFirst, limitToLast या equalTo.

किसी खास चाइल्ड बटन के हिसाब से फ़िल्टर करना

हम किसी सामान्य चाइल्ड की कोड को orderBy पैरामीटर में पास करके, नोड को फ़िल्टर कर सकते हैं. उदाहरण के लिए, तीन से ज़्यादा ऊंचाई वाले सभी डायनासोर को वापस लाने के लिए, हम ये काम कर सकते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="height"&startAt=3&print=pretty'

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

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

{
  "lambeosaurus": {
    "dimensions": {
      "height" : 2.1,
      "length" : 12.5,
      "weight": 5000
    }
  },
  "stegosaurus": {
    "dimensions": {
      "height" : 4,
      "length" : 9,
      "weight" : 2500
    }
  }
}

अब ऊंचाई की क्वेरी करने के लिए, हम किसी एक बटन के बजाय ऑब्जेक्ट के पूरे पाथ का इस्तेमाल करते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="dimensions/height"&startAt=3&print=pretty'

क्वेरी को एक बार में सिर्फ़ एक कुंजी के हिसाब से फ़िल्टर किया जा सकता है. एक ही अनुरोध में orderBy पैरामीटर का कई बार इस्तेमाल करने पर गड़बड़ी का मैसेज मिलता है.

बटन के हिसाब से फ़िल्टर करना

orderBy="$key" पैरामीटर का इस्तेमाल करके, नोड को उनकी कुंजियों के हिसाब से भी फ़िल्टर किया जा सकता है. इस उदाहरण में, a से m तक के अक्षर से शुरू होने वाले सभी डायनासोर के नाम दिखाए गए हैं: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="$key"&startAt="a"&endAt="m"&print=pretty'

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

orderBy="$value" पैरामीटर का इस्तेमाल करके, नोड को उनकी चाइल्ड बटन की वैल्यू के हिसाब से फ़िल्टर किया जा सकता है. मान लें कि डायनासोर एक स्पोर्ट्स प्रतियोगिता में हिस्सा ले रहे हैं और हम उनके स्कोर का ट्रैक इस फ़ॉर्मैट में रख रहे हैं: 

{
  "scores": {
    "bruhathkayosaurus": 55,
    "lambeosaurus": 21,
    "linhenykus": 80,
    "pterodactyl": 93,
    "stegosaurus": 5,
    "triceratops": 22
  }
}

50 से ज़्यादा स्कोर वाले सभी डायनासोर को वापस लाने के लिए, हम यह अनुरोध कर सकते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/scores.json?orderBy="$value"&startAt=50&print=pretty'

orderBy="$value" का इस्तेमाल करते समय, null, बूलियन, स्ट्रिंग, और ऑब्जेक्ट वैल्यू को क्रम से लगाने का तरीका जानने के लिए, डेटा को क्रम से लगाने का तरीका लेख पढ़ें.

कॉम्प्लेक्स फ़िल्टरिंग

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

क्वेरी सीमित करना

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

डायनासोर के बारे में जानकारी वाले डेटाबेस और orderBy का इस्तेमाल करके, हम सबसे ज़्यादा वज़न वाले दो डायनासोर के बारे में पता लगा सकते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="weight"&limitToLast=2&print=pretty'

इसी तरह, limitToFirst का इस्तेमाल करके, सबसे छोटे दो डायनासोर ढूंढे जा सकते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="height"&limitToFirst=2&print=pretty'

हम orderBy="$value" की मदद से, सीमित क्वेरी भी कर सकते हैं. अगर हमें सबसे ज़्यादा स्कोर करने वाले तीन डायनो स्पोर्ट्स खिलाड़ियों का लीडरबोर्ड बनाना है, तो ये काम किए जा सकते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/scores.json?orderBy="$value"&limitToLast=3&print=pretty'

रेंज क्वेरी

startAt, endAt, और equalTo का इस्तेमाल करके, अपनी क्वेरी के लिए, शुरू और खत्म होने के समय को अपनी पसंद के मुताबिक चुना जा सकता है. उदाहरण के लिए, अगर हमें ऐसे सभी डायनासोर ढूंढने हैं जो कम से कम तीन मीटर लंबे हैं, तो orderBy और startAt को जोड़ा जा सकता है: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="height"&startAt=3&print=pretty'

endAt का इस्तेमाल करके, उन सभी डायनासोर को ढूंढा जा सकता है जिनके नाम, लिक्सिकोग्राफ़ी के हिसाब से Pterodactyl से पहले आते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="$key"&endAt="pterodactyl"&print=pretty'

अपनी क्वेरी के दोनों छोर सीमित करने के लिए, हम startAt और endAt को जोड़ सकते हैं. इस उदाहरण में, ऐसे सभी डायनासोर ढूंढे जाते हैं जिनका नाम "b" अक्षर से शुरू होता है: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="$key"&startAt="b"&endAt="b\uf8ff"&print=pretty'

रेंज क्वेरी तब भी काम की होती हैं, जब आपको अपने डेटा को पेज पर दिखाना हो.

जानकारी को एक जगह इकट्ठा किया जा रहा है

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

MY_FAV_DINO_HEIGHT=`curl "https://dinosaur-facts.firebaseio.com/dinosaurs/stegosaurus/height.json"`
curl "https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy=\"height\"&endAt=${MY_FAV_DINO_HEIGHT}&print=pretty"

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

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

orderBy

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

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

orderBy="$key"

अपने डेटा को क्रम से लगाने के लिए orderBy="$key" पैरामीटर का इस्तेमाल करने पर, डेटा को कुंजी के हिसाब से, यहां बताए गए क्रम में दिखाया जाएगा. ध्यान रखें कि कुंजियां सिर्फ़ स्ट्रिंग हो सकती हैं.

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

orderBy="$value"

अपने डेटा को क्रम से लगाने के लिए orderBy="$value" पैरामीटर का इस्तेमाल करने पर, चाइल्ड एलिमेंट को उनकी वैल्यू के हिसाब से क्रम में लगाया जाएगा. क्रम से लगाने की शर्तें, चाइल्ड की-वर्ड के हिसाब से लगाए गए डेटा जैसी ही होती हैं. हालांकि, इसमें किसी चाइल्ड की-वर्ड की वैल्यू के बजाय, नोड की वैल्यू का इस्तेमाल किया जाता है.

orderBy="$priority"

अपने डेटा को क्रम से लगाने के लिए orderBy="$priority" पैरामीटर का इस्तेमाल करने पर, बच्चों का क्रम, उनकी प्राथमिकता और कुंजी के हिसाब से तय किया जाता है. ध्यान रखें कि प्राथमिकता की वैल्यू के तौर पर सिर्फ़ संख्याएं या स्ट्रिंग इस्तेमाल की जा सकती हैं.

  1. जिन बच्चों के लिए कोई प्राथमिकता नहीं तय की गई है (डिफ़ॉल्ट) वे पहले दिखते हैं.
  2. इसके बाद, उन बच्चों की जानकारी दिखती है जिनकी प्राथमिकता नंबर है. इन्हें प्राथमिकता के हिसाब से, संख्या के हिसाब से, छोटे से बड़े क्रम में लगाया जाता है.
  3. जिन बच्चों की प्राथमिकता स्ट्रिंग है वे सबसे आखिर में दिखते हैं. इन्हें प्राथमिकता के हिसाब से, अंग्रेज़ी के अक्षरों के क्रम में लगाया जाता है.
  4. जब दो बच्चों की प्राथमिकता एक जैसी हो (इसमें कोई प्राथमिकता नहीं भी शामिल है), तो उन्हें कुंजी के हिसाब से क्रम में लगाया जाता है. अंकों वाली कुंजियां पहले आती हैं (अंकों के हिसाब से क्रम में लगाई जाती हैं). इसके बाद, बाकी कुंजियां (वर्णमाला के हिसाब से क्रम में लगाई जाती हैं).

प्राथमिकताओं के बारे में ज़्यादा जानकारी के लिए, एपीआई रेफ़रंस देखें.

REST API से स्ट्रीमिंग करना

Firebase REST एंडपॉइंट, EventSource / सर्वर से भेजे गए इवेंट प्रोटोकॉल के साथ काम करते हैं. इससे, हमारे Firebase डेटाबेस में किसी एक जगह पर बदलावों को स्ट्रीम करना आसान हो जाता है.

स्ट्रीमिंग शुरू करने के लिए, हमें ये काम करने होंगे:

  1. क्लाइंट के Accept हेडर को text/event-stream पर सेट करें
  2. एचटीटीपी रीडायरेक्ट का पालन करें. खास तौर पर, एचटीटीपी स्टेटस कोड 307 का पालन करें
  3. अगर Firebase डेटाबेस की जगह को पढ़ने के लिए अनुमति की ज़रूरत है, तो auth क्वेरी पैरामीटर शामिल करें

इसके बदले, सर्वर नाम वाले इवेंट भेजेगा, क्योंकि अनुरोध किए गए यूआरएल पर डेटा की स्थिति में बदलाव होता है. इन मैसेज का स्ट्रक्चर, EventSource प्रोटोकॉल के मुताबिक होता है: 

event: event name
data: JSON encoded data payload

सर्वर ये इवेंट भेज सकता है:

डालें JSON में कोड में बदला गया डेटा, दो कुंजियों वाला ऑब्जेक्ट होगा: पाथ और डेटा
पाथ, अनुरोध यूआरएल के हिसाब से किसी जगह पर ले जाता है
क्लाइंट को अपनी कैश मेमोरी में उस जगह के सभी डेटा को मैसेज में दिए गए डेटा से बदलना चाहिए
पैच JSON में कोड में बदला गया डेटा, दो कुंजियों वाला ऑब्जेक्ट होगा: पाथ और डेटा
पाथ, अनुरोध यूआरएल के हिसाब से किसी जगह पर ले जाता है
डेटा में मौजूद हर कुंजी के लिए, क्लाइंट को अपनी कैश मेमोरी में मौजूद उस कुंजी को मैसेज में मौजूद उस कुंजी के डेटा से बदलना चाहिए
कीप-अलाइव इस इवेंट का डेटा शून्य है. आपको कुछ करने की ज़रूरत नहीं है
रद्द करें इस इवेंट का डेटा शून्य है
यह इवेंट तब भेजा जाएगा, जब Firebase Realtime Database Security Rules की वजह से अनुरोध की गई जगह पर डेटा पढ़ने की अनुमति नहीं होगी
auth_revoked इस इवेंट का डेटा एक स्ट्रिंग होती है, जो बताती है कि क्रेडेंशियल की समयसीमा खत्म हो गई है
यह इवेंट तब भेजा जाएगा, जब दिया गया पुष्टि करने वाला पैरामीटर अमान्य हो जाएगा

यहां उन इवेंट के सेट का उदाहरण दिया गया है जिन्हें सर्वर भेज सकता है: 

// Set your entire cache to {"a": 1, "b": 2}
event: put
data: {"path": "/", "data": {"a": 1, "b": 2}}


// Put the new data in your cache under the key 'c', so that the complete cache now looks like:
// {"a": 1, "b": 2, "c": {"foo": true, "bar": false}}
event: put
data: {"path": "/c", "data": {"foo": true, "bar": false}}


// For each key in the data, update (or add) the corresponding key in your cache at path /c,
// for a final cache of: {"a": 1, "b": 2, "c": {"foo": 3, "bar": false, "baz": 4}}
event: patch
data: {"path": "/c", "data": {"foo": 3, "baz": 4}}

अगर Go का इस्तेमाल किया जा रहा है, तो Firego देखें. यह Firebase REST और स्ट्रीमिंग एपीआई के लिए, तीसरे पक्ष का रैपर है.