Google ใช้เทคโนโลยี AI เพื่อแปลเนื้อหาเป็นภาษาที่คุณต้องการ การแปลโดย AI อาจมีข้อผิดพลาด

กำลังดึงข้อมูล

การอ่านข้อมูลด้วย GET

เราสามารถอ่านข้อมูลจากฐานข้อมูล Firebase ได้โดยส่งคำขอ GET ไปยังปลายทาง URL ของฐานข้อมูล มาต่อกันที่ตัวอย่างบล็อกของเราจากส่วนก่อนหน้าและอ่านข้อมูลบล็อกโพสต์ทั้งหมดกัน

curl 'https://docs-examples.firebaseio.com/fireblog/posts.json?print=pretty'

คำขอที่สำเร็จจะแสดงด้วยรหัสสถานะ HTTP 200 OK และการตอบกลับจะมีข้อมูลที่เรากำลังดึงข้อมูล

การเพิ่มพารามิเตอร์ URI

REST API ยอมรับพารามิเตอร์การค้นหาหลายรายการเมื่ออ่านข้อมูลจากฐานข้อมูล Firebase พารามิเตอร์ที่ใช้กันโดยทั่วไปมีดังนี้ ดูรายการทั้งหมดได้ในเอกสารอ้างอิง REST API

การตรวจสอบสิทธิ์

พารามิเตอร์คำขอ auth ช่วยให้เข้าถึงข้อมูลที่ได้รับการปกป้องโดย Firebase Realtime Database Security Rules และคำขอทุกประเภทจะรองรับพารามิเตอร์นี้ อาร์กิวเมนต์อาจเป็นข้อมูลลับของแอป Firebase หรือโทเค็นการตรวจสอบสิทธิ์ตามที่อธิบายไว้ในผู้ใช้ในโปรเจ็กต์ Firebase ในตัวอย่างต่อไปนี้ เราจะส่งคำขอ GET พร้อมพารามิเตอร์ auth โดยที่ CREDENTIAL เป็นรหัสลับของแอป Firebase หรือโทเค็นการตรวจสอบสิทธิ์

curl 'https://docs-examples.firebaseio.com/auth-example.json?auth=CREDENTIAL'

หากมีการตั้งค่าแฟล็ก debug ของโทเค็น คุณจะดูข้อมูลการแก้ไขข้อบกพร่องได้ในส่วนหัว X-Firebase-Auth-Debug ของการตอบกลับ

พิมพ์

การระบุ print=pretty จะแสดงผลข้อมูลในรูปแบบที่มนุษย์อ่านได้

curl 'https://docs-examples.firebaseio.com/fireblog/posts.json?print=pretty'

การระบุ print=silent จะแสดงผล 204 No Content เมื่อดำเนินการสำเร็จ

curl 'https://docs-examples.firebaseio.com/fireblog/posts.json?print=silent'

callback

หากต้องการเรียกใช้ REST จากเว็บเบราว์เซอร์ข้ามโดเมน คุณสามารถใช้ JSONP เพื่อรวมการตอบกลับไว้ในฟังก์ชัน Callback ของ JavaScript เพิ่ม callback= เพื่อให้ REST API รวมข้อมูลที่แสดงผลในฟังก์ชัน Callback ที่คุณระบุ เช่น

<script>
  function gotData(data) {
    console.log(data);
  }
</script>
<script src="https://docs-examples.firebaseio.com/fireblog/posts.json?callback=gotData">

ตื้น

ฟีเจอร์ขั้นสูงนี้ออกแบบมาเพื่อช่วยให้คุณทำงานกับชุดข้อมูลขนาดใหญ่ได้โดยไม่ต้องดาวน์โหลดทุกอย่าง หากต้องการใช้ ให้เพิ่ม shallow=true เป็นพารามิเตอร์ ซึ่งจะจำกัดความลึกของข้อมูลที่แสดงผล หากข้อมูลที่ตำแหน่งเป็น JSON แบบพื้นฐาน (สตริง ตัวเลข หรือบูลีน) ระบบจะแสดงค่าของข้อมูลนั้น หากสแนปชอตข้อมูลที่ตำแหน่งเป็นออบเจ็กต์ JSON ระบบจะตัดค่าของแต่ละคีย์ให้เหลือ true ตัวอย่างเช่น การใช้ข้อมูลด้านล่าง

