Interfejs API reguł zabezpieczeń bazy danych Firebase

Reguła: typy

.read

Przyznaje klientowi dostęp z możliwością odczytu do lokalizacji w Bazie danych czasu rzeczywistego Firebase.

Reguła .read to typ reguły zabezpieczeń, który przyznaje klientowi dostęp z możliwością odczytu do lokalizacji w Bazie danych czasu rzeczywistego Firebase. Przykład:

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

Wartość reguły .read jest ciągiem znaków, który jest oceniany jako podzbiór składni wyrażeń JavaScriptu z kilkoma zmianami w działaniu, które zwiększają przejrzystość i poprawność działania. Reguła .read, która przyznaje uprawnienia do odczytu lokalizacji, zezwala też na odczyt wszystkich jej elementów podrzędnych, nawet jeśli te elementy podrzędne mają własne reguły .read, które nie działają.

Reguła .read ma dostęp do wszystkich zmiennych reguł w Bazie danych czasu rzeczywistego Firebase z wyjątkiem newData.

.write

Przyznaje klientowi uprawnienia do zapisu w lokalizacji Bazy danych czasu rzeczywistego Firebase.

Reguła .write to typ reguły zabezpieczeń, który przyznaje klientowi uprawnienia do zapisu w lokalizacji w Bazie danych czasu rzeczywistego Firebase. Przykład:

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

Wartość reguły .write jest ciągiem znaków, który jest oceniany jako podzbiór składni wyrażeń JavaScriptu z kilkoma zmianami w działaniu, które zwiększają przejrzystość i poprawność działania. Reguła .write, która przyznaje uprawnienia do zapisu w lokalizacji, zezwala też na zapis do wszystkich jej elementów podrzędnych, nawet jeśli mają one własne reguły .write, które nie działają.

Reguła .write ma dostęp do wszystkich zmiennych reguł w Bazie danych czasu rzeczywistego Firebase.

.validate

Używana, gdy reguła .write przyzna dostęp, aby zapewnić, że zapisywane dane są zgodne z określonym schematem.

Reguła .validate jest używana po przyznaniu dostępu przez regułę .write w celu zagwarantowania, że zapisywane dane są zgodne z określonym standardem. Oprócz .write przyznającego dostęp do zapisu dozwolony jest też zapis wszystkich odpowiednich reguł .validate. Przykład:

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

Wartość reguły .validate jest ciągiem znaków, który jest oceniany jako podzbiór składni wyrażeń JavaScriptu z kilkoma zmianami w działaniu, które zwiększają przejrzystość i poprawność działania.

Reguła .validate ma dostęp do wszystkich zmiennych reguł w Bazie danych czasu rzeczywistego Firebase.

.indexOn

Zwiększa wydajność zapytań, wskazując Bazie danych czasu rzeczywistego Firebase, które klucze mają być indeksowane w Twoich danych.

Reguła .indexOn informuje serwery Bazy danych czasu rzeczywistego Firebase, aby indeksowały określone klucze w Twoich danych, aby zwiększyć wydajność zapytań. Jeśli na przykład baza danych zawiera zbiór danych o dinozaurach, możemy zastosować w Bazie danych czasu rzeczywistego Firebase optymalizację pod kątem zapytań, zanim zostaną one zwrócone z serwerów, dodając tę regułę:

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

Więcej informacji o regule .indexOn znajdziesz w sekcji przewodnika po zabezpieczeniach poświęconej indeksowaniu danych.

Reguła: zmienne

uwierzytelnienie

zmienną zawierającą ładunek tokena, jeśli klient jest uwierzytelniony, lub parametr null. jeśli klient nie jest uwierzytelniony.

Baza danych czasu rzeczywistego Firebase umożliwia łatwe uwierzytelnianie u kilku wbudowanych dostawców i generowanie dla nich tokenów uwierzytelniania. Gdy użytkownik zostanie uwierzytelniony przy użyciu jednego z wbudowanych dostawców, zmienna auth będzie zawierać:

