Firebase डेटाबेस सुरक्षा नियम एपीआई

नियम: टाइप

.पढ़ें

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

.read नियम, सुरक्षा के नियम का ऐसा नियम है जो क्लाइंट को Firebase रीयल टाइम डेटाबेस की जगह की जानकारी को पढ़ने का ऐक्सेस देता है. उदाहरण के लिए:

 ".read": "auth != null && auth.provider == 'twitter'"

.read नियम की वैल्यू एक स्ट्रिंग होती है. इसका आकलन, JavaScript के एक्सप्रेशन सिंटैक्स के सबसेट के तौर पर किया जाता है. इसके लिए, व्यवहार में कुछ बदलाव किए जाते हैं, ताकि साफ़ तौर पर और सटीक नतीजे दिखाए जा सकें. किसी जगह का डेटा पढ़ने की अनुमति देने वाला .read नियम, उस जगह के सभी डिसेंडेंट को भी पढ़ने की अनुमति देता है. भले ही, डिसेंडेंट के खुद के .read नियम लागू न हों.

.read नियम के पास Firebase रीयल टाइम डेटाबेस के नियम वैरिएबल का ऐक्सेस होता है. हालांकि, इसके पास newData के अलावा सभी प्रॉपर्टी का ऐक्सेस होता है.

.लिखें

यह क्लाइंट, Firebase रीयल टाइम डेटाबेस की जगह की जानकारी में, क्लाइंट को लिखने का ऐक्सेस देता है.

.write नियम, सुरक्षा के नियम का ही हिस्सा है. इसकी मदद से, क्लाइंट को Firebase रीयल टाइम डेटाबेस की लोकेशन में बदलाव करने का ऐक्सेस दिया जाता है. उदाहरण के लिए:

".write": "auth != null && auth.token.isAdmin == true"

.write नियम की वैल्यू एक स्ट्रिंग होती है. इसका आकलन, JavaScript के एक्सप्रेशन सिंटैक्स के सबसेट के तौर पर किया जाता है. इसके लिए, व्यवहार में कुछ बदलाव किए जाते हैं, ताकि साफ़ तौर पर और सटीक नतीजे दिखाए जा सकें. किसी जगह पर लिखने की अनुमति देने वाला .write नियम, उस जगह के किसी भी डिसेंडेंट को भी लिखने की अनुमति देगा, भले ही डिसेंडेंट के अपने .write नियम लागू न हों.

.write नियम के पास Firebase रीयल टाइम डेटाबेस के नियम वैरिएबल का ऐक्सेस होता है.

.पुष्टि करें

.write नियम का ऐक्सेस मिलने के बाद इस्तेमाल किया जाता है, ताकि यह पक्का किया जा सके कि लिखा जा रहा डेटा किसी खास स्कीमा के मुताबिक है.

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

".validate": "newData.hasChildren(['name', 'age'])"

.validate नियम की वैल्यू एक स्ट्रिंग होती है. इसका आकलन, JavaScript के एक्सप्रेशन सिंटैक्स के सबसेट के तौर पर किया जाता है. इसके लिए, व्यवहार में कुछ बदलाव किए जाते हैं, ताकि साफ़ तौर पर और सटीक नतीजे दिखाए जा सकें.

.validate नियम के पास Firebase रीयल टाइम डेटाबेस के नियम वैरिएबल का ऐक्सेस होता है.

.indexOn

Firebase रीयल टाइम डेटाबेस को यह बताकर क्वेरी की परफ़ॉर्मेंस को बेहतर बनाता है कि आपको किन कुंजियों को इंडेक्स कराना है.

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

{
  "rules": {
    "dinosaurs": {
      ".indexOn": ["height", "length"]
    }
  }
}

ध्यान दें: नोड की कुंजी और प्राथमिकता को अपने-आप इंडेक्स किया जाता है. इसलिए, उन्हें अलग से इंडेक्स करने की ज़रूरत नहीं होती.

.indexOn नियम के बारे में ज़्यादा जानकारी पाने के लिए, अपना डेटा इंडेक्स करने से जुड़ी सुरक्षा गाइड का सेक्शन देखें.

नियम: वैरिएबल

प्रमाणीकरण

अगर क्लाइंट की पुष्टि हो चुकी है, तो टोकन पेलोड वाला वैरिएबल या null अगर क्लाइंट की पुष्टि नहीं हुई है.

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