{
  "message": {
    "user": {
      "name": "Chris"
    },
    "body": "Hello!"
  }
}

// A request to /message.json?shallow=true
// would return the following:
{
  "user": true,
  "body": true
}

// A request to /message/body.json?shallow=true
// would simply return:
"Hello!"

ลองใช้คำขอ curl ต่อไปนี้

curl 'https://docs-examples.firebaseio.com/rest/retrieving-data.json?shallow=true&print=pretty'

shallow ไม่สามารถใช้กับพารามิเตอร์การค้นหา "การกรองข้อมูล"

timeout

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

ระบุ timeouts โดยใช้รูปแบบต่อไปนี้ 3ms, 3s หรือ 3min พร้อมตัวเลขและหน่วย หากไม่ได้ระบุ ระบบจะใช้ timeout สูงสุด 15min หาก timeout ไม่เป็นค่าบวกหรือเกินจำนวนสูงสุด ระบบจะปฏิเสธคำขอพร้อมข้อผิดพลาด HTTP 400 ในตัวอย่างต่อไปนี้ คำขอ GET มี timeout เป็น 10 วินาที

curl 'https://docs-examples.firebaseio.com/rest/retrieving-data.json?timeout=10s'

การกรองข้อมูล

เราสามารถสร้างการค้นหาเพื่อกรองข้อมูลตามปัจจัยต่างๆ ได้ ในการเริ่มต้น ให้ระบุวิธีที่คุณต้องการกรองข้อมูลโดยใช้พารามิเตอร์ orderBy จากนั้นรวม orderBy เข้ากับพารามิเตอร์อื่นๆ อีก 5 รายการ ได้แก่ limitToFirst, limitToLast, startAt, endAt และ equalTo

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

{
  "lambeosaurus": {
    "height": 2.1,
    "length": 12.5,
    "weight": 5000
  },
  "stegosaurus": {
    "height": 4,
    "length": 9,
    "weight": 2500
  }
}

เราสามารถกรองข้อมูลได้ 3 วิธี ได้แก่ ตามคีย์ย่อย ตามคีย์ หรือตามค่า การค้นหาจะเริ่มต้นด้วยพารามิเตอร์อย่างใดอย่างหนึ่งต่อไปนี้ และต้องรวมกับพารามิเตอร์อย่างน้อย 1 รายการ ได้แก่ startAt, endAt, limitToFirst, limitToLast หรือ equalTo

การกรองตามคีย์ย่อยที่ระบุ

เราสามารถกรองโหนดตามคีย์ย่อยทั่วไปได้โดยส่งคีย์นั้นไปยังพารามิเตอร์ orderBy ตัวอย่างเช่น หากต้องการดึงข้อมูลไดโนเสาร์ทั้งหมดที่มีความสูงมากกว่า 3 เราสามารถทำดังนี้

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="height"&startAt=3&print=pretty'

โหนดที่ไม่มีคีย์ย่อยที่เรากำลังกรองจะจัดเรียงด้วยค่า null ดูรายละเอียดเกี่ยวกับวิธีจัดเรียงข้อมูลได้ที่หัวข้อวิธีจัดเรียงข้อมูล

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

{
  "lambeosaurus": {
    "dimensions": {
      "height" : 2.1,
      "length" : 12.5,
      "weight": 5000
    }
  },
  "stegosaurus": {
    "dimensions": {
      "height" : 4,
      "length" : 9,
      "weight" : 2500
    }
  }
}

หากต้องการค้นหาความสูงในตอนนี้ เราจะใช้เส้นทางแบบเต็มไปยังออบเจ็กต์แทนคีย์เดียว ดังนี้

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="dimensions/height"&startAt=3&print=pretty'

