API กฎความปลอดภัยของฐานข้อมูล Firebase

กฎ: ประเภท

.อ่าน

มอบสิทธิ์การอ่านตำแหน่งฐานข้อมูลเรียลไทม์ Firebase ให้กับลูกค้า

กฎ .read คือกฎความปลอดภัยประเภทหนึ่งที่ให้สิทธิ์การเข้าถึงแบบอ่านแก่ไคลเอ็นต์ไปยังตำแหน่งฐานข้อมูล Firebase Realtime ตัวอย่างเช่น:

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

ค่าของกฎ .read คือสตริง ซึ่งได้รับการประเมินว่าเป็นชุดย่อยของไวยากรณ์นิพจน์ของ JavaScript โดยมีการเปลี่ยนแปลงลักษณะการทำงานเล็กน้อยเพื่อเพิ่มความชัดเจนและความถูกต้อง กฎ .read ที่ให้สิทธิ์ในการอ่านตำแหน่งจะอนุญาตให้อ่านผู้สืบทอดของตำแหน่งนั้นด้วย แม้ว่าผู้สืบทอดจะมีกฎ .read ของตนเองซึ่งล้มเหลวก็ตาม

กฎ .read มีสิทธิ์เข้าถึง ตัวแปรกฎ ของฐานข้อมูล Firebase Realtime ทั้งหมด ยกเว้น newData

.เขียน

มอบสิทธิ์การเขียนไคลเอ็นต์ไปยังตำแหน่งฐานข้อมูลเรียลไทม์ Firebase

กฎ .write คือกฎความปลอดภัยประเภทหนึ่งที่ให้สิทธิ์การเขียนไคลเอ็นต์ไปยังตำแหน่งฐานข้อมูล Firebase Realtime ตัวอย่างเช่น:

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

ค่าของกฎ .write คือสตริง ซึ่งได้รับการประเมินว่าเป็นชุดย่อยของไวยากรณ์นิพจน์ของ JavaScript โดยมีการเปลี่ยนแปลงลักษณะการทำงานเล็กน้อยเพื่อเพิ่มความชัดเจนและความถูกต้อง กฎ .write ซึ่งให้สิทธิ์ในการเขียนไปยังตำแหน่งนั้นจะอนุญาตให้เขียนไปยังผู้สืบทอดของตำแหน่งนั้นด้วย แม้ว่าผู้สืบทอดจะมีกฎ .write ของตนเองซึ่งล้มเหลวก็ตาม

กฎ .write มีสิทธิ์เข้าถึง ตัวแปรกฎ ของฐานข้อมูล Firebase Realtime ทั้งหมด

.ตรวจสอบความถูกต้อง

ใช้เมื่อกฎ .write ให้สิทธิ์ในการเข้าถึง เพื่อให้แน่ใจว่าข้อมูลที่เขียนสอดคล้องกับสคีมาเฉพาะ

กฎ .validate จะใช้เมื่อกฎ .write ให้สิทธิ์ในการเข้าถึง เพื่อให้แน่ใจว่าข้อมูลที่เขียนเป็นไปตามมาตรฐานเฉพาะ นอกเหนือจากการอนุญาตการเข้าถึง .write แล้ว กฎ .validate ที่เกี่ยวข้องทั้งหมดจะต้องสำเร็จก่อนจึงจะอนุญาตให้เขียนได้ ตัวอย่างเช่น:

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

ค่าของกฎ .validate คือสตริง ซึ่งได้รับการประเมินว่าเป็นชุดย่อยของไวยากรณ์นิพจน์ของ JavaScript โดยมีการเปลี่ยนแปลงลักษณะการทำงานเล็กน้อยเพื่อเพิ่มความชัดเจนและความถูกต้อง

กฎ .validate มีสิทธิ์เข้าถึง ตัวแปรกฎ ของฐานข้อมูล Firebase Realtime ทั้งหมด

.indexOn

