नियमों से डेटा का सत्यापन

सबसे सामान्य सत्यापनों में से एक डेटा प्रकार की जाँच करना है। आप सुनिश्चित कर सकते हैं कि फ़ील्ड स्ट्रिंग, संख्याएँ, बूलियन या यहाँ तक कि null हों।

इससे उपयोगकर्ता द्वारा, उदाहरण के लिए, जहाँ नाम (स्ट्रिंग) अपेक्षित है वहाँ संख्या भेजने से बचाव होता है।

{
  "rules": {
    "users": {
      "$userId": {
        "name": { ".validate": "newData.isString()" },
        "age": { ".validate": "newData.isNumber()" },
        "isActive": { ".validate": "newData.isBoolean()" }
      }
    }
  }
}

कभी-कभी कुछ फ़ील्ड का होना बिल्कुल आवश्यक होता है। एक से अधिक फ़ील्ड मौजूद हैं या नहीं, यह सुनिश्चित करने के लिए आप newData.hasChildren(['field1', 'field2']) का उपयोग कर सकते हैं, या किसी चाइल्ड को सीधे एक्सेस करके उसकी मौजूदगी जाँच सकते हैं।

यदि कोई आवश्यक फ़ील्ड मौजूद नहीं है, तो लिखने की प्रक्रिया विफल हो जाएगी।

{
  "rules": {
    "messages": {
      "$messageId": {
        ".validate": "newData.hasChildren(['senderId', 'text'])"
      }
    }
  }
}

टेक्स्ट फ़ील्ड के लिए आप अक्सर न्यूनतम या अधिकतम लंबाई निर्धारित करना चाहते हैं। इससे बहुत छोटे या अत्यधिक लंबे इनपुट से बचाव होता है।

आप स्ट्रिंग मान पर .length प्रॉपर्टी का उपयोग कर सकते हैं।

{
  "rules": {
    "products": {
      "$productId": {
        "name": {
          ".validate": "newData.isString() && newData.val().length > 2 && newData.val().length < 50"
        }
      }
    }
  }
}

संख्यात्मक डेटा के लिए आपको यह सुनिश्चित करना पड़ सकता है कि मान किसी विशिष्ट सीमा में हों। उदाहरण के लिए, आयु धनात्मक होनी चाहिए या स्कोर 0 और 100 के बीच होना चाहिए।

आप मानक तुलना ऑपरेटरों (>, <, >=, <=) का उपयोग कर सकते हैं।

{
  "rules": {
    "scores": {
      "$scoreId": {
        "value": {
          ".validate": "newData.isNumber() && newData.val() >= 0 && newData.val() <= 100"
        }
      }
    }
  }
}

ईमेल या URL जैसे अधिक जटिल स्ट्रिंग प्रारूपों के लिए आप .matches() फ़ंक्शन के साथ रेगुलर एक्सप्रेशन का उपयोग कर सकते हैं।

रेगुलर एक्सप्रेशन टेक्स्ट से मिलान करने वाले शक्तिशाली पैटर्न होते हैं। शुरुआत में वे कठिन लग सकते हैं, लेकिन बहुत उपयोगी होते हैं!

{
  "rules": {
    "profiles": {
      "$profileId": {
        "email": {
          // Basic email regex pattern validation
          ".validate": "newData.isString() && newData.val().matches(/^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,4}$/i)"
        }
      }
    }
  }
}

आपको अक्सर कई सत्यापन जाँचों को संयोजित करने की आवश्यकता होगी। आप तार्किक ऑपरेटरों का उपयोग कर सकते हैं:

• && (AND): सभी शर्तें सही होनी चाहिए।
• || (OR): कम-से-कम एक शर्त सही होनी चाहिए।

इससे सत्यापन का तर्क बहुत लचीला और विश्वसनीय बनता है।

{
  "rules": {
    "tasks": {
      "$taskId": {
        ".validate": "newData.hasChildren(['title', 'status']) && newData.child('title').isString() && newData.child('title').val().length > 5"
      }
    }
  }
}

आइए, उपयोगकर्ता प्रोफ़ाइल के एक व्यापक उदाहरण के साथ सभी बातों को एक साथ समझते हैं:

• username: स्ट्रिंग होना चाहिए और कम-से-कम 3 अक्षर होने चाहिए।
• email: स्ट्रिंग होना चाहिए और ईमेल रेगुलर एक्सप्रेशन से मेल खाना चाहिए।
• age: संख्या होनी चाहिए और कम-से-कम 13 होनी चाहिए।

{
  "rules": {
    "userProfiles": {
      "$userId": {
        ".validate": "newData.hasChildren(['username', 'email', 'age']) && \
                      newData.child('username').isString() && \
                      newData.child('username').val().length >= 3 && \
                      newData.child('email').isString() && \
                      newData.child('email').val().matches(/^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,4}$/i) && \
                      newData.child('age').isNumber() && \
                      newData.child('age').val() >= 13"
      }
    }
  }
}

बहुत बढ़िया! आपने Firebase Realtime Database Security Rules का उपयोग करके डेटा का सत्यापन करना सीख लिया है:

• newData ऑब्जेक्ट लिखे जा रहे डेटा को दर्शाता है।
• .validate() Rule newData पर शर्तें लागू करता है।
• आप डेटा प्रकारों की जाँच कर सकते हैं (isString(), isNumber())।
• hasChildren() से सुनिश्चित करें कि आवश्यक फ़ील्ड मौजूद हैं।
• स्ट्रिंग की लंबाई (.length) और संख्याओं की सीमाओं (>, <) का सत्यापन करें।
• रेगुलर एक्सप्रेशन के साथ जटिल पैटर्न का सत्यापन करने के लिए .matches() का उपयोग करें।
• शक्तिशाली तर्क के लिए Rules को && और || से संयोजित करें।

डेटा का सत्यापन करके आप सुनिश्चित करते हैं कि आपका डेटाबेस स्वच्छ और सुरक्षित बना रहे!