การค้นหาจะกรองได้ครั้งละ 1 คีย์เท่านั้น การใช้พารามิเตอร์ orderBy หลายครั้งในคำขอเดียวกันจะทำให้เกิดข้อผิดพลาด

เพิ่มการจัดทำดัชนีลงใน Firebase Realtime Database Security Rules: หากใช้ orderBy ในแอป คุณต้องกำหนดคีย์ที่จะจัดทำดัชนีผ่านกฎ .indexOn ใน Firebase Realtime Database Security Rules อ่านเอกสารประกอบเกี่ยวกับกฎ .indexOn เพื่อดูข้อมูลเพิ่มเติม

การกรองตามคีย์

นอกจากนี้ เรายังกรองโหนดตามคีย์ได้โดยใช้พารามิเตอร์ orderBy="$key" ตัวอย่างต่อไปนี้จะดึงข้อมูลไดโนเสาร์ทั้งหมดที่มีชื่อขึ้นต้นด้วยตัวอักษร a ถึง m

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="$key"&startAt="a"&endAt="m"&print=pretty'

การกรองตามค่า

เราสามารถกรองโหนดตามค่าของคีย์ย่อยได้โดยใช้พารามิเตอร์ orderBy="$value" สมมติว่าไดโนเสาร์กำลังแข่งขันกีฬาไดโนเสาร์และเรากำลังติดตามคะแนนของไดโนเสาร์ในรูปแบบต่อไปนี้

{
  "scores": {
    "bruhathkayosaurus": 55,
    "lambeosaurus": 21,
    "linhenykus": 80,
    "pterodactyl": 93,
    "stegosaurus": 5,
    "triceratops": 22
  }
}

หากต้องการดึงข้อมูลไดโนเสาร์ทั้งหมดที่มีคะแนนสูงกว่า 50 เราสามารถส่งคำขอต่อไปนี้ได้

curl 'https://dinosaur-facts.firebaseio.com/scores.json?orderBy="$value"&startAt=50&print=pretty'

ดูวิธีจัดเรียงข้อมูลเพื่อดูคำอธิบายเกี่ยวกับวิธีจัดเรียงค่า null, บูลีน, สตริง และออบเจ็กต์เมื่อใช้ orderBy="$value"

เพิ่มการจัดทำดัชนีลงใน Firebase Realtime Database Security Rules: หากใช้ orderBy="$value" ในแอป คุณต้องเพิ่ม .value ลงในกฎที่ดัชนีที่เหมาะสม อ่านเอกสารประกอบเกี่ยวกับกฎ .indexOn เพื่อดูข้อมูลเพิ่มเติม

การกรองที่ซับซ้อน

เราสามารถรวมพารามิเตอร์หลายรายการเพื่อสร้างการค้นหาที่ซับซ้อนมากขึ้นได้

จำกัดคำค้นหา

พารามิเตอร์ limitToFirst และ limitToLast ใช้เพื่อกำหนดจำนวนบุตรหลานสูงสุดที่จะรับข้อมูล หากเราตั้งค่าขีดจำกัดไว้ที่ 100 เราจะได้รับรายการย่อยที่ตรงกันไม่เกิน 100 รายการเท่านั้น หากเรามีข้อความที่จัดเก็บไว้ในฐานข้อมูลน้อยกว่า 100 ข้อความ เราจะได้รับข้อความย่อยทั้งหมด อย่างไรก็ตาม หากเรามีข้อความมากกว่า 100 ข้อความ เราจะได้รับข้อมูลสำหรับข้อความเพียง 100 ข้อความเท่านั้น ซึ่งจะเป็นข้อความที่เรียงลำดับ 100 รายการแรกหากเราใช้ limitToFirst หรือข้อความที่เรียงลำดับ 100 รายการสุดท้ายหากเราใช้ limitToLast

เมื่อใช้ฐานข้อมูลข้อเท็จจริงเกี่ยวกับไดโนเสาร์และ orderBy เราจะค้นหาไดโนเสาร์ที่หนักที่สุด 2 ตัวได้ดังนี้

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="weight"&limitToLast=2&print=pretty'

