Firebase Database Security Rules API

כלל: סוגים

.לקרוא

מעניק ללקוח גישת קריאה למיקום של Firebase Realtime Database.

כלל .read הוא סוג של כלל אבטחה המעניק ללקוח גישת קריאה למיקום של Firebase Realtime Database. לדוגמה:

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

הערך של כלל .read הוא מחרוזת, המוערכת כתת-קבוצה של תחביר הביטוי של JavaScript עם כמה שינויים התנהגותיים כדי להגביר את הבהירות והנכונות. כלל .read המעניק הרשאה לקרוא מיקום יאפשר גם קריאה של כל צאצא של אותו מיקום, גם אם לצאצאים יש חוקי .read משלהם שנכשלים.

לכלל .read יש גישה לכל משתני הכללים של Firebase Realtime Database מלבד newData .

.לִכתוֹב

מעניק ללקוח גישת כתיבה למיקום של Firebase Realtime Database.

כלל .write הוא סוג של כלל אבטחה המעניק ללקוח גישת כתיבה למיקום של מסד נתונים של Firebase בזמן אמת. לדוגמה:

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

הערך של כלל .write הוא מחרוזת, המוערכת כתת-קבוצה של תחביר הביטוי של JavaScript עם כמה שינויים התנהגותיים כדי להגביר את הבהירות והנכונות. כלל .write המעניק הרשאה לכתוב למיקום יאפשר גם כתיבה לכל צאצא של אותו מיקום, גם אם לצאצאים יש חוקי .write משלהם.

לכלל .write יש גישה לכל משתני החוקים של Firebase Realtime Database.

.לְאַמֵת

משמש לאחר שכלל .write העניק גישה, כדי להבטיח שהנתונים הנכתבים תואמים לסכימה ספציפית.

כלל .validate משמש לאחר שכלל .write העניק גישה, כדי להבטיח שהנתונים הנכתבים תואמים לתקן ספציפי. בנוסף ל- .write המעניק גישה, כל כללי .validate הרלוונטיים חייבים להצליח לפני שתתאפשר כתיבה. לדוגמה:

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

הערך של כלל .validate הוא מחרוזת, המוערכת כתת-קבוצה של תחביר הביטוי של JavaScript עם כמה שינויים התנהגותיים כדי להגביר את הבהירות והנכונות.

לכלל .validate יש גישה לכל משתני החוקים של Firebase Realtime Database.

.indexOn

משפר את ביצועי השאילתות על ידי הסבר ל-Firebase Realtime Database אילו מפתחות אתה רוצה שהנתונים שלך יתווספו לאינדקס.

כלל .indexOn אומר לשרתי Firebase Realtime Database להוסיף מפתחות ספציפיים בנתונים שלך כדי לשפר את הביצועים של השאילתות שלך. לדוגמה, בהינתן מסד נתונים עם אוסף של נתוני דינוזאורים, אנו יכולים לומר ל-Firebase Realtime Database לבצע אופטימיזציה עבור שאילתות, לפני שהן מוחזרות מהשרתים, על ידי הוספת כלל זה:

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

תוכל לברר מידע נוסף על כלל .indexOn על ידי עיון בסעיף של מדריך האבטחה על הוספת הנתונים שלך לאינדקס .

כלל: משתנים

אישור

משתנה המכיל את מטען האסימון אם לקוח מאומת, או null אם הלקוח אינו מאומת.

Firebase Realtime Database מאפשר לך לבצע אימות בקלות מול מספר ספקים מובנים וייצור עבורם אסימוני אימות. לאחר שמשתמש מאומת עם אחד מהספקים המובנים, משתנה האימות יכיל את הדברים הבאים:

שדה תיאור
provider שיטת האימות שבה נעשה שימוש (למשל "סיסמה", "אנונימי", "פייסבוק", "github", "גוגל" או "טוויטר").
uid מזהה משתמש ייחודי, מובטח להיות ייחודי בכל הספקים.
token התוכן של אסימון Firebase Auth ID. ראה 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 Auth ID.

האסימון מכיל חלק מהמפתחות הבאים או את כולם:

