Firebase Database防止重复条目：iOS/Android应用规则配置求助

Got it, let’s fix this uniqueness issue right in your Firebase Database rules so you don’t have to duplicate logic across iOS and Android. The key here is to use a dedicated index node to track unique values, paired with write rules that validate new entries against that index—this ensures no duplicates get written, even if clients try to bypass checks.

Step 1: Define Your Data Structure #

First, let’s assume you’re storing entries in an items node, and each entry has a field that needs to be unique (let’s call it uniqueIdentifier, like a user’s email, product SKU, or custom unique string). We’ll add a second node uniqueItemIndex to map these unique values to their corresponding item IDs—this lets Firebase quickly check for duplicates without scanning the entire items list.

Example structure:

{
  "items": {
    "item123": {
      "uniqueIdentifier": "user@example.com",
      "name": "Sample Item",
      "description": "..."
    },
    "item456": {
      "uniqueIdentifier": "another@example.com",
      "name": "Another Item",
      "description": "..."
    }
  },
  "uniqueItemIndex": {
    "user@example.com": "item123",
    "another@example.com": "item456"
  }
}

Step 2: Implement the Firebase Rules #

These rules will:

1. Block new entries if their uniqueIdentifier already exists in the index
2. Ensure the index stays in sync with the items node (no orphaned index entries or mismatches)

Here’s the full rule set:

{
  "rules": {
    "items": {
      "$itemId": {
        // Allow writing only if: user is authenticated, it's a new entry, and the unique ID isn't taken
        ".write": "auth != null && !data.exists() && !root.child('uniqueItemIndex').child(newData.child('uniqueIdentifier').val()).exists()",
        // Validate that required fields are present
        ".validate": "newData.hasChildren(['uniqueIdentifier', 'name', 'description'])"
      }
    },
    "uniqueItemIndex": {
      "$uniqueValue": {
        // Allow writing only if the value matches the corresponding item ID, and the item's unique ID matches this index key
        ".write": "auth != null && newData.val() === root.child('items').child($itemId).key",
        ".validate": "root.child('items').child(newData.val()).child('uniqueIdentifier').val() === $uniqueValue"
      }
    }
  }
}

Rule Breakdown #

• For items/$itemId:

  • auth != null: Ensures only authenticated users can write (remove this if you don’t need auth, but it’s recommended for security)
  • !data.exists(): Prevents overwriting existing items (adjust if you need to allow edits—see note below)
  • !root.child('uniqueItemIndex').child(newData.child('uniqueIdentifier').val()).exists(): Checks that the unique value hasn’t been used before

• For uniqueItemIndex/$uniqueValue:

  • Ensures the index entry always points to a valid item, and the item’s unique ID matches the index key—this prevents invalid or orphaned entries in the index.

Step 3: Client-Side Write (Batch Update) #

To keep the items and uniqueItemIndex nodes in sync, you need to write to both in a single batch update. This ensures either both writes succeed or both fail, avoiding inconsistencies.

Here’s what this looks like in pseudo-code (iOS/Android SDKs have equivalent methods):

// iOS example (Swift)
let ref = Database.database().reference()
let newItemId = ref.child("items").childByAutoId().key
let updates = [
  "items/\(newItemId)": [
    "uniqueIdentifier": "user@example.com",
    "name": "My New Item",
    "description": "..."
  ],
  "uniqueItemIndex/user@example.com": newItemId
]
ref.updateChildValues(updates) { error, _ in
  if let error = error {
    // Handle duplicate error or write failure
    print("Write failed: \(error.localizedDescription)")
  } else {
    // Success!
  }
}

Important Notes #

• Allowing Edits: If you need to let users edit items but not change the uniqueIdentifier, adjust the items/$itemId write rule to:

  ".write": "auth != null && (!data.exists() || (data.exists() && data.child('uniqueIdentifier').val() === newData.child('uniqueIdentifier').val())) && (!root.child('uniqueItemIndex').child(newData.child('uniqueIdentifier').val()).exists() || (data.exists() && root.child('uniqueItemIndex').child(data.child('uniqueIdentifier').val()).val() === $itemId))"
  

  This ensures edits don’t change the unique field, and the index remains linked to the correct item.

• Case Sensitivity: Firebase rules are case-sensitive, so "User@Example.com" and "user@example.com" are treated as different values. If you need case-insensitive uniqueness, normalize the value (e.g., convert to lowercase) before writing to both nodes.

• Security: Always keep your rules tight—avoid broad write permissions. The rules above ensure only valid, unique entries are added, and the index can’t be tampered with independently.

内容的提问来源于stack exchange，提问作者Anirudha Mahale