ในทำนองเดียวกัน เราสามารถค้นหาไดโนเสาร์ที่เตี้ยที่สุด 2 ตัวได้โดยใช้ limitToFirst ดังนี้

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="height"&limitToFirst=2&print=pretty'

นอกจากนี้ เรายังจำกัดการค้นหาด้วย orderBy="$value" ได้ด้วย หากต้องการสร้างลีดเดอร์บอร์ดที่มีผู้เข้าแข่งขันกีฬาไดโนเสาร์ที่ได้คะแนนสูงสุด 3 อันดับแรก เราสามารถทำดังนี้

curl 'https://dinosaur-facts.firebaseio.com/scores.json?orderBy="$value"&limitToLast=3&print=pretty'

คำค้นหาช่วง

การใช้ startAt, endAt และ equalTo ช่วยให้เราเลือกจุดเริ่มต้นและจุดสิ้นสุดที่กำหนดเองสำหรับการค้นหาได้ ตัวอย่างเช่น หากต้องการค้นหาไดโนเสาร์ทั้งหมดที่มีความสูงอย่างน้อย 3 เมตร เราสามารถรวม orderBy และ startAt เข้าด้วยกันได้ ดังนี้

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="height"&startAt=3&print=pretty'

เราสามารถใช้ endAt เพื่อค้นหาไดโนเสาร์ทั้งหมดที่มีชื่อขึ้นต้นก่อน Pterodactyl ตามพจนานุกรมได้

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="$key"&endAt="pterodactyl"&print=pretty'

startAt และ endAt เป็นแบบรวม ซึ่งหมายความว่า "pterodactyl" จะตรงกับคำค้นหาด้านบน

เราสามารถรวม startAt และ endAt เพื่อจำกัดทั้ง 2 ด้านของคำค้นหาได้ ตัวอย่างต่อไปนี้จะค้นหาไดโนเสาร์ทั้งหมดที่มีชื่อขึ้นต้นด้วยตัวอักษร "b"

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="$key"&startAt="b"&endAt="b\uf8ff"&print=pretty'

อักขระ \uf8ff ที่ใช้ในคำค้นหาด้านบนเป็น Code Point ที่สูงมากในช่วง Unicode เนื่องจากอักขระนี้อยู่หลังอักขระปกติส่วนใหญ่ใน Unicode คำค้นหาจึงจับคู่กับค่าทั้งหมดที่ขึ้นต้นด้วย b

การค้นหาช่วงยังมีประโยชน์เมื่อคุณต้องการแบ่งหน้าข้อมูล

สรุปข้อมูลทั้งหมด

เราสามารถรวมเทคนิคทั้งหมดเหล่านี้เพื่อสร้างการค้นหาที่ซับซ้อนได้ ตัวอย่างเช่น คุณอาจต้องการค้นหาชื่อไดโนเสาร์ทั้งหมดที่มีความสูงน้อยกว่าหรือเท่ากับไดโนเสาร์ชนิดโปรดของเราอย่างสเตโกซอรัส

MY_FAV_DINO_HEIGHT=`curl "https://dinosaur-facts.firebaseio.com/dinosaurs/stegosaurus/height.json"`
curl "https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy=\"height\"&endAt=${MY_FAV_DINO_HEIGHT}&print=pretty"

วิธีจัดเรียงข้อมูล

ส่วนนี้จะอธิบายวิธีจัดเรียงข้อมูลเมื่อใช้พารามิเตอร์การกรองทั้ง 3 รายการ

REST API แสดงผลลัพธ์ที่ไม่ได้จัดเรียง: โปรแกรมแปล JSON ไม่บังคับใช้การจัดเรียงใดๆ กับชุดผลลัพธ์ แม้ว่าจะใช้ orderBy ร่วมกับ startAt, endAt, limitToFirst หรือ limitToLast เพื่อแสดงชุดย่อยของข้อมูลได้ แต่ผลลัพธ์ที่แสดงจะไม่ได้รับการจัดเรียง ดังนั้น คุณอาจต้องจัดเรียงผลลัพธ์ด้วยตนเองหากการจัดลำดับมีความสำคัญ