ปรับปรุงประสิทธิภาพการสืบค้นโดยบอก Firebase Realtime Database ว่าคีย์ใดที่คุณต้องการให้จัดทำดัชนีข้อมูล

กฎ .indexOn บอกให้เซิร์ฟเวอร์ Firebase Realtime Database ทำดัชนีคีย์เฉพาะในข้อมูลของคุณ เพื่อปรับปรุงประสิทธิภาพการสืบค้นของคุณ ตัวอย่างเช่น เมื่อกำหนดฐานข้อมูลที่มีการรวบรวมข้อมูลไดโนเสาร์ เราสามารถบอกให้ Firebase Realtime Database ปรับให้เหมาะสมสำหรับการสืบค้น ก่อนที่จะส่งคืนจากเซิร์ฟเวอร์ โดยการเพิ่มกฎนี้:

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

คุณสามารถดูข้อมูลเพิ่มเติมเกี่ยวกับกฎ .indexOn ได้จากส่วนคำแนะนำด้านความปลอดภัยเกี่ยวกับ การจัดทำดัชนีข้อมูลของคุณ

กฎ: ตัวแปร

รับรองความถูกต้อง

ตัวแปรที่มีเพย์โหลดโทเค็นหากไคลเอ็นต์ได้รับการรับรองความถูกต้อง หรือ null หากไคลเอ็นต์ไม่ได้รับการรับรองความถูกต้อง

ฐานข้อมูลเรียลไทม์ Firebase ช่วยให้คุณตรวจสอบสิทธิ์กับผู้ให้บริการในตัวหลายรายได้อย่างง่ายดาย และจะสร้างโทเค็นการตรวจสอบสิทธิ์สำหรับผู้ให้บริการเหล่านั้น หลังจากที่ผู้ใช้ได้รับการรับรองความถูกต้องกับผู้ให้บริการในตัวรายใดรายหนึ่งแล้ว ตัวแปรการรับรองความถูกต้องจะมีสิ่งต่อไปนี้:

สนาม คำอธิบาย
provider วิธีการรับรองความถูกต้องที่ใช้ (เช่น "รหัสผ่าน", "ไม่ระบุชื่อ", "facebook", "github", "google" หรือ "twitter")
uid รหัสผู้ใช้ที่ไม่ซ้ำใคร รับประกันว่าจะไม่ซ้ำกันในผู้ให้บริการทุกราย
token เนื้อหาของโทเค็น Firebase Auth ID ดูที่ auth.token

ตามตัวอย่าง เราอาจมีกฎดังต่อไปนี้เพื่ออนุญาตให้ผู้ใช้สร้างความคิดเห็นได้ ตราบใดที่พวกเขาเก็บ ID ผู้ใช้ไว้พร้อมกับความคิดเห็น:

{
  "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.โทเค็น

ตัวแปรที่มีเนื้อหาของโทเค็น 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] มี ID ผู้ใช้ 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 ในโครงสร้างกฎของคุณ คุณสามารถใช้ตัวแปร $ ที่ตรงกันภายในนิพจน์กฎของคุณเพื่อรับชื่อของรายการย่อยจริงที่กำลังอ่านหรือเขียนได้ สมมติว่าเราต้องการให้ผู้ใช้ทุกคนมีสิทธิ์ในการอ่านและเขียนตำแหน่ง /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"

ตอนนี้

ประกอบด้วยจำนวนมิลลิวินาทีนับตั้งแต่ยุค Unix ตามเซิร์ฟเวอร์ Firebase Realtime Database

ตัวแปร now มีจำนวนมิลลิวินาทีตั้งแต่ยุค UNIX ตามเซิร์ฟเวอร์ฐานข้อมูล Firebase Realtime ตัวอย่างเช่น คุณสามารถใช้สิ่งนี้เพื่อตรวจสอบว่าเวลา created ของผู้ใช้ไม่เคยตั้งเวลาไว้ในอนาคต:

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

ราก