Pole Opis
provider Używana metoda uwierzytelniania (np. „hasło”, „anonimowe”, „facebook”, „github”, „google” lub „twitter”).
uid Unikalny identyfikator użytkownika, który musi być unikalny wśród wszystkich dostawców.
token Zawartość tokena identyfikatora uwierzytelniania Firebase. Zobacz auth.token.

Dla przykładu możemy stworzyć regułę podobną do tej, która zezwala użytkownikom na tworzenie komentarzy pod warunkiem, że przechowują w nim swój identyfikator:

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

Możemy też utworzyć regułę podobną do tej, która zezwala użytkownikom na tworzenie komentarzy pod warunkiem, że są zalogowani przez Facebooka:

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

token.auth.token

Zmienna zawierająca zawartość tokena identyfikatora uwierzytelniania Firebase.

Token zawiera niektóre lub wszystkie z tych kluczy:

Pole Opis
email Adres e-mail powiązany z kontem (jeśli istnieje).
email_verified true, jeśli użytkownik potwierdził, że ma dostęp do adresu email. Niektórzy dostawcy automatycznie potwierdzają swoje adresy e-mail.
phone_number Numer telefonu powiązany z kontem (jeśli istnieje).
name Wyświetlana nazwa użytkownika (jeśli została ustawiona).
sub Identyfikator UID Firebase użytkownika. Jest to unikalna wartość w obrębie projektu.
firebase.identities Słownik wszystkich tożsamości powiązanych z kontem tego użytkownika. Słownik może zawierać te klucze: email, phone, google.com, facebook.com, github.com, twitter.com. Wartościami słownika są tablice unikalnych identyfikatorów każdego dostawcy tożsamości powiązanego z kontem. Na przykład auth.token.firebase.identities["google.com"][0] zawiera pierwszy identyfikator użytkownika Google powiązany z kontem.
firebase.sign_in_provider Dostawca logowania, który został użyty do uzyskania tego tokena. Może to być jeden z tych ciągów: custom, password, phone, anonymous, google.com, facebook.com, github.com, twitter.com.
firebase.tenant Identyfikator najemcy powiązany z kontem, jeśli istnieje. np. tenant2-m6tyz

Jeśli używasz uwierzytelniania niestandardowego, auth.token zawiera też wszelkie niestandardowe określone przez programistę.

Wszystkie te wartości można stosować w regułach. Aby na przykład ograniczyć dostęp do kont Google powiązanych z adresem w domenie gmail.com, możemy dodać taką regułę:

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

Dla pełnego obrazu dostępne są też te pola w auth.token, ale prawdopodobnie nie będą przydatne w regułach.

Pole Opis
iss Wydawca tokena.
aud Odbiorcy tokena.
auth_time Czas ostatniego uwierzytelnienia użytkownika za pomocą danych logowania przy użyciu urządzenia otrzymującego token.
iat Czas wydania tokena.
exp Godzina wygaśnięcia tokena.

$location

Zmienna, która może służyć do odwoływania się do klucza $location, który był używany wcześniej w strukturze reguł.

Jeśli w strukturze reguł masz $location, możesz użyć pasującej zmiennej $ w wyrażeniu reguły, aby uzyskać nazwę odczytywanego lub zapisywanego elementu podrzędnego. Załóżmy, że chcemy przyznać każdemu użytkownikowi uprawnienia do odczytu i zapisu we własnej lokalizacji /users/<user>. Możemy użyć:

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

Gdy klient spróbuje uzyskać dostęp do usługi /users/barney, domyślna lokalizacja typu $user zostanie dopasowana, gdy $user będzie równa „barney”. Dlatego reguła .read sprawdzi, czy auth.uid === 'barney'. W związku z tym odczyt /users/barney będzie udany tylko wtedy, gdy klient zostanie uwierzytelniony za pomocą identyfikatora UID „barney”.

od teraz

Zawiera liczbę milisekund od początku epoki uniksowej określonej przez serwery Bazy danych czasu rzeczywistego Firebase.

Zmienna now zawiera liczbę milisekund od początku epoki systemu UNIX, zgodnie z informacjami pochodzącymi z serwerów Bazy danych czasu rzeczywistego Firebase. Możesz na przykład użyć tego kodu, aby sprawdzić, czy czas w polu created użytkownika nigdy nie przypada w przyszłości:

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