orderBy

เมื่อใช้ orderBy กับชื่อของคีย์ย่อย ข้อมูลที่มีคีย์ย่อยที่ระบุจะเรียงลำดับดังนี้

รายการย่อยที่มีค่า null สำหรับคีย์ย่อยที่ระบุจะแสดงก่อน
ตามด้วยรายการย่อยที่มีค่า false สำหรับคีย์ย่อยที่ระบุ หากโหนดบุตรหลานหลายโหนดมีค่าเป็น false ระบบจะจัดเรียงโหนดเหล่านั้นตามพจนานุกรมตามคีย์
ตามด้วยรายการย่อยที่มีค่า true สำหรับคีย์ย่อยที่ระบุ หากโหนดบุตรหลานหลายโหนดมีค่าเป็น true ระบบจะจัดเรียงตามพจนานุกรมตามคีย์
ตามด้วยรายการย่อยที่มีค่าตัวเลข โดยจัดเรียงจากน้อยไปมาก หากโหนดย่อยหลายโหนดมีค่าตัวเลขเดียวกันสำหรับโหนดย่อยที่ระบุ ระบบจะจัดเรียงตามคีย์
สตริงจะอยู่หลังตัวเลข และจัดเรียงตามพจนานุกรมจากน้อยไปมาก หากโหนดย่อยหลายโหนดมีค่าเดียวกันสำหรับโหนดย่อยที่ระบุ ระบบจะจัดเรียงตามลำดับพจนานุกรมตามคีย์
ออบเจ็กต์จะอยู่ท้ายสุด และจัดเรียงตามพจนานุกรมตามคีย์จากน้อยไปมาก

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

orderBy="$key"

เมื่อใช้พารามิเตอร์ orderBy="$key" เพื่อจัดเรียงข้อมูล ระบบจะแสดงผลข้อมูลตามลำดับจากน้อยไปมากตามคีย์ดังนี้ โปรดทราบว่าคีย์ต้องเป็นสตริงเท่านั้น

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

orderBy="$value"

เมื่อใช้พารามิเตอร์ orderBy="$value" เพื่อจัดเรียงข้อมูล ระบบจะจัดเรียงรายการย่อยตามค่าของรายการนั้นๆ เกณฑ์การจัดลำดับจะเหมือนกับข้อมูลที่จัดลำดับตามคีย์ย่อย ยกเว้นว่าจะใช้ค่าของโหนดแทนค่าของคีย์ย่อยที่ระบุ

orderBy="$priority"

เมื่อใช้พารามิเตอร์ orderBy="$priority" เพื่อจัดเรียงข้อมูล ลำดับของรายการย่อยจะกำหนดโดยลำดับความสำคัญและคีย์ ดังนี้ โปรดทราบว่าค่าลำดับความสำคัญต้องเป็นตัวเลขหรือสตริงเท่านั้น

กล้องย่อยที่ไม่มีลำดับความสำคัญ (ค่าเริ่มต้น) จะแสดงก่อน
บุตรหลานที่มีตัวเลขเป็นลำดับความสำคัญจะแสดงเป็นลำดับถัดไป โดยจะจัดเรียงตามตัวเลขตามลำดับความสำคัญจากน้อยไปมาก
รายการย่อยที่มีสตริงเป็นลำดับความสำคัญจะอยู่ท้ายสุด โดยจะจัดเรียงตามลำดับพจนานุกรมตามลำดับความสำคัญ
เมื่อใดก็ตามที่รายการย่อย 2 รายการมีลำดับความสำคัญเท่ากัน (รวมถึงไม่มีลำดับความสำคัญ) ระบบจะจัดเรียงตามคีย์ คีย์ที่เป็นตัวเลขจะแสดงก่อน (จัดเรียงตามตัวเลข) ตามด้วยคีย์ที่เหลือ (จัดเรียงตามพจนานุกรม)

ดูข้อมูลเพิ่มเติมเกี่ยวกับลำดับความสำคัญได้ในเอกสารอ้างอิง API

สตรีมมิงจาก REST API