שדה תיאור
email כתובת האימייל המשויכת לחשבון, אם קיימת.
email_verified true אם המשתמש אימת שיש לו גישה לכתובת email . חלק מהספקים מאמתים באופן אוטומטי כתובות דוא"ל בבעלותם.
phone_number מספר הטלפון המשויך לחשבון, אם קיים.
name שם התצוגה של המשתמש, אם מוגדר.
sub ה-UID של 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 ה-tenantId המשויך לחשבון, אם קיים. למשל tenant2-m6tyz

אם משתמשים באימות מותאם אישית, auth.token מכיל גם תביעות מותאמות אישית שצוינו על ידי המפתח.

ניתן להשתמש בכל הערכים הללו במסגרת כללים. לדוגמה, כדי להגביל את הגישה לחשבונות Google המשויכים לכתובת gmail.com, נוכל להוסיף את הכלל:

{
  "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 תצליח רק אם הלקוח מאומת באמצעות uid של "barney".

עַכשָׁיו

מכיל את מספר האלפיות השניות מאז עידן יוניקס לפי שרתי Firebase Realtime Database.

המשתנה now מכיל את מספר האלפיות מאז עידן UNIX לפי שרתי Firebase Realtime Database. לדוגמה, תוכל להשתמש בזה כדי לאמת שזמן created של משתמש לעולם אינו מוגדר לשעה בעתיד:

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

שורש

RuleDataSnapshot התואמת לנתונים הנוכחיים בבסיס מסד הנתונים שלך בזמן אמת של Firebase.

משתנה השורש נותן לך RuleDataSnapshot התואם לנתונים הנוכחיים בבסיס מסד הנתונים שלך בזמן אמת של Firebase. אתה יכול להשתמש בזה כדי לקרוא כל נתונים במסד הנתונים שלך בביטויי הכלל שלך. לדוגמה, אם נרצה לאפשר למשתמשים לקרוא /comments רק אם /users/<id>/active שלהם הוגדר כ-true, נוכל להשתמש ב:

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

לאחר מכן, אם /users/barney/active הכיל את הערך true, משתמש שאומת עם ה-uid של "barney" יוכל לכתוב לצומת /comments .

נתונים

RuleDataSnapshot התואם לנתונים הנוכחיים במסד הנתונים של Firebase Realtime במיקום של הכלל המבצע כעת.

משתנה הנתונים נותן לך RuleDataSnapshot התואם לנתונים הנוכחיים במיקום מסד הנתונים של הכלל הפועל כעת (בניגוד ל-root, שנותן לך את הנתונים עבור השורש של מסד הנתונים שלך).

כך למשל, אם רצית לאפשר לכל לקוח לגשת ל- /users/<user> אם /users/<user>/public הוגדר כ-true, תוכל להשתמש ב:

{
  "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'])"
      }
    }
  }
}

מכיוון ש-newData ממזג נתונים קיימים ונתונים חדשים, הוא מתנהג כראוי גם עבור עדכונים "חלקיים". לדוגמה:

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();

המשתנה newData אינו זמין בכללי .read מכיוון שאין נתונים חדשים שנכתבים. אתה צריך פשוט להשתמש בנתונים .

RuleDataSnapshot: שיטות

val()

מקבל את הערך הפרימיטיבי ( string , number , boolean או null ) מ- RuleDataSnapshot זה.

ערך החזרה : ( String , Number , Boolean , Null ) - הערך הפרימיטיבי מ- RuleDataSnapshot זה.

בניגוד DataSnapshot.val() , קריאה ל- val() ב- RuleDataSnapshot שיש לו נתוני צאצא לא תחזיר אובייקט המכיל את הילדים. במקום זאת הוא יחזיר ערך זקיף מיוחד. זה מבטיח שהכללים תמיד יכולים לפעול ביעילות רבה.

כתוצאה מכך, עליך להשתמש תמיד child() כדי לגשת לילדים (למשל data.child('name').val() , לא data.val().name ).

דוגמה זו מאפשרת קריאה רק אם הילד isReadable מוגדר כ-true במיקום הנקרא.

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