poziom główny

Element RuleDataSnapshot (reguła danych) odpowiadający bieżącym danym w katalogu głównym Bazy danych czasu rzeczywistego Firebase.

Zmienna główna zawiera obiekt RuleDataSnapshot (reguła danych) odpowiadający bieżącym danym w katalogu głównym Twojej bazy danych czasu rzeczywistego Firebase. Za jego pomocą możesz odczytywać w wyrażeniach reguły dowolne dane z bazy danych. Aby na przykład zezwolić użytkownikom na odczytywanie pliku /comments tylko wtedy, gdy ich zasada /users/<id>/active ma wartość Prawda, możemy użyć:

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

Jeśli pole /users/barney/active zawierało wartość true (prawda), użytkownik uwierzytelnił się za pomocą identyfikatora UID „barney”. może zapisać dane w węźle /comments.

dane

RuleDataSnapshot (Reguła DataSnapshot), która odpowiada bieżącym danym w Bazie danych czasu rzeczywistego Firebase w lokalizacji obecnie wykonywanej reguły.

Zmienna danych udostępnia wskaźnik RuleDataSnapshot, który odpowiada bieżącym danym w bazie danych lokalizacji obecnie wykonywanej reguły (a nie katalog główny, który podaje dane z katalogu głównego bazy danych).

Jeśli na przykład chcesz zezwolić dowolnemu klientowi na dostęp do zasady /users/<user>, gdyby zasada /users/<user>/public miała wartość Prawda, możesz użyć:

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

Zmienna danych jest dostępna w tych interfejsach: .read, .write i .validate reguł.

noweDane

Obiekt RuleDataSnapshot (reguła danych) odpowiadający danym, które powstaną przy dozwolonym zapisie.

W przypadku reguł .write i .validate zmienna newData udostępnia obiekt RuleDataSnapshot (zrzut danych reguły), który odpowiada danym, które zostaną odnotowane, jeśli zapis będzie dozwolony (jest to „scalanie” istniejących danych z zapisywanymi nowymi danymi). Jeśli chcesz mieć pewność, że każdy użytkownik ma imię i nazwisko oraz wiek, możesz użyć:

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

Wartość newData scala istniejące i nowe dane, dlatego działa prawidłowo nawet w przypadku „częściowych” aktualizacje. Przykład:

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

Zmienna newData jest niedostępna w regułach .read, ponieważ nie są zapisywane żadne nowe dane. Należy używać po prostu danych.

RuleDataSnapshot: metody

wartość()

Pobiera wartość podstawową (string, number, boolean lub null) z tego elementu RuleDataSnapshot.

Zwracana wartość: (String, Number, Boolean, Null) – wartość podstawowa z tego RuleDataSnapshot.

W przeciwieństwie do DataSnapshot.val() wywołanie val() w przypadku RuleDataSnapshot, który zawiera dane podrzędne, nie spowoduje zwrócenia obiektu zawierającego te elementy. Zamiast tego zwróci specjalną wartość wartojącą. Dzięki temu reguły mogą zawsze działać skutecznie.

Dlatego, aby uzyskiwać dostęp do dzieci, musisz zawsze używać nazwy child() (np. data.child('name').val(), a nie data.val().name).

W tym przykładzie można czytać tylko wtedy, gdy w odczytywanej lokalizacji dla elementu podrzędnego isReadable (odczytywanego) ma wartość true (prawda).

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

dziecko()

Pobiera obiekt RuleDataSnapshot na potrzeby lokalizacji w określonej ścieżce względnej.

Argumenty: childPath String – ścieżka względna do lokalizacji danych podrzędnych.

Zwracana wartość: RuleDataSnapshot – RuleDataSnapshot (dla lokalizacji podrzędnej).

Ścieżka względna może być prostą nazwą elementu podrzędnego (np. „fred”) lub ścieżką oddzielonych ukośnikami (np. „fred/imię/imię”). Jeśli lokalizacja podrzędna nie ma danych, zwracany jest pusty element RuleDataSnapshot.