फ़ील्ड	ब्यौरा
provider	पुष्टि करने के लिए इस्तेमाल किया गया तरीका, जैसे कि "password", "बिना पहचान वाला", "facebook", "github", "google" या "twitter"
uid	एक यूनीक यूज़र आईडी, जिसकी गारंटी दी जाती है कि वह सभी कंपनियों के लिए यूनीक होगा.
token	Firebase पुष्टि आईडी टोकन का कॉन्टेंट. auth.token देखें.

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

{
  "rules": {
    ".read": true,
    "$comment": {
      ".write": "!data.exists() && newData.child('user_id').val() == auth.uid"
    }
  }
}

हम उपयोगकर्ताओं को तब तक टिप्पणियां करने की अनुमति देने के लिए नीचे दिया गया नियम बना सकते हैं, जब तक कि उन्होंने Facebook का उपयोग करके प्रवेश किया हुआ है:

{
  "rules": {
    ".read": true,
    "$comment": {
      ".write": "!data.exists() && auth.provider == 'facebook'"
    }
  }
}

auth.token

Firebase पुष्टि आईडी टोकन के कॉन्टेंट वाला वैरिएबल.

टोकन में इनमें से कुछ या सभी कुंजियां शामिल होती हैं:

फ़ील्ड	ब्यौरा
email	अगर खाते से जुड़ा ईमेल पता मौजूद है, तो उसे डालें.
email_verified	true अगर उपयोगकर्ता ने पुष्टि कर दी है कि उसके पास email पते का ऐक्सेस है. कुछ कंपनियां अपने मालिकाना हक वाले ईमेल पतों की पुष्टि अपने-आप करती हैं.
phone_number	खाते से जुड़ा फ़ोन नंबर, अगर मौजूद हो.
name	अगर सेट हो, तो उपयोगकर्ता का डिसप्ले नेम.
sub	उपयोगकर्ता का Firebase यूआईडी. यह किसी प्रोजेक्ट के लिए यूनीक होता है.
firebase.identities	इस उपयोगकर्ता के खाते से जुड़ी सभी पहचानों की डिक्शनरी. शब्दकोश की कुंजियां इनमें से कोई भी हो सकती हैं: email, phone, google.com, facebook.com, github.com, twitter.com. डिक्शनरी की वैल्यू, खाते से जुड़े हर आइडेंटिटी प्रोवाइडर के यूनीक आइडेंटिफ़ायर की कैटगरी होती हैं. उदाहरण के लिए, auth.token.firebase.identities["google.com"][0] में खाते से जुड़ा पहला Google यूज़र आईडी शामिल होता है.
firebase.sign_in_provider	इस टोकन को पाने के लिए, साइन इन करने की सेवा देने वाली कंपनी का इस्तेमाल किया गया. यह इनमें से कोई एक स्ट्रिंग हो सकती है: custom, password, phone, anonymous, google.com, facebook.com, github.com, twitter.com.
firebase.tenant	अगर खाते से जुड़ा किराये पर इस्तेमाल करने वाला व्यक्ति मौजूद है, तो उसका आईडी. उदाहरण के लिए, tenant2-m6tyz अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

अगर कस्टम ऑथेंटिकेशन का इस्तेमाल किया जा रहा है, तो auth.token में कस्टम ऑथेंटिकेशन भी होता है डेवलपर के तय किए गए दावों के हिसाब से.

इन सभी वैल्यू का इस्तेमाल, नियमों में किया जा सकता है. उदाहरण के लिए, gmail.com वाले किसी पते से जुड़े Google खातों के ऐक्सेस पर पाबंदी लगाने के लिए, हम यह नियम जोड़ सकते हैं:

{
  "rules": {
    ".read": "auth != null",
    "gmailUsers": {
      "$uid": {
        ".write": "auth.token.email_verified == true && auth.token.email.matches(/.*@gmail.com$/)"
      }
    }
  }
}

पूरी जानकारी के लिए, auth.token में ये फ़ील्ड भी शामिल किए गए हैं. हालांकि, नियमों के लिए शायद ये फ़ील्ड काम के न हों.

फ़ील्ड	ब्यौरा
iss	टोकन जारी करने वाला.
aud	टोकन के लिए ऑडियंस.
auth_time	वह तारीख जब उपयोगकर्ता ने टोकन पाने वाले डिवाइस का इस्तेमाल करके, क्रेडेंशियल की मदद से पुष्टि की.
iat	टोकन जारी करने का समय.
exp	टोकन की समयसीमा खत्म होने का समय.