ปลายทาง REST ของ Firebase รองรับโปรโตคอล EventSource / Server-Sent Events ซึ่งช่วยให้สตรีมการเปลี่ยนแปลงไปยังตำแหน่งเดียวในฐานข้อมูล Firebase ได้อย่างง่ายดาย

หากต้องการเริ่มต้นใช้งานสตรีมมิง เราจะต้องดำเนินการดังนี้

ตั้งค่าส่วนหัว Accept ของไคลเอ็นต์เป็น text/event-stream
ปฏิบัติตามการเปลี่ยนเส้นทาง HTTP โดยเฉพาะรหัสสถานะ HTTP 307
ใส่พารามิเตอร์การค้นหา auth หากตำแหน่งฐานข้อมูล Firebase ต้องได้รับสิทธิ์ในการอ่าน

ในทางกลับกัน เซิร์ฟเวอร์จะส่งเหตุการณ์ที่มีชื่อเป็นสถานะของข้อมูลที่ URL ที่ขอเปลี่ยนแปลง โครงสร้างของข้อความเหล่านี้เป็นไปตามโปรโตคอล EventSource ดังนี้

event: event name
data: JSON encoded data payload

เซิร์ฟเวอร์อาจส่งเหตุการณ์ต่อไปนี้

ใส่	ข้อมูลที่เข้ารหัส JSON จะเป็นออบเจ็กต์ที่มีคีย์ 2 รายการ ได้แก่ path และ data path จะชี้ไปยังตำแหน่งที่สัมพันธ์กับ URL คำขอ ไคลเอ็นต์ควรแทนที่ข้อมูลทั้งหมดที่ตำแหน่งนั้นในแคชด้วยข้อมูลที่ระบุไว้ในข้อความ
แพตช์	ข้อมูลที่เข้ารหัส JSON จะเป็นออบเจ็กต์ที่มีคีย์ 2 รายการ ได้แก่ path และ data path จะชี้ไปยังตำแหน่งที่สัมพันธ์กับ URL คำขอ สำหรับคีย์แต่ละรายการใน data ไคลเอ็นต์ควรแทนที่คีย์ที่เกี่ยวข้องในแคชด้วยข้อมูลสำหรับคีย์นั้นในข้อความ
Keep-alive	ข้อมูลสำหรับเหตุการณ์นี้เป็นค่าว่าง คุณไม่ต้องดำเนินการใดๆ
ยกเลิก	ข้อมูลสำหรับเหตุการณ์นี้เป็นค่าว่าง ระบบจะส่งเหตุการณ์นี้หาก Firebase Realtime Database Security Rules ทำให้ไม่ได้รับอนุญาตให้อ่านที่ตำแหน่งที่ขออีกต่อไป
auth_revoked	ข้อมูลสำหรับเหตุการณ์นี้คือสตริงที่ระบุว่าข้อมูลเข้าสู่ระบบหมดอายุแล้ว ระบบจะส่งเหตุการณ์นี้เมื่อพารามิเตอร์การตรวจสอบสิทธิ์ที่ระบุไม่ถูกต้องอีกต่อไป

ด้านล่างนี้คือตัวอย่างชุดเหตุการณ์ที่เซิร์ฟเวอร์อาจส่ง

// Set your entire cache to {"a": 1, "b": 2}
event: put
data: {"path": "/", "data": {"a": 1, "b": 2}}


// Put the new data in your cache under the key 'c', so that the complete cache now looks like:
// {"a": 1, "b": 2, "c": {"foo": true, "bar": false}}
event: put
data: {"path": "/c", "data": {"foo": true, "bar": false}}


// For each key in the data, update (or add) the corresponding key in your cache at path /c,
// for a final cache of: {"a": 1, "b": 2, "c": {"foo": 3, "bar": false, "baz": 4}}
event: patch
data: {"path": "/c", "data": {"foo": 3, "baz": 4}}

หากคุณใช้ Go ให้ดู Firego ซึ่งเป็น Wrapper ของบุคคลที่สามสำหรับ Firebase REST และ Streaming API