W tym przykładzie można czytać tylko wtedy, gdy w odczytywanej lokalizacji dla elementu podrzędnego isReadable (odczytywanego) ma wartość true (prawda).

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

nadrzędny()

Pobiera obiekt RuleDataSnapshot dla lokalizacji nadrzędnej.

Zwracana wartość: RuleDataSnapshot – RuleDataSnapshot na potrzeby lokalizacji nadrzędnej.

Jeśli ta instancja odnosi się do poziomu głównego bazy danych czasu rzeczywistego Firebase, nie ma ona elementu nadrzędnego, przez co parent() nie powiedzie się, co spowoduje pominięcie bieżącego wyrażenia reguły (jako błąd).

W tym przykładzie można czytać tylko wtedy, gdy element podrzędny isReadable ma wartość true (prawda).

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

hasChild(childPath)

Zwraca wartość „prawda”, jeśli określony element podrzędny istnieje.

Argumenty: childPath String – ścieżka względna do lokalizacji potencjalnego elementu podrzędnego.

Zwracana wartość: Wartość logiczna – true, jeśli dane istnieją na określonej ścieżce podrzędnej; a w przypadku: false.

W tym przykładzie można zapisywać dane tylko wtedy, gdy zawierają one podrzędny element „name”.

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

madzieci([dzieci])

Sprawdza, czy istnieją dzieci.

Argumenty: children Array opcjonalnie – tablica kluczy podrzędnych, które muszą istnieć.

Zwracana wartość: Boolean – true, jeśli istnieją (określone) elementy podrzędne; a w przeciwnym razie – false.

Jeśli nie podano żadnych argumentów, zwracana jest wartość „prawda”, jeśli RuleDataSnapshot ma jakieś elementy podrzędne. Jeśli podana jest tablica nazw podrzędnych, zwraca wartość „prawda” tylko wtedy, gdy w RuleDataSnapshot znajdują się wszystkie podane elementy podrzędne.

Ten przykład zezwala na zapisywanie danych tylko wtedy, gdy zawiera on co najmniej 1 element podrzędny.

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

Ten przykład zezwala na zapisywanie danych tylko wtedy, gdy zawierają one ciąg znaków „name” i „wiek” dzieci.

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

istnieje()

Zwraca wartość prawda, jeśli element RuleDataSnapshot zawiera jakiekolwiek dane.

Zwracana wartość: Boolean – true, jeśli obiekt RuleDataSnapshot zawiera jakiekolwiek dane; a w przypadku: false.

Funkcja istnieje zwraca wartość „true” (prawda), jeśli ten element RuleDataSnapshot zawiera jakiekolwiek dane. Jest to funkcja czysto udogodnienia, ponieważ data.exists() jest odpowiednikiem data.val() != null.

Ten przykład zezwala na zapis w tej lokalizacji, o ile nie ma żadnych danych.

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

getPriority(),

Pobiera priorytet danych w komponencie RuleDataSnapshot.

Zwracana wartość: (String, Number, Null) – priorytet danych w tym zrzucie danych reguł.

Ten przykład zapewnia, że zapisywane nowe dane mają priorytet

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

isNumber(),

Zwraca wartość „prawda”, jeśli element RuleDataSnapshot zawiera wartość liczbową.

Zwracana wartość: Boolean – true, jeśli dane są liczbowe; a w przeciwnym razie – false.

Ten przykład pozwala upewnić się, że nowo zapisywane dane mają wiek dziecka z wartością liczbową.

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

isString()

Zwraca wartość „prawda”, jeśli element RuleDataSnapshot zawiera wartość w postaci ciągu znaków.

Zwracana wartość: Boolean – true, jeśli dane to String; a w przypadku: false.

Ten przykład pozwala upewnić się, że zapisywane nowe dane mają element podrzędny „name” ciągiem tekstowym.

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

isBoolean()

Zwraca wartość prawda, jeśli element RuleDataSnapshot zawiera wartość logiczną.

Zwracana wartość: Boolean – true, jeśli dane to Boolean; a w przeciwnym razie – false.

Ten przykład zapewnia, że zapisywane nowe dane mają stan podrzędny „aktywny” z wartością logiczną.

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