יֶלֶד()

מקבל RuleDataSnapshot עבור המיקום בנתיב היחסי שצוין.

ארגומנטים : String childPath - נתיב יחסי למיקום של נתוני צאצא.

ערך החזרה : RuleDataSnapshot - RuleDataSnapshot עבור מיקום הילד.

הנתיב היחסי יכול להיות שם צאצא פשוט (לדוגמה 'fred') או נתיב עמוק יותר מופרד באלכסון (למשל 'fred/name/first'). אם למיקום הילד אין נתונים, מוחזרת RuleDataSnapshot ריקה.

דוגמה זו מאפשרת קריאה רק אם הילד isReadable מוגדר כ-true במיקום הנקרא.

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

הוֹרֶה()

מקבל RuleDataSnapshot עבור מיקום האב.

ערך החזרה : RuleDataSnapshot - RuleDataSnapshot עבור מיקום האב.

אם מופע זה מתייחס לשורש של מסד הנתונים של Firebase Realtime, אין לו אב, ו- parent() ייכשל, מה שיגרום לדילוג על ביטוי הכלל הנוכחי (ככשל).

דוגמה זו מאפשרת קריאה רק אם האח isReadable מוגדר כ-true.

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

hasChild(childPath)

מחזירה true אם הצאצא שצוין קיים.

טיעונים : childPath String - נתיב יחסי למיקום של ילד פוטנציאלי.

ערך החזרה : בוליאני - true אם קיימים נתונים בנתיב הבן שצוין; אחרת false .

דוגמה זו מאפשרת לכתוב את הנתונים רק אם הם מכילים "שם" בן.

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

hasChildren([ילדים])

בדיקות לקיומם של ילדים.

טיעונים : Array children אופציונלי - מערך של מפתחות ילדים שכולם חייבים להתקיים.

ערך החזרה : Boolean - true אם קיימים ילדים (המצוינים); אחרת false .

אם לא יסופקו ארגומנטים, הוא יחזיר אמת אם ל- RuleDataSnapshot יש ילדים. אם מסופק מערך של שמות צאצאים, הוא יחזיר true רק אם כל הילדים שצוינו קיימים ב- RuleDataSnapshot .

דוגמה זו מאפשרת לכתוב את הנתונים רק אם הם מכילים ילד אחד או יותר.

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

דוגמה זו מאפשרת לכתוב את הנתונים רק אם הם מכילים ילדים "שם" ו"גיל".

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

קיים()

מחזירה true אם RuleDataSnapshot זה מכיל נתונים כלשהם.

ערך החזרה : Boolean - true אם RuleDataSnapshot מכיל נתונים כלשהם; אחרת false .

הפונקציה exists מחזירה true אם RuleDataSnapshot זה מכיל נתונים כלשהם. זוהי פונקציית נוחות בלבד מכיוון ש- data.exists() שווה ערך ל- data.val() != null .

דוגמה זו מאפשרת כתיבה במיקום זה כל עוד אין נתונים קיימים.

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

getPriority()

מקבל את העדיפות של הנתונים בתמונת RuleDataSnapshot .

ערך החזרה : ( String , Number , Null ) - העדיפות של הנתונים ב- RuleDataSnapshot זה.

דוגמה זו מבטיחה שלנתונים החדשים הנכתבים יש עדיפות

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

isNumber()

מחזירה true אם RuleDataSnapshot זה מכיל ערך מספרי.

ערך החזרה : Boolean - true אם הנתונים הם מספריים; אחרת false .

דוגמה זו מבטיחה שלנתונים החדשים שנכתבים יש "גיל" בן עם ערך מספרי.

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

isString()

מחזירה true אם RuleDataSnapshot זה מכיל ערך מחרוזת.

ערך החזרה : Boolean - true אם הנתונים הם String ; אחרת false .

דוגמה זו מבטיחה שלנתונים החדשים הנכתבים יש "שם" בן עם ערך מחרוזת.

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

isBoolean()

מחזירה true אם RuleDataSnapshot זה מכיל ערך בוליאני.