$location

एक ऐसा वैरिएबल जिसका इस्तेमाल $location की कुंजी के रेफ़रंस के लिए किया जा सकता है. इसका इस्तेमाल नियम वाले स्ट्रक्चर में पहले किया गया था.

जब आपके नियमों की संरचना में $location होता है, तब अपने नियम के एक्सप्रेशन में, मेल खाने वाले $ वैरिएबल का इस्तेमाल करके, पढ़े या लिखे जा रहे असल बच्चे का नाम लिया जा सकता है. इसलिए, मान लीजिए कि हम हर उपयोगकर्ता को उनकी जगह की /users/<user> जगह की जानकारी पढ़ने और उसमें बदलाव करने का ऐक्सेस देना चाहते हैं. हम इनका इस्तेमाल कर सकते हैं:

{
  "rules": {
    "users": {
      "$user": {
        ".read": "auth.uid === $user",
        ".write": "auth.uid === $user"
      }
    }
  }
}

जब कोई क्लाइंट /users/barney को ऐक्सेस करने की कोशिश करता है, तो $user की डिफ़ॉल्ट जगह की जानकारी का मिलान $user, "barney" के बराबर होगा. इसलिए, .read नियम जांच करेगा कि auth.uid === 'barney'. इस वजह से, /users/barney को सिर्फ़ तभी पढ़ा जा सकेगा, जब क्लाइंट की पुष्टि "barney" आईडी से की गई हो.

ध्यान दें: $ वैरिएबल में हमेशा एक तरह की स्ट्रिंग होती है.

अभी

इसमें Firebase रीयल टाइम डेटाबेस सर्वर के हिसाब से, Unix Epoch के बाद से मिलीसेकंड की संख्या शामिल होती है.

Firebase रीयल टाइम डेटाबेस सर्वर के हिसाब से, now वैरिएबल में मिलीसेकंड की संख्या शामिल होती है. यह संख्या, UNIX Epoch के हिसाब से होती है. उदाहरण के लिए, इसका इस्तेमाल यह पुष्टि करने के लिए किया जा सकता है कि उपयोगकर्ता के created का समय, आने वाले समय के लिए कभी सेट नहीं किया गया है:

{
  "rules": {
    "users": {
      "$user": {
        "created": {
          ".validate": "newData.val() < now"
        }
      }
    }
  }
}

रूट

आपके Firebase रीयल टाइम डेटाबेस के रूट में मौजूदा डेटा से जुड़ा RuleDataSnapshot.

रूट वैरिएबल आपको आपके Firebase रीयल टाइम डेटाबेस के रूट में मौजूदा डेटा के हिसाब से RuleDataSnapshot देता है. आप अपने नियम एक्सप्रेशन में अपने डेटाबेस के किसी भी डेटा को पढ़ने के लिए इसका इस्तेमाल कर सकते हैं. उदाहरण के लिए, अगर हम उपयोगकर्ताओं को /comments को पढ़ने की अनुमति देना चाहते, तो सिर्फ़ उनके /users/<id>/active का इस्तेमाल करने पर, हम इसका इस्तेमाल कर सकते हैं:

{
  "rules": {
    "comments": {
      ".read": "root.child('users').child(auth.uid).child('active').val() == true"
    }
  }
}

इसके बाद, अगर /users/barney/active में वैल्यू 'सही' है, तो उपयोगकर्ता की पुष्टि "barney" कोड की मदद से की गई हो /comments नोड में डेटा भेज सकता है.

डेटा

मौजूदा समय में लागू किए जा रहे नियम की जगह पर Firebase रीयल टाइम डेटाबेस के मौजूदा डेटा से जुड़ा RuleDataSnapshot.

डेटा वैरिएबल आपको मौजूदा समय में लागू किए जा रहे नियम के डेटाबेस की जगह में मौजूदा डेटा के हिसाब से एक RuleDataSnapshot देता है (रूट के उलट, जो आपको आपके डेटाबेस के रूट के लिए डेटा देता है).

उदाहरण के लिए, अगर /users/<user>/public को 'सही है' पर सेट किया गया था और आपको किसी क्लाइंट को /users/<user> का ऐक्सेस देना है, तो इसका इस्तेमाल करें:

{
  "rules": {
    "users": {
      "$user": {
        ".read": "data.child('public').val() == true"
      }
    }
  }
}