Ciąg: właściwości

długość

Zwraca długość ciągu.

Zwracana wartość: Number – liczba znaków w ciągu znaków.

W tym przykładzie ciąg musi mieć co najmniej 10 znaków.

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

Ciąg znaków: metody

zawiera(podłańcuch)

Zwraca wartość „prawda”, jeśli ciąg zawiera określony podłańcuch.

Argumenty: substring String – podłańcuch do wyszukania.

Zwracana wartość: Boolean – true, jeśli ciąg zawiera określony podłańcuch; a w przeciwnym razie – false.

W tym przykładzie dane muszą być ciągiem znaków zawierającym „@”.

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

startedWith(podłańcuch)

Zwraca wartość „prawda”, jeśli ciąg znaków zaczyna się od określonego podłańcucha.

Argumenty: substring String – podłańcuch do wyszukania na początku.

Zwracana wartość: Boolean – true, jeśli ciąg zawiera określony podłańcuch; a w przeciwnym razie – false.

Ten przykład umożliwia dostęp w trybie odczytu, jeśli auth.token.identifier zaczyna się od „internal-”

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

EndWith(podłańcuch)

Zwraca wartość „prawda”, jeśli ciąg znaków kończy się określonym podłańcuchem.

Argumenty: substring String – podłańcuch do wyszukania na końcu.

Zwracana wartość: Boolean – true, jeśli ciąg znaków kończy się określonym podłańcuchem; a w przeciwnym razie – false.

Ten przykład zapewnia uprawnienia do odczytu, jeśli domena auth.token.identifier kończy się na „@firma.com”

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

zamień(podłańcuch; zamiennik)

Zwraca kopię ciągu znaków ze wszystkimi wystąpieniami określonego podłańcucha zastąpionymi określonym ciągiem zastępczym.

Argumenty: substring String – podłańcuch do wyszukania. replacement String – ciąg, którym ma zostać zastąpiony podłańcuch.

Zwracana wartość: String – nowy ciąg po zastąpieniu podłańcucha zastąpieniem.

Metoda replace() różni się nieco od metody JavaScript replace() tym, że zastępuje wszystkie wystąpienia określonego podłańcucha określonym ciągiem zastępczym, a nie tylko pierwszym wystąpieniem.

Kropki są niedozwolone w kluczach, więc przed ich zapisaniem musimy poprzedzać ciągi tekstowe z kropkami. Przykładem mogą być adresy e-mail. Załóżmy, że w węźle /whitelist/ mamy listę adresów e-mail umieszczonych na białej liście:

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

Możemy utworzyć regułę, która zezwala na dodawanie użytkowników tylko wtedy, gdy ich adres e-mail znajduje się w węźle /whitelist/:

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

toLowerCase()

Zwraca kopię ciągu znaków przekonwertowaną na małe litery.

Zwracana wartość: String – ciąg przekonwertowany na małe litery.

Ten przykład umożliwia dostęp w trybie odczytu, jeśli auth.token.identifier (w /users) zawiera wszystkie małe litery.

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

wielkość liter()

Zwraca kopię ciągu znaków przekonwertowaną na wielkie litery.

Zwracana wartość: String – ciąg przekonwertowany na wielkie litery.

Ten przykład umożliwia dostęp w trybie odczytu, jeśli auth.token.identifier zawiera wszystkie wielkie litery w wierszu /users.

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

pasuje(wyrażenie regularne)

Zwraca wartość „prawda”, jeśli ciąg znaków pasuje do określonego literału wyrażenia regularnego.

Zwracana wartość: Boolean – true, jeśli ciąg znaków pasuje do literału wyrażenia regularnego, wyrażenia regularnego; a w przeciwnym razie – false.

Zobacz pełną dokumentację wyrażeń regularnych reguł.

Operatory

+ (dodaj)

Służy do dodawania zmiennych lub łączenia ciągów znaków.

W przykładzie poniżej nowa wartość zwiększa wartość dokładnie o 1. Jest to przydatne przy implementowaniu licznika:

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

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

- (wyklucz lub odejmuj)