RuleDataSnapshot ที่สอดคล้องกับข้อมูลปัจจุบันที่รากของฐานข้อมูลเรียลไทม์ Firebase ของคุณ

ตัวแปรรูทจะให้ RuleDataSnapshot ที่สอดคล้องกับข้อมูลปัจจุบันที่รูทของฐานข้อมูลเรียลไทม์ Firebase ของคุณ คุณสามารถใช้สิ่งนี้เพื่ออ่านข้อมูลใดๆ ในฐานข้อมูลของคุณในนิพจน์กฎของคุณ ตัวอย่างเช่น หากเราต้องการอนุญาตให้ผู้ใช้อ่าน /comments ได้ก็ต่อเมื่อ /users/<id>/active ของพวกเขาถูกตั้งค่าเป็นจริง เราสามารถใช้:

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

จากนั้น หาก /users/barney/active มีค่าเป็น true ผู้ใช้ที่ได้รับการพิสูจน์ตัวตนด้วย uid เป็น "barney" จะสามารถเขียนไปยังโหนด /comments ได้

ข้อมูล

RuleDataSnapshot ที่สอดคล้องกับข้อมูลปัจจุบันในฐานข้อมูลเรียลไทม์ Firebase ที่ตำแหน่งของกฎที่ดำเนินการอยู่ในปัจจุบัน

ตัวแปรข้อมูลจะให้ RuleDataSnapshot ที่สอดคล้องกับข้อมูลปัจจุบันในตำแหน่งฐานข้อมูลของกฎที่ดำเนินการอยู่ในปัจจุบัน (ตรงข้ามกับรูท ซึ่งจะให้ข้อมูลสำหรับรูทของฐานข้อมูลของคุณ)

ตัวอย่างเช่น หากคุณต้องการให้ไคลเอนต์เข้าถึง /users/<user> หาก /users/<user>/public ถูกตั้งค่าเป็นจริง คุณสามารถใช้:

{
  "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: วิธีการ

วาล()

รับค่าดั้งเดิม ( string , number , boolean หรือ null ) จาก RuleDataSnapshot นี้

ค่าส่งคืน : ( String , Number , Boolean , Null ) - ค่าดั้งเดิมจาก RuleDataSnapshot นี้

ต่างจาก DataSnapshot.val() การเรียก val() บน RuleDataSnapshot ที่มีข้อมูลลูกจะไม่ส่งคืนออบเจ็กต์ที่มีลูก ๆ โดยจะส่งกลับค่าแมวมองพิเศษแทน สิ่งนี้ทำให้มั่นใจได้ว่ากฎต่างๆ จะสามารถทำงานได้อย่างมีประสิทธิภาพอย่างยิ่งเสมอ

ด้วยเหตุนี้ คุณจะต้องใช้ child() เพื่อเข้าถึงอุปกรณ์ลูกเสมอ (เช่น data.child('name').val() ไม่ใช่ data.val().name )

ตัวอย่างนี้อนุญาตให้อ่านได้ก็ต่อเมื่อลูก isReadable ถูกตั้งค่าเป็นจริงในตำแหน่งที่กำลังอ่าน

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

เด็ก()

รับ RuleDataSnapshot สำหรับตำแหน่งที่เส้นทางสัมพัทธ์ที่ระบุ

อาร์กิวเมนต์ : childPath String - เส้นทางสัมพันธ์ไปยังตำแหน่งของข้อมูลลูก

Return Value : RuleDataSnapshot - RuleDataSnapshot สำหรับตำแหน่งลูก

เส้นทางสัมพัทธ์อาจเป็นชื่อลูกธรรมดา (เช่น 'fred') หรือเส้นทางที่คั่นด้วยเครื่องหมายทับลึกกว่า (เช่น 'fred/name/first') หากตำแหน่งลูกไม่มีข้อมูล ระบบจะส่งคืน RuleDataSnapshot ที่ว่างเปล่า

ตัวอย่างนี้อนุญาตให้อ่านได้ก็ต่อเมื่อลูก isReadable ถูกตั้งค่าเป็นจริงในตำแหน่งที่กำลังอ่าน

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

พ่อแม่()

รับ RuleDataSnapshot สำหรับตำแหน่งหลัก

Return Value : RuleDataSnapshot - RuleDataSnapshot สำหรับตำแหน่งหลัก

หากอินสแตนซ์นี้อ้างถึงรากของฐานข้อมูลเรียลไทม์ Firebase ของคุณ อินสแตนซ์นั้นไม่มีพาเรนต์ และ parent() จะล้มเหลว ส่งผลให้นิพจน์กฎปัจจุบันถูกข้าม (เนื่องจากล้มเหลว)

ตัวอย่างนี้อนุญาตให้อ่านได้ก็ต่อเมื่อพี่น้อง isReadable ถูกตั้งค่าเป็นจริง

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

hasChild (เส้นทางลูก)

คืนค่าเป็นจริงหากมีรายการลูกที่ระบุอยู่

อาร์กิวเมนต์ : childPath String - เส้นทางสัมพันธ์ไปยังตำแหน่งของเด็กที่มีศักยภาพ

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

รับลำดับความสำคัญ()

รับลำดับความสำคัญของข้อมูลใน RuleDataSnapshot

ค่าส่งคืน : ( String , Number , Null ) - ลำดับความสำคัญของข้อมูลใน RuleDataSnapshot นี้

ตัวอย่างนี้ช่วยให้แน่ใจว่าข้อมูลใหม่ที่กำลังเขียนมีลำดับความสำคัญ

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

คือหมายเลข()

คืนค่าเป็นจริงหาก RuleDataSnapshot นี้มีค่าตัวเลข

ค่าส่งคืน : Boolean - true หากข้อมูลเป็นตัวเลข อย่างอื่น false

ตัวอย่างนี้ช่วยให้แน่ใจว่าข้อมูลใหม่ที่กำลังเขียนมี "อายุ" ย่อยที่มีค่าตัวเลข

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

isString()

คืนค่าเป็นจริงหาก RuleDataSnapshot นี้มีค่าสตริง

Return Value : Boolean - true หากข้อมูลเป็น String ; อย่างอื่น false

ตัวอย่างนี้ช่วยให้แน่ใจว่าข้อมูลใหม่ที่กำลังเขียนมี "ชื่อ" ลูกพร้อมค่าสตริง

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

isBoolean()

คืนค่าเป็นจริงหาก RuleDataSnapshot นี้มีค่าบูลีน

Return Value : Boolean - true หากข้อมูลเป็น Boolean อย่างอื่น false

ตัวอย่างนี้ช่วยให้แน่ใจว่าข้อมูลใหม่ที่กำลังเขียนมีลูก "ใช้งานอยู่" ที่มีค่าบูลีน

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

สตริง: คุณสมบัติ

ความยาว

ส่งกลับความยาวของสตริง

Return Value : Number - จำนวนอักขระในสตริง

ตัวอย่างนี้ต้องการให้สตริงมีอักขระอย่างน้อย 10 ตัว

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

สตริง: วิธีการ

มี (สตริงย่อย)

คืนค่าเป็นจริงหากสตริงมีสตริงย่อยที่ระบุ

อาร์กิวเมนต์ : substring String - สตริงย่อยที่จะค้นหา

ค่าส่งคืน : Boolean - true หากสตริงมีสตริงย่อยที่ระบุ อย่างอื่น false

ตัวอย่างนี้ต้องการให้ข้อมูลเป็นสตริงที่มี "@"

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

เริ่มต้นด้วย (สตริงย่อย)

คืนค่าเป็นจริงหากสตริงขึ้นต้นด้วยสตริงย่อยที่ระบุ

อาร์กิวเมนต์ : substring String - สตริงย่อยที่จะมองหาที่จุดเริ่มต้น

ค่าส่งคืน : Boolean - true หากสตริงมีสตริงย่อยที่ระบุ อย่างอื่น false

ตัวอย่างนี้อนุญาตให้เข้าถึงการอ่านหาก auth.token.identifier ขึ้นต้นด้วย "internal-"

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

สิ้นสุดด้วย (สตริงย่อย)

คืนค่าเป็นจริงหากสตริงลงท้ายด้วยสตริงย่อยที่ระบุ

อาร์กิวเมนต์ : substring String - สตริงย่อยที่จะค้นหาที่ส่วนท้าย

ค่าส่งคืน : Boolean - true หากสตริงลงท้ายด้วยสตริงย่อยที่ระบุ อย่างอื่น false

ตัวอย่างนี้อนุญาตให้เข้าถึงการอ่านหาก auth.token.identifier ลงท้ายด้วย "@company.com"

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

แทนที่ (สตริงย่อย, การแทนที่)

ส่งกลับสำเนาของสตริงที่มีอินสแตนซ์ทั้งหมดของสตริงย่อยที่ระบุแทนที่ด้วยสตริงการแทนที่ที่ระบุ

อาร์กิวเมนต์ : substring String - สตริงย่อยที่จะค้นหา replacement String - สตริงที่จะแทนที่สตริงย่อยด้วย

Return Value : String - สตริงใหม่หลังจากแทนที่สตริงย่อยด้วยการแทนที่

วิธี replace() แตกต่างเล็กน้อยจากวิธี replace() JavaScript โดยจะแทนที่อินสแตนซ์ทั้งหมดของสตริงย่อยที่ระบุด้วยสตริงการแทนที่ที่ระบุ ไม่ใช่แค่อินสแตนซ์แรก

เนื่องจากไม่อนุญาตให้ใช้จุดในคีย์ เราจึงต้องหลีกเลี่ยงสตริงด้วยจุดก่อนที่จะจัดเก็บ ตัวอย่างนี้จะเป็นกับที่อยู่อีเมล สมมติว่าเรามีรายการที่อยู่อีเมลที่อนุญาตพิเศษใน /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()"
      }
    }
  }
}