डेटा वैरिएबल .read, .write, और .validate नियम.

नया डेटा

डेटा से जुड़ा RuleDataSnapshot. इससे डेटा तब मिलता है, जब डेटा में बदलाव करने की अनुमति होती है.

.write और .validate के नियमों के लिए, newData वैरिएबल आपको डेटा के हिसाब से एक RuleDataSnapshot देता है. इससे लिखने की अनुमति मिलने पर नतीजा मिलता है (यह मौजूदा डेटा और नए डेटा को "मर्ज" करने की प्रक्रिया है). इसलिए, अगर आपको यह पक्का करना है कि हर उपयोगकर्ता का एक नाम और उम्र हो, तो इसका इस्तेमाल करें:

{
  "rules": {
    "users": {
      "$user": {
        ".read": true,
        ".write": true,
        ".validate": "newData.hasChildren(['name', 'age'])"
      }
    }
  }
}

नया डेटा मौजूदा डेटा और नए डेटा को मर्ज करता है. इसलिए, यह "आंशिक" के लिए भी सही तरीके से काम करता है अपडेट. उदाहरण के लिए:

var fredRef = firebase.database().ref("users/fred");
// Valid since we have a name and age.
fredRef.set({ name: "Fred", age: 19 });
// Valid since we are updating the name but there's already an age.
fredRef.child("age").set(27);
// Invalid since the .validate rule will no longer be true.
fredRef.child("name").remove();

कोई नया डेटा नहीं लिखा जा रहा है, इसलिए .read नियमों में newData वैरिएबल उपलब्ध नहीं है. आपको सिर्फ़ डेटा का इस्तेमाल करना चाहिए.

RuleDataSnapshot: तरीके

वैल्यू()

इस RuleDataSnapshot से प्रिमिटिव वैल्यू (string, number, boolean या null) देता है.

आइटम लौटाने की वैल्यू: (String, Number, Boolean, Null) - इस RuleDataSnapshot की शुरुआती वैल्यू.

DataSnapshot.val() के उलट, चाइल्ड डेटा वाले RuleDataSnapshot पर val() को कॉल करने से, बच्चों वाला कोई ऑब्जेक्ट नहीं दिखेगा. इसके बजाय, यह एक खास सेंटिनल वैल्यू दिखाएगा. इससे यह पक्का होता है कि नियम हमेशा बेहतर तरीके से काम कर सकते हैं.

इस वजह से, आपको बच्चों को ऐक्सेस करने के लिए हमेशा child() का इस्तेमाल करना होगा (उदाहरण के लिए, data.child('name').val(), data.val().name का नहीं).

यह उदाहरण सिर्फ़ तब पढ़ने की अनुमति देता है, जब isReadable चाइल्ड को पढ़ी जा रही जगह पर 'सही है' पर सेट किया गया हो.

".read": "data.child('isReadable').val() == true"

चाइल्ड()

तय किए गए मिलते-जुलते पाथ पर जगह के लिए RuleDataSnapshot देता है.

आर्ग्युमेंट: childPath String - चाइल्ड डेटा की लोकेशन से जुड़ा पाथ.

आइटम लौटाने की वैल्यू: RuleDataSnapshot - चाइल्ड की जगह के लिए RuleDataSnapshot.

रिलेटिव पाथ या तो कोई आसान चाइल्ड नाम (उदाहरण के लिए, 'फ़्रेड') हो सकता है या स्लैश से अलग किया गया पाथ (उदाहरण के लिए, 'fred/name/first'). अगर चाइल्ड लोकेशन में कोई डेटा नहीं है, तो एक खाली RuleDataSnapshot दिया जाता है.

यह उदाहरण सिर्फ़ तब पढ़ने की अनुमति देता है, जब isReadable चाइल्ड को पढ़ी जा रही जगह पर 'सही है' पर सेट किया गया हो.

".read": "data.child('isReadable').val() == true"

पैरंट()

पैरंट जगह के लिए RuleDataSnapshot देता है.

रिटर्न वैल्यू: RuleDataSnapshot - पैरंट लोकेशन के लिए RuleDataSnapshot.

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

यह उदाहरण सिर्फ़ तब पढ़ने की अनुमति देता है, जब isReadable सिबलिंग 'सही' पर सेट हो.

".read": "data.parent().child('isReadable').val() == true"

हैचाइल्ड(चाइल्डपाथ)

तय किया गया चाइल्ड मौजूद होने पर 'सही' दिखाता है.