Służy do wykluczania wartości lub odejmowania 2 wartości w wyrażeniu reguł.

Ta reguła weryfikacji sprawdza, czy nowa wartość jest odwrotnością wartości podrzędnej w danej lokalizacji:

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

W przykładzie poniżej użyto odejmowania, aby zapewnić czytanie tylko wiadomości z ostatnich 10 minut:

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

* (mnożenie)

Służy do mnożenia zmiennych w wyrażeniu reguł.

Ta reguła weryfikacji sprawdza, czy nowa wartość jest równa produkcji ceny i ilości (2 dotychczasowe wartości):

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

/ (dzielenie)

Służy do dzielenia zmiennych w wyrażeniu reguł.

W poniższym przykładzie reguła weryfikacji sprawia, że przechowywane dane stanowią średnią wszystkich danych przechowywanych w innym miejscu:

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

% (moduł)

Służy do znajdowania pozostałej części dzielenia jednej zmiennej przez drugą w wyrażeniu reguł.

Ta reguła sprawdza, czy można zapisywać tylko liczby parzyste:

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

=== (równe)

Służy do sprawdzania, czy dwie zmienne w wyrażeniu reguł mają ten sam typ i wartość.

W poniższej regule za pomocą operatora === przyznano uprawnienia do zapisu tylko właścicielowi konta użytkownika. Aby reguła została uznana za prawda, identyfikator UID użytkownika musi dokładnie odpowiadać kluczowi ($user_id).

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

!== (nie równa się)

Służy do sprawdzania, czy 2 zmienne w wyrażeniu reguł nie są równe.

Ta reguła odczytu zapewnia, że tylko zalogowani użytkownicy mogą odczytywać dane:

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

& (ORAZ)

Zwraca wartość prawda, jeśli oba operandy są prawdziwe. Służy do określania wielu warunków w wyrażeniu reguł.

Ta reguła weryfikacji sprawdza, czy nowe dane są ciągiem krótszym niż 100 znaków:

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

|| (LUB)

Zwraca wartość prawda, jeśli jeden operand w wyrażeniu reguł jest prawdziwy.

W tym przykładzie możemy zapisać dane, dopóki nie istnieją stare lub nowe dane. Inaczej mówiąc, możemy zapisywać, czy usuwamy lub tworzymy dane, ale nie możemy ich aktualizować.

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

! (NIE)

Zwraca wartość prawda, jeśli pojedynczy operand jest fałszywy. W wyrażeniach reguł znak ! jest często używany do sprawdzania, czy dane zostały zapisane w lokalizacji.

Poniższa reguła zezwala na zapis tylko wtedy, gdy w określonej lokalizacji nie ma danych:

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

> (większe niż)

Służy do sprawdzania, czy wartość jest większa od innej wartości w wyrażeniu reguł.

Ta reguła weryfikacji sprawdza, czy wpisywany ciąg nie jest pusty:

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

< (mniejsze niż)

Służy do sprawdzania, czy wartość jest mniejsza od innej wartości w wyrażeniu reguł.

Ta reguła weryfikacji sprawdza, czy ciąg znaków ma mniej niż 20 znaków:

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

>= (większe niż lub równe)

Służy do sprawdzania, czy wartość jest większa lub równa innej wartości w wyrażeniu reguł.

Ta reguła weryfikacji sprawdza, czy wpisywany ciąg nie jest pusty:

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

<= (mniejsze niż lub równe)

Służy do sprawdzania, czy wartość jest mniejsza czy równa innej wartości w wyrażeniu reguł.

Ta reguła weryfikacji zapobiega dodawanie nowych danych w przyszłości:

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

? (operator potrójny)

Służy do oceny wyrażenia reguł warunkowych.

Operator potrójny przyjmuje 3 operandy. Argument przed znakiem ? to warunek. Jeśli warunek ma wartość prawda, sprawdzany jest drugi operand. Jeśli warunek ma wartość Fałsz, sprawdzany jest trzeci operand.

W przypadku tej reguły weryfikacji nową wartością może być liczba lub wartość logiczna. Jeśli jest to liczba, musi być większa niż 0.

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