ערך החזרה : Boolean - true אם הנתונים הם Boolean ; אחרת false .

דוגמה זו מבטיחה שלנתונים החדשים שנכתבים יש ילד "פעיל" עם ערך בוליאני.

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

מחרוזת: מאפיינים

אורך

מחזירה את אורך המחרוזת.

ערך החזרה : Number - מספר התווים במחרוזת.

דוגמה זו דורשת שהמחרוזת תהיה בת 10 תווים לפחות.

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

מחרוזת: שיטות

מכיל (מחרוזת משנה)

מחזירה true אם המחרוזת מכילה את המחרוזת המשנה שצוינה.

ארגומנטים : substring String מחרוזת משנה שצריך לחפש.

Return Value : Boolean - true אם המחרוזת מכילה את המחרוזת המשנה שצוינה; אחרת false .

דוגמה זו דורשת שהנתונים יהיו מחרוזת המכילה "@".

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

beginsWith(מחרוזת משנה)

מחזירה true אם המחרוזת מתחילה במחרוזת המשנה שצוינה.

ארגומנטים : substring String מחרוזת משנה שיש לחפש בהתחלה.

Return Value : Boolean - true אם המחרוזת מכילה את המחרוזת המשנה שצוינה; אחרת false .

דוגמה זו מאפשרת גישת קריאה אם auth.token.identifier מתחיל ב-"internal-"

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

endsWith(מחרוזת משנה)

מחזירה true אם המחרוזת מסתיימת במחרוזת המשנה שצוינה.

ארגומנטים : substring String - תת מחרוזת לחפש בסוף.

Return Value : Boolean - true אם המחרוזת מסתיימת במחרוזת המשנה שצוינה; אחרת false .

דוגמה זו מאפשרת גישת קריאה אם auth.token.identifier מסתיים ב-"@company.com"

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

replace(מחרוזת משנה, החלפה)

מחזירה עותק של המחרוזת עם כל המופעים של מחרוזת משנה שצוינה מוחלפת במחרוזת ההחלפה שצוינה.

ארגומנטים : substring String - מחרוזת משנה שצריך לחפש. replacement String - מחרוזת להחלפת המחרוזת המשנה בה.

Return Value : 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()"

התאמות (רגקס)

מחזירה true אם המחרוזת תואמת את הביטוי הרגולרי שצוין.

Return Value : Boolean - true אם המחרוזת תואמת לביטוי הרגולרי ליטרלי, regex; אחרת false .

ראה את התיעוד המלא של כללים רגולריים .

מפעילים

+ (הוסף)

משמש להוספת משתנים או לשרשור מחרוזות.

הדוגמה הבאה מבטיחה שהערך החדש מגדיל את הערך הקיים באחד בדיוק. זה שימושי ליישום מונה:

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

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

- (שלילה או הפחתה)

משמש כדי לשלול ערך או להחסיר שני ערכים בביטוי כללים.

כלל אימות זה בודק שהערך החדש הוא היפוך של ערך צאצא במיקום:

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

הדוגמה הבאה משתמשת בחיסור כדי להבטיח שניתן לקרוא רק הודעות מעשר הדקות האחרונות:

".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"

=== (שווה)

משמש כדי לבדוק אם לשני משתנים בביטוי כללים יש אותו סוג וערך.

הכלל הבא משתמש באופרטור === כדי להעניק גישת כתיבה רק לבעלים של חשבון המשתמש. ה-uid של המשתמש חייב להתאים בדיוק למפתח ( $user_id ) כדי שהכלל יוערך כ-true.

"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"

? (אופרטור טרירי)

משמש להערכת ביטוי כללים מותנה.

האופרטור השלישוני לוקח שלושה אופרנדים. האופרנד לפני ה? הוא התנאי. אם התנאי מוערך כ-true, האופרנד השני מוערך. אם התנאי שקרי, האופרנד השלישי מוערך.

עבור כלל האימות הבא, הערך החדש יכול להיות מספר או בוליאני. אם זה מספר, הוא חייב להיות גדול מ-0.

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