आर्ग्युमेंट: childPath String - किसी संभावित बच्चे की जगह का मिलता-जुलता पाथ.

रिटर्न वैल्यू: बूलियन - true, अगर डेटा तय किए गए चाइल्ड पाथ पर मौजूद है; अन्य false.

इस उदाहरण में डेटा को सिर्फ़ तब लिखा जा सकता है, जब इसमें "नाम" चाइल्ड शामिल हो.

".validate": "newData.hasChild('name')"

बच्चों के लिए([बच्चे])

यह बच्चों की मौजूदगी की जांच करता है.

आर्ग्युमेंट: children Array ज़रूरी नहीं - चाइल्ड कुंजियों का कलेक्शन, जो सभी मौजूद होना चाहिए.

प्रॉडक्ट लौटाने की वैल्यू: Boolean - true, अगर (बताए गए) बच्चे मौजूद हैं; और false.

अगर कोई आर्ग्युमेंट नहीं दिया जाता है, तो RuleDataSnapshot का कोई चाइल्ड मिलने पर, 'सही' दिखेगा. अगर चाइल्ड नामों की एक कलेक्शन दी जाती है, तो यह सिर्फ़ तभी 'सही' दिखेगी, जब RuleDataSnapshot में दिए गए सभी बच्चे मौजूद हों.

इस उदाहरण में डेटा को सिर्फ़ तब लिखा जा सकता है, जब इसमें एक या एक से ज़्यादा बच्चे हों.

".validate": "newData.hasChildren()"

इस उदाहरण में "नाम" शामिल होने पर ही डेटा लिखा जा सकता है और "उम्र" है बच्चे.

".validate": "newData.hasChildren(['name', 'age'])"

मौजूद()

अगर इस RuleDataSnapshot पर कोई डेटा होता है, तो 'सही' दिखाता है.

सामान लौटाने की वैल्यू: Boolean - true, अगर RuleDataSnapshot पर कोई डेटा मौजूद हो; अन्य false.

अगर इस RuleDataSnapshot पर कोई डेटा होता है, तो मौजूदा फ़ंक्शन 'सही' दिखाता है. यह पूरी तरह से सुविधा फ़ंक्शन है, क्योंकि data.exists(), data.val() != null के बराबर है.

जब तक कोई मौजूदा डेटा नहीं है, तब तक यह उदाहरण इस जगह पर लिखने की अनुमति देता है.

".write": "!data.exists()"

getप्राथमिकता()

RuleDataSnapshot में डेटा की प्राथमिकता हासिल करता है.

सामान लौटाने की वैल्यू: (String, Number, Null) - इस RuleDataSnapshot में डेटा की प्राथमिकता.

इस उदाहरण से पक्का होता है कि लिखे जा रहे नए डेटा को प्राथमिकता दी जाए

".validate": "newData.getPriority() != null"

isNumber()

अगर इस RuleDataSnapshot में कोई संख्या वाली वैल्यू होती है, तो 'सही' दिखाता है.

रिटर्न वैल्यू: अगर डेटा संख्या वाला है, तो Boolean - true; और false.

इस उदाहरण से पक्का होता है कि लिखे जा रहे नए डेटा में चाइल्ड "उम्र" है डालें.

".validate": "newData.child('age').isNumber()"

isString()

अगर इस RuleDataSnapshot में कोई स्ट्रिंग वैल्यू होती है, तो 'सही' दिखाता है.

रिटर्न वैल्यू: अगर डेटा String है, तो Boolean - true; अन्य false.

इस उदाहरण से पक्का होता है कि लिखे जा रहे नए डेटा में चाइल्ड "नाम" है सेट करें.

".validate": "newData.child('name').isString()

isबूलियन()

अगर इस RuleDataSnapshot में बूलियन वैल्यू होती है, तो 'सही' दिखाता है.

रिटर्न वैल्यू: अगर डेटा, Boolean है, तो Boolean - true; और false.

इस उदाहरण से यह पक्का होता है कि लिखे जा रहे नए डेटा में चाइल्ड "ऐक्टिव" है शामिल होनी चाहिए.

".validate": "newData.child('active').isBoolean()"

स्ट्रिंग: प्रॉपर्टी

लंबाई

स्ट्रिंग की लंबाई देता है.

रिटर्न वैल्यू: Number - स्ट्रिंग में वर्णों की संख्या.

इस उदाहरण के लिए, स्ट्रिंग में कम से कम 10 वर्ण होने चाहिए.

".validate": "newData.isString() && newData.val().length >= 10"

स्ट्रिंग: तरीके

इसमें शामिल है(सबस्ट्रिंग)

स्ट्रिंग में बताई गई सबस्ट्रिंग होने पर 'सही' दिखाता है.

आर्ग्युमेंट: substring String - देखने के लिए एक सबस्ट्रिंग.

रिटर्न वैल्यू: Boolean - true, अगर स्ट्रिंग में बताई गई सबस्ट्रिंग है; और false.

इस उदाहरण के लिए डेटा स्ट्रिंग में "@" होना चाहिए.

".validate": "newData.isString() && newData.val().contains('@')"

beforeWith(सबस्ट्रिंग)

स्ट्रिंग तय की गई सबस्ट्रिंग से शुरू होने पर 'सही' दिखाता है.

आर्ग्युमेंट: substring String - शुरुआत में देखने के लिए एक सबस्ट्रिंग.

रिटर्न वैल्यू: Boolean - true, अगर स्ट्रिंग में बताई गई सबस्ट्रिंग है; और false.

अगर auth.token.identifier "internal-" से शुरू होता है, तो यह उदाहरण पढ़ने का ऐक्सेस देता है

".read": "auth.token.identifier.beginsWith('internal-')"

EndWith(सबस्ट्रिंग)

स्ट्रिंग तय की गई सबस्ट्रिंग पर खत्म होने पर 'सही' दिखाता है.

आर्ग्युमेंट: substring String - आखिर में देखने के लिए एक सबस्ट्रिंग.

रिटर्न वैल्यू: Boolean - true, अगर स्ट्रिंग तय की गई सबस्ट्रिंग पर खत्म होती है; और false.

अगर auth.token.identifier, "@company.com" पर खत्म होता है, तो यह उदाहरण पढ़ने का ऐक्सेस देता है

".read": "auth.token.identifier.endsWith('@company.com')"

बदलें(सबस्ट्रिंग, रिप्लेसमेंट)

तय की गई रीप्लेसमेंट स्ट्रिंग से बदली गई किसी सबस्ट्रिंग के सभी इंस्टेंस वाली स्ट्रिंग की कॉपी दिखाता है.

आर्ग्युमेंट: substring String - देखने के लिए एक सबस्ट्रिंग. replacement String- सबस्ट्रिंग को बदलने वाली स्ट्रिंग.

रिटर्न वैल्यू: String - सबस्ट्रिंग को बदलने के बाद दिखने वाली नई स्ट्रिंग.

replace() तरीका, JavaScript replace() तरीके से कुछ इस तरह अलग है कि यह किसी खास सबस्ट्रिंग के सभी इंस्टेंस को, तय की गई रीप्लेसमेंट स्ट्रिंग से बदलता है, न कि सिर्फ़ पहले इंस्टेंस से.

कुंजियों में पूर्णविरामों की अनुमति नहीं है, इसलिए हमें उन्हें संग्रहित करने से पहले पूर्णविराम वाली स्ट्रिंग को एस्केप करना होगा. ईमेल पतों के साथ इसका एक उदाहरण होगा. मान लें कि हमारे /whitelist/ नोड में अनुमति वाले ईमेल पतों की सूची है:

{
 "user": {
   "$uid": {
     "email": <email>
   }
 },
 "whitelist": {
   "fred@gmail%2Ecom": true,
   "barney@aol%2Ecom": true
 }
}

हम एक ऐसा नियम बना सकते हैं जो उपयोगकर्ताओं को सिर्फ़ तब जोड़ने की अनुमति देता है, जब उनका ईमेल पता /whitelist/ नोड में हो:

{
  "rules": {
    "users": {
      "$uid": {
        ".read": "true",
        ".write": "root.child('whitelist').child(newData.child('email').val().replace('.', '%2E')).exists()"
      }
    }
  }
}

tolowerCase()

लोअर केस में बदली गई स्ट्रिंग की कॉपी दिखाता है.

रिटर्न वैल्यू: String - स्ट्रिंग को लोअर केस में बदला गया.

यह उदाहरण सिर्फ़ तब पढ़ने का ऐक्सेस देता है, जब auth.token.identifier के सभी लोअर केस /users से जुड़े हों.

".read": "root.child('users').child(auth.token.identifier.toLowerCase()).exists()"

toUpperCase()

अपर केस में बदली गई स्ट्रिंग की कॉपी दिखाता है.

रिटर्न वैल्यू: String - स्ट्रिंग को अपर केस में बदला गया.

अगर auth.token.identifier, सभी बड़े अक्षर /users में मौजूद हैं, तो यह उदाहरण पढ़ने का ऐक्सेस देता है.

".read": "root.child('users').child(auth.token.identifier.toUpperCase()).exists()"

मैच करता है(रेगुलर एक्सप्रेशन)

स्ट्रिंग किसी खास रेगुलर एक्सप्रेशन की लिटरल वैल्यू से मेल खाती है, तो 'सही' दिखाता है.

रिटर्न वैल्यू: Boolean - true अगर स्ट्रिंग, रेगुलर एक्सप्रेशन की लिटरल वैल्यू से मेल खाती है, तो regex; और false.

रेगुलर एक्सप्रेशन के नियमों से जुड़ा पूरा दस्तावेज़ देखें.

ऑपरेटर

+ (जोड़ें)

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

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

".write": "newData.val() === data.val() + 1"

ध्यान दें: पाथ कुंजियां हमेशा स्ट्रिंग स्ट्रिंग होती हैं. कुंजियां हमेशा स्ट्रिंग होती हैं, इसलिए $ वैरिएबल की तुलना किसी संख्या से करने की कोशिश हमेशा फ़ेल हो जाती है. + ऑपरेटर का इस्तेमाल करके, संख्या को स्ट्रिंग में बदलकर इसे ठीक किया जा सकता है. नीचे दिया गया पुष्टि करने वाला नियम, $room_id वैरिएबल को किसी स्ट्रिंग में बदलकर यह जांच करता है कि रूम पाथ मौजूद है या नहीं.

".validate": "root.child('room_names/' + $room_id).exists()"

- (निगेट या घटाएं)

इसका इस्तेमाल, किसी नियम के एक्सप्रेशन में मौजूद वैल्यू को हटाने या दो वैल्यू को घटाने के लिए किया जाता है.

पुष्टि करने का यह नियम, इस बात की जांच करता है कि नई वैल्यू, जगह की चाइल्ड वैल्यू से बिलकुल उलट है या नहीं:

".validate": "newData.val() === -(data.child('quantity').val())"

इस उदाहरण में, घटाव का इस्तेमाल किया गया है, ताकि यह पक्का किया जा सके कि सिर्फ़ पिछले 10 मिनट के मैसेज पढ़े जा सकें:

".read": "newData.child('timestamp').val() > (now - 600000)"

* (गुणा करें)

इसका इस्तेमाल, किसी नियम के एक्सप्रेशन में वैरिएबल का गुणा करने के लिए किया जाता है.

पुष्टि करने वाला यह नियम, यह जांच करता है कि नई वैल्यू, कीमत और संख्या (दो मौजूदा वैल्यू) के प्रोडक्शन के बराबर है या नहीं:

".validate": "newData.val() === data.child('price').val() * data.child('quantity').val()"

/ (भाग करें)

इसका इस्तेमाल, नियम के एक्सप्रेशन में वैरिएबल को भाग देने के लिए किया जाता है.

यहां दिए गए उदाहरण में, पुष्टि करने वाला नियम यह पक्का करता है कि सेव किया गया डेटा, कहीं और सेव किए गए कुल डेटा का औसत हो:

".validate": "newData.val() === data.parent().child('sum').val() / data.parent().child('numItems').val()"

% (मॉड्यूल)

इसका इस्तेमाल, किसी नियम के एक्सप्रेशन में, एक वैरिएबल को दूसरे वैरिएबल से भाग देने के बचे हुए हिस्से का पता लगाने के लिए किया जाता है.

यह नियम इस बात की पुष्टि करता है कि सिर्फ़ संख्याओं को लिखा जा सकता है:

".validate": "newData.val() % 2 === 0"

=== (इसके बराबर है)

इसका इस्तेमाल यह जांचने के लिए किया जाता है कि किसी नियम के एक्सप्रेशन में दो वैरिएबल का टाइप और वैल्यू एक ही है या नहीं.

नीचे दिया गया नियम, उपयोगकर्ता खाते के मालिक को ही लिखने का ऐक्सेस देने के लिए === ऑपरेटर का इस्तेमाल करता है. नियम के 'सही' का आकलन करने के लिए, उपयोगकर्ता का यूआईडी, कुंजी ($user_id) से पूरी तरह मेल खाना चाहिए.