ถึงตัวพิมพ์เล็ก()

ส่งกลับสำเนาของสตริงที่แปลงเป็นตัวพิมพ์เล็ก

Return Value : String - สตริงที่แปลงเป็นตัวพิมพ์เล็ก

ตัวอย่างนี้อนุญาตให้เข้าถึงการอ่านหาก auth.token.identifier เป็นตัวพิมพ์เล็กทั้งหมดอยู่ภายใต้ /users

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

ถึงUpperCase()

ส่งกลับสำเนาของสตริงที่แปลงเป็นตัวพิมพ์ใหญ่

Return Value : String - สตริงที่แปลงเป็นตัวพิมพ์ใหญ่

ตัวอย่างนี้อนุญาตให้เข้าถึงการอ่านหาก auth.token.identifier เป็นตัวพิมพ์ใหญ่ทั้งหมดอยู่ภายใต้ /users

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

การแข่งขัน (regex)

คืนค่าเป็นจริงหากสตริงตรงกับลิเทอรัลของนิพจน์ทั่วไปที่ระบุ

ค่าส่งคืน : Boolean - true หากสตริงตรงกับลิเทอรัลของนิพจน์ทั่วไป regex อย่างอื่น false

ดู เอกสารกฎ regex ฉบับเต็ม

ผู้ประกอบการ

+ (เพิ่ม)

ใช้เพื่อเพิ่มตัวแปรหรือสำหรับการต่อสตริง

ตัวอย่างต่อไปนี้ช่วยให้แน่ใจว่าค่าใหม่จะเพิ่มค่าที่มีอยู่ทีละค่าเท่านั้น สิ่งนี้มีประโยชน์สำหรับการนำตัวนับไปใช้:

".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 ) เพื่อให้กฎประเมินเป็นจริง

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