หน้านี้ได้รับการแปลโดย Cloud Translation API

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

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

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

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

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

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

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

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

auth คำขอตรวจสอบสิทธิ์อนุญาตการเข้าถึงข้อมูลที่ป้องกันโดย กฎฐานข้อมูลเรียลไทม์ของ Firebase และได้รับการสนับสนุนโดยคำขอทุกประเภท อาร์กิวเมนต์อาจเป็นความลับของแอป Firebase หรือโทเค็นการตรวจสอบสิทธิ์ ตามที่อธิบายไว้ใน Users in Firebase Projects ในตัวอย่างต่อไปนี้ เราจะส่งคำขอ GET พร้อมพารามิเตอร์การตรวจสอบสิทธิ์ CREDENTIAL auth ความลับของแอป 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'

โทรกลับ

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

<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 ไม่สามารถใช้กับพารามิเตอร์แบบสอบถาม "ข้อมูลการกรอง" ใด ๆ

หมดเวลา

ใช้สิ่งนี้เพื่อจำกัดระยะเวลาการอ่านในฝั่งเซิร์ฟเวอร์ หากคำขออ่านไม่เสร็จสิ้นภายในเวลาที่กำหนด คำขอจะสิ้นสุดลงด้วยข้อผิดพลาด 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 กับพารามิเตอร์ห้าตัวอื่นๆ: limitToFirst , limitToLast , startAt , endAt และ equalTo

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

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

เราสามารถกรองข้อมูลด้วยวิธีใดวิธีหนึ่งจากสามวิธี: โดย คีย์ ย่อย โดย คีย์ หรือตาม ค่า การสืบค้นเริ่มต้นด้วยหนึ่งในพารามิเตอร์เหล่านี้ จากนั้นต้องรวมกับพารามิเตอร์ต่อไปนี้อย่างน้อยหนึ่งรายการ: 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'

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

เพิ่มการจัดทำดัชนีลงในกฎฐานข้อมูลเรียลไทม์ของ Firebase : หากคุณกำลังใช้ orderBy ในแอป คุณจะต้องกำหนดคีย์ที่คุณจะจัดทำดัชนีผ่านกฎ . .indexOn ในกฎฐานข้อมูลเรียลไทม์ของ Firebase อ่านเอกสาร เกี่ยวกับกฎ .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 : หากคุณกำลังใช้ orderBy="$value" ในแอป คุณต้องเพิ่ม .value ให้กับกฎของคุณในดัชนีที่เหมาะสม อ่านเอกสาร เกี่ยวกับกฎ .indexOn สำหรับข้อมูลเพิ่มเติม

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

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

จำกัดแบบสอบถาม

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

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

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

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

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

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

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

แบบสอบถามช่วง

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

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

เราสามารถใช้ endAt เพื่อค้นหาไดโนเสาร์ทั้งหมดที่มีชื่อมาก่อน Pterodactyl lexicographically:

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

startAt และ endAt รวมอยู่ด้วย หมายความว่า "pterodactyl" จะตรงกับข้อความค้นหาด้านบน

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

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

อักขระ \uf8ff ที่ใช้ในแบบสอบถามด้านบนเป็นจุดโค้ดที่สูงมากในช่วง Unicode เนื่องจากอยู่หลังอักขระปกติส่วนใหญ่ใน Unicode เคียวรีจึงจับคู่ค่าทั้งหมดที่ขึ้นต้นด้วย a 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"

วิธีการสั่งซื้อข้อมูล

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

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

สั่งโดย

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

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

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

orderBy="$คีย์"

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

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

orderBy="$value"

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

orderBy="$ลำดับความสำคัญ"

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

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

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

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

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

ในการเริ่มต้นใช้งานการสตรีม เราต้องดำเนินการดังต่อไปนี้:

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

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

event: event name
data: JSON encoded data payload

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

ใส่	ข้อมูลที่เข้ารหัส JSON จะเป็นวัตถุที่มีสองคีย์: เส้นทางและ data เส้นทางชี้ไปยังตำแหน่งที่สัมพันธ์กับ URL คำขอ ไคลเอนต์ควรแทนที่ข้อมูลทั้งหมดที่ตำแหน่งนั้นในแคชด้วยข้อมูลที่ระบุในข้อความ
ปะ	ข้อมูลที่เข้ารหัส JSON จะเป็นวัตถุที่มีสองคีย์: เส้นทางและ data เส้นทางชี้ไปยังตำแหน่งที่สัมพันธ์กับ URL คำขอ สำหรับแต่ละคีย์ในข้อมูล ไคลเอนต์ควรแทนที่คีย์ที่เกี่ยวข้องในแคชด้วยข้อมูลสำหรับคีย์นั้นในข้อความ
ให้มีชีวิตอยู่	ข้อมูลสำหรับเหตุการณ์นี้เป็นโมฆะ ไม่จำเป็นต้องดำเนินการใดๆ
ยกเลิก	ข้อมูลสำหรับเหตุการณ์นี้เป็นโมฆะ เหตุการณ์นี้จะถูกส่งไปหากกฎฐานข้อมูลเรียลไทม์ของ Firebase ทำให้การอ่านที่ตำแหน่งที่ร้องขอไม่ได้รับอนุญาตอีกต่อไป
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