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

การอ่านข้อมูลด้วย 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 และ รองรับคำขอทุกประเภท อาร์กิวเมนต์นี้อาจเป็นข้อมูลลับของแอป Firebase หรือ โทเค็นการตรวจสอบสิทธิ์ ตามที่อธิบายไว้ในผู้ใช้ในโปรเจ็กต์ Firebase ในตัวอย่างต่อไปนี้ เราส่งคำขอ GET ที่มี auth โดยที่ CREDENTIAL เป็นข้อมูลลับของแอป Firebase หรือ โทเค็นการตรวจสอบสิทธิ์: 

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

พิมพ์

การระบุ 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'

หมดเวลา

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

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

นอกจากนี้ เรายังกรองโหนดตามคีย์โดยใช้พารามิเตอร์ 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"

การกรองแบบซับซ้อน

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

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

พารามิเตอร์ 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 เพื่อจํากัดการค้นหาทั้ง 2 ด้าน ตัวอย่างต่อไปนี้ค้นหาไดโนเสาร์ทุกตัวที่ชื่อขึ้นต้นด้วย "b" 

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

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

กำลังประกอบรูปภาพเข้าด้วยกัน

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

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 แบบ

สั่งโดย

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

  1. เด็กที่มีค่า null สำหรับคีย์ย่อยที่ระบุจะต้องมาก่อน
  2. แท็กย่อยที่มีค่าเป็น false สำหรับคีย์ย่อยที่ระบุจะเกิดขึ้นในลำดับถัดไป ถ้า เด็กหลายคนมีค่าเป็น false และจัดเรียงแล้ว ในพจนานุกรมตามคีย์
  3. แท็กย่อยที่มีค่าเป็น true สำหรับคีย์ย่อยที่ระบุจะเกิดขึ้นในลำดับถัดไป ถ้า เด็กหลายคนมีค่า true และจัดเรียงแบบพจนานุกรมตาม
  4. เด็กที่มีค่าตัวเลขจะแสดงอยู่ถัดไปโดยเรียงลำดับจากน้อยไปหามาก หากมีเด็กหลายคน มีค่าตัวเลขเหมือนกันสำหรับโหนดย่อยที่ระบุ โดยจะจัดเรียงตามคีย์
  5. สตริงจะอยู่หลังตัวเลขและจัดเรียงแบบพจนานุกรมตามลำดับจากน้อยไปมาก ถ้ามีหลาย ย่อยมีค่าเดียวกันสำหรับโหนดย่อยที่ระบุ จะถูกเรียงลำดับ แบบพจนานุกรมตามคีย์
  6. ออบเจ็กต์อยู่ท้ายสุดและจัดเรียงแบบพจนานุกรมตามคีย์ในลำดับจากน้อยไปมาก
ผลลัพธ์ที่กรองแล้วจะแสดงโดยไม่เรียงลำดับ หากลำดับของข้อมูลมีความสำคัญ คุณควรจัดเรียงผลลัพธ์ในแอปพลิเคชันของคุณหลังจากที่ข้อมูลแสดงผลจาก Firebase

orderBy="$key"

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

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

orderBy="$value"

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

orderBy="$Priority"

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

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

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

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

ปลายทาง REST ของ Firebase รองรับ EventSource / โปรโตคอลกิจกรรมที่ส่งโดยเซิร์ฟเวอร์ ทำให้การสตรีมการเปลี่ยนแปลงไปยังสถานที่เดียวเป็นเรื่องง่าย ฐานข้อมูล Firebase

หากต้องการเริ่มต้นใช้งานสตรีมมิง เราจำเป็นต้องทำสิ่งต่อไปนี้

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

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

event: event name
data: JSON encoded data payload

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

ใส่ ข้อมูลที่เข้ารหัสด้วย JSON จะเป็นออบเจ็กต์ที่มี 2 คีย์ ได้แก่ เส้นทางและข้อมูล
เส้นทางจะชี้ไปยังตำแหน่งซึ่งสัมพันธ์กับ URL คำขอ
ไคลเอ็นต์ควรแทนที่ข้อมูลทั้งหมดในตำแหน่งนั้นในแคชด้วยข้อมูลที่ระบุในข้อความ
แพตช์ ข้อมูลที่เข้ารหัสด้วย JSON จะเป็นออบเจ็กต์ที่มี 2 คีย์ ได้แก่ เส้นทางและข้อมูล
เส้นทางจะชี้ไปยังตำแหน่งซึ่งสัมพันธ์กับ URL คำขอ
สำหรับแต่ละคีย์ของข้อมูล ไคลเอ็นต์ควรแทนที่คีย์ที่เกี่ยวข้องในแคชด้วยข้อมูลสำหรับคีย์นั้นในข้อความ
Keep-alive ข้อมูลสำหรับเหตุการณ์นี้ว่างเปล่า คุณไม่ต้องดำเนินการใดๆ
ยกเลิก ข้อมูลสำหรับเหตุการณ์นี้เป็นค่าว่าง
ระบบจะส่งเหตุการณ์นี้หากกฎความปลอดภัยของฐานข้อมูลเรียลไทม์ของ Firebase ทำให้การอ่านในตำแหน่งที่ขอไม่ได้รับอนุญาตอีกต่อไป
การตรวจสอบสิทธิ์_ถูกยกเลิก ข้อมูลสำหรับเหตุการณ์นี้เป็นสตริงที่ระบุว่าข้อมูลเข้าสู่ระบบหมดอายุแล้ว
ระบบจะส่งเหตุการณ์นี้เมื่อพารามิเตอร์การตรวจสอบสิทธิ์ที่ระบุไม่ถูกต้องอีกต่อไป

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

// 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