"users": {
  ".write": "$user_id === auth.uid"
}

ध्यान दें: == इस रूप में व्यवहार किया जाता है ===. अगर आपने सुरक्षा के नियमों में == का इस्तेमाल किया है, तो नियमों के लागू होने पर, उसका अनुवाद === हो जाएगा.

!== (इसके बराबर नहीं है)

इसका इस्तेमाल यह जांचने के लिए किया जाता है कि किसी नियम के एक्सप्रेशन में दो वैरिएबल बराबर नहीं हैं.

पढ़ने के इस नियम से यह पक्का होता है कि लॉग इन करने वाले उपयोगकर्ता ही डेटा पढ़ सकें:

".read": "auth !== null"

ध्यान दें: != इस रूप में व्यवहार किया जाता है !==. अगर आपने सुरक्षा के नियमों में != का इस्तेमाल किया है, तो नियमों के लागू होने पर, उसका अनुवाद !== में कर दिया जाएगा.

&& (और)

दोनों ऑपरेंड के सही होने पर, 'सही' के तौर पर नतीजा दिखाता है. इसका इस्तेमाल, नियम एक्सप्रेशन में कई शर्तों का आकलन करने के लिए किया जाता है.

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

".validate": "newData.isString() && newData.val().length < 100"

(या)

नियम के एक्सप्रेशन में एक ऑपरेंड के सही होने पर, 'सही' के तौर पर नतीजा दिखाता है.

इस उदाहरण में, हम तब तक लिख सकते हैं, जब तक पुराना डेटा या नया डेटा मौजूद न हो. दूसरे शब्दों में, अगर हम डेटा मिटा रहे हैं या बना रहे हैं, लेकिन उसे अपडेट नहीं कर रहे हैं, तो हम ईमेल लिख सकते हैं.

".write": "!data.exists() || !newData.exists()"

! (नहीं)

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

यह नियम, डेटा में बदलाव करने का ऐक्सेस सिर्फ़ तब देता है, जब बताई गई जगह पर कोई डेटा मौजूद न हो:

".write": "!data.exists()"

> (इससे ज़्यादा)

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

पुष्टि करने वाला यह नियम, इस बात की जांच करता है कि लिखी जा रही स्ट्रिंग कोई खाली स्ट्रिंग नहीं है:

".validate": "newData.isString() && newData.val().length > 0"

< (इससे कम)

इसका इस्तेमाल यह जांचने के लिए किया जाता है कि किसी नियम के एक्सप्रेशन में मौजूद वैल्यू, किसी दूसरी वैल्यू से कम है या नहीं.

पुष्टि करने वाला यह नियम, इस बात की जांच करता है कि स्ट्रिंग में 20 से कम वर्ण हैं:

".validate": "newData.isString() && newData.val().length < 20"

>= (इससे ज़्यादा या इसके बराबर)

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

पुष्टि करने वाला यह नियम, इस बात की जांच करता है कि लिखी जा रही स्ट्रिंग कोई खाली स्ट्रिंग नहीं है:

".validate": "newData.isString() && newData.val().length >= 1"

<= (इससे कम या इसके बराबर)

इसका इस्तेमाल यह जांचने के लिए किया जाता है कि क्या कोई वैल्यू, नियम एक्सप्रेशन में मौजूद किसी दूसरी वैल्यू से कम या उसके बराबर है.

पुष्टि करने का यह नियम पक्का करता है कि आने वाले समय में नया डेटा न जोड़ा जा सके:

".validate": "newData.val() <= now"

का इस्तेमाल किया जा सकता है? (टर्नरी ऑपरेटर)

इसका इस्तेमाल, कंडिशनल नियम के एक्सप्रेशन का आकलन करने के लिए किया जाता है.

टर्नरी ऑपरेटर तीन ऑपरेंड लेता है. ? से पहले ऑपरेंड वह स्थिति है. अगर शर्त का आकलन सही लगता है, तो दूसरे ऑपरेंड का आकलन किया जाता है. अगर शर्त गलत है, तो तीसरे ऑपरेंड का आकलन किया जाता है.

नीचे दिए गए पुष्टि करने के नियम के लिए, नई वैल्यू कोई संख्या या बूलियन हो सकती है. अगर यह एक संख्या है, तो यह 0 से ज़्यादा होनी चाहिए.

".validate": "newData.isNumber() ? newData.val() > 0 : newData.isBoolean()"