หน้านี้ได้รับการแปลโดย 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

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

พารามิเตอร์คำขอ 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 เพื่อรวมคำตอบใน JavaScript ฟังก์ชัน Callback เพิ่ม 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 Primitive (สตริง, ตัวเลข, หรือบูลีน) ระบบจะแสดงผลค่า หากสแนปชอตข้อมูลที่ตำแหน่งเป็น 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 กับพารามิเตอร์อื่นๆ อีก 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 ยังรองรับคำค้นหาที่จัดเรียงตามระดับย่อยที่ซ้อนกันอยู่ระดับล่าง แทนที่จะเป็นระดับย่อยลงไปอีก 1 ระดับ วิธีนี้มีประโยชน์หากคุณใส่ข้อมูลที่ฝังลึกไว้แบบนี้

{
  "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 เราพบข้อมูลทั้งสอง ไดโนเสาร์ที่หนักที่สุด:

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 เพื่อค้นหาไดโนเสาร์ทุกชนิดที่มีชื่อมาก่อนเทอโรแดคทิล แบบพจนานุกรม:

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

รวม startAt และ endAt ไว้ด้วย หมายถึง "เทอโรแดคทิล" จะตรงกับ คำค้นหาข้างต้น

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

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

อักขระ \uf8ff ที่ใช้ในข้อความค้นหาด้านบนเป็นจุดรหัสที่สูงมากใน ช่วงของ 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 / โปรโตคอลกิจกรรมที่ส่งโดยเซิร์ฟเวอร์ ทำให้การสตรีมการเปลี่ยนแปลงไปยังสถานที่เดียวเป็นเรื่องง่าย ฐานข้อมูล 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 คีย์ ได้แก่ เส้นทางและข้อมูล เส้นทางจะชี้ไปยังตำแหน่งซึ่งสัมพันธ์กับ URL คำขอ สำหรับแต่ละคีย์ของข้อมูล ไคลเอ็นต์ควรแทนที่คีย์ที่เกี่ยวข้องในแคชด้วยข้อมูลสำหรับคีย์นั้นในข้อความ
Keep-alive	ข้อมูลสำหรับเหตุการณ์นี้ว่างเปล่า คุณไม่ต้องดำเนินการใดๆ
ยกเลิก	ข้อมูลสำหรับเหตุการณ์นี้เป็นค่าว่าง ระบบจะส่งกิจกรรมนี้หาก Firebase Realtime Database Security Rules ทำให้ไม่อนุญาตให้อ่านในตำแหน่งที่ขออีกต่อไป
การตรวจสอบสิทธิ์_ถูกยกเลิก	ข้อมูลสำหรับเหตุการณ์นี้เป็นสตริงที่ระบุว่าข้อมูลเข้าสู่ระบบหมดอายุแล้ว ระบบจะส่งเหตุการณ์นี้เมื่อพารามิเตอร์การตรวจสอบสิทธิ์ที่ระบุไม่ถูกต้องอีกต่อไป

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

// 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 ของบุคคลที่สามเกี่ยวกับ REST และ Streaming API ของ Firebase