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

ทริกเกอร์ฐานข้อมูลเรียลไทม์

ในวงจรชีวิตทั่วไป ฟังก์ชัน Firebase Realtime Database ดำเนินการต่อไปนี้:

รอการเปลี่ยนแปลงเส้นทางฐานข้อมูลเรียลไทม์เฉพาะ
ทริกเกอร์เมื่อมีเหตุการณ์เกิดขึ้นและดำเนินการตามหน้าที่
รับวัตถุข้อมูลที่มีภาพรวมของข้อมูลที่เก็บไว้ที่เส้นทางนั้น

คุณสามารถทริกเกอร์ฟังก์ชันเพื่อตอบสนองต่อการเขียน การสร้าง การอัปเดต หรือการลบโหนดฐานข้อมูลใน Firebase Realtime Database

เรียกใช้ฟังก์ชันในการเปลี่ยนแปลงฐานข้อมูลเรียลไทม์ของ Firebase

ใช้แพ็กเกจย่อย firebase-functions/v2/database เพื่อสร้างฟังก์ชันที่จัดการเหตุการณ์ Firebase Realtime Database ในการควบคุมเวลาที่ทริกเกอร์ฟังก์ชัน ให้ระบุตัวจัดการเหตุการณ์หนึ่งตัว และระบุพาธฐานข้อมูลเรียลไทม์ที่จะคอยฟังเหตุการณ์

การตั้งค่าตำแหน่งฟังก์ชัน

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

จัดการเหตุการณ์ฐานข้อมูลเรียลไทม์

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

มีตัวจัดการเหล่านี้สำหรับการตอบสนองต่อเหตุการณ์ฐานข้อมูลเรียลไทม์:

onValueWritten() เรียกใช้เมื่อข้อมูลถูกเขียนในฐานข้อมูลเรียลไทม์เท่านั้น
onValueCreated() จะทำงานเมื่อมีการสร้างข้อมูลใน Realtime Database เท่านั้น
onValueUpdated() จะทำงานเมื่อมีการอัปเดตข้อมูลในฐานข้อมูลเรียลไทม์เท่านั้น
onValueDeleted() เรียกใช้เมื่อข้อมูลถูกลบในฐานข้อมูลเรียลไทม์เท่านั้น

ระบุตัวอย่างและเส้นทาง

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

ตัวอย่างเช่น ใช้ onValueWritten() เพื่ออธิบาย:

# All Realtime Database instances in default function region us-central1 at path "/user/{uid}"
# There must be at least one Realtime Database present in us-central1.
const onwrittenfunctiondefault = onValueWritten("/user/{uid}", (event) => {
  // …
});

# Instance named "my-app-db-2", at path "/user/{uid}".
# The "my-app-db-2" instance must exist in this region.
const onwrittenfunctioninstance = onValueWritten(
  {
    ref: "/user/{uid}",
    instance: "my-app-db-2"
    // This example assumes us-central1, but to set location:
    // region: "europe-west1"
  },
  (event) => {
    // …
  }
);

# Instance with "my-app-db-" prefix, at path "/user/{uid}", where uid ends with @gmail.com.
# There must be at least one Realtime Database with "my-app-db-*" prefix in this region.
const onwrittenfunctioninstance = onValueWritten(
  {
    ref: "/user/{uid=*@gmail.com}",
    instance: "my-app-db-*"
    // This example assumes us-central1, but to set location:
    // region: "europe-west1"
  },
  (event) => {
    // …
  }
);

พารามิเตอร์เหล่านี้กำหนดให้ฟังก์ชันของคุณจัดการกับการเขียนที่เส้นทางเฉพาะภายในอินสแตนซ์ฐานข้อมูลเรียลไทม์

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

 /foo/bar
 /foo/bar/baz/really/deep/path

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

การใช้สัญลักษณ์แทนและการจับภาพ

คุณสามารถใช้ {key} , {key=*} , {key=prefix*} , {key=*suffix} เพื่อจับภาพ * , prefix* , *suffix สำหรับสัญลักษณ์ตัวแทนกลุ่มเดียว หมายเหตุ: ** หมายถึงสัญลักษณ์แทนหลายกลุ่ม ซึ่ง RTDB ไม่รองรับ โปรดดู ทำความเข้าใจรูปแบบพาธ

สัญลักษณ์แทนเส้นทาง คุณสามารถระบุส่วนประกอบพาธเป็นไวด์การ์ดได้:

ใช้เครื่องหมายดอกจัน * . ตัวอย่างเช่น foo/* จับคู่ระดับย่อยของลำดับชั้นของโหนดที่ต่ำกว่า foo/ หนึ่งระดับ
การใช้กลุ่มที่มีเครื่องหมายดอกจัน * ตัวอย่างเช่น foo/app*-us จะจับคู่ส่วนย่อยด้านล่าง foo/ ที่มีคำนำหน้า app และ -us ต่อท้าย

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

{
  "foo": {
    "hello": "world",
    "firebase": "functions"
  }
}

จับคู่เส้นทาง "/foo/*" สองครั้ง: อีกครั้งกับ "hello": "world" และอีกครั้งด้วย "firebase": "functions"

การจับภาพเส้นทาง คุณสามารถจับเส้นทางที่ตรงกันเป็นตัวแปรที่มีชื่อเพื่อใช้ในโค้ดฟังก์ชันของคุณ (เช่น /user/{uid} , /user/{uid=*-us} )

ค่าของตัวแปรการดักจับมีอยู่ภายในอ็อบเจ็กต์ ฐานข้อมูลฐานข้อมูลเหตุการณ์พารามิเตอร์ ของฟังก์ชันของคุณ

การใช้สัญลักษณ์แทนอินสแตนซ์ คุณยังสามารถระบุส่วนประกอบอินสแตนซ์โดยใช้สัญลักษณ์แทน สัญลักษณ์แทนอินสแตนซ์สามารถมีคำนำหน้า คำต่อท้าย หรือทั้งสองอย่าง (เช่น my-app-*-prod )

สัญลักษณ์ตัวแทนและการอ้างอิงการจับภาพ

ด้วย Cloud Functions (รุ่นที่ 2) และฐานข้อมูลเรียลไทม์ คุณจะสามารถใช้รูปแบบเมื่อระบุ ref และ instance แต่ละอินเทอร์เฟซทริกเกอร์จะมีตัวเลือกต่อไปนี้สำหรับการกำหนดขอบเขตของฟังก์ชัน:

`ref`	การระบุ `instance` สแตนซ์	พฤติกรรม
โสด ( `/foo/bar` )	ไม่ระบุ	ตัวจัดการขอบเขตไปยังอินสแตนซ์ทั้งหมดในพื้นที่ฟังก์ชัน
โสด ( `/foo/bar` )	เดี่ยว ( `'my-new-db'` )	ตัวจัดการขอบเขตไปยังอินสแตนซ์เฉพาะในพื้นที่ฟังก์ชัน
โสด ( `/foo/bar` )	รูปแบบ ( `'inst-prefix*'` )	ตัวจัดการขอบเขตไปยังอินสแตนซ์ทั้งหมดที่ตรงกับรูปแบบในพื้นที่ของฟังก์ชัน
รูปแบบ ( `/foo/{bar}` )	ไม่ระบุ	ตัวจัดการขอบเขตไปยังอินสแตนซ์ทั้งหมดในพื้นที่ฟังก์ชัน
รูปแบบ ( `/foo/{bar}` )	เดี่ยว ( `'my-new-db'` )	ตัวจัดการขอบเขตไปยังอินสแตนซ์เฉพาะในพื้นที่ฟังก์ชัน
รูปแบบ ( `/foo/{bar}` )	รูปแบบ ( `'inst-prefix*'` )	ตัวจัดการขอบเขตไปยังอินสแตนซ์ทั้งหมดที่ตรงกับรูปแบบในพื้นที่ของฟังก์ชัน

จัดการข้อมูลเหตุการณ์

เมื่อจัดการเหตุการณ์ฐานข้อมูลเรียลไทม์ อ็อบเจ็กต์ข้อมูลที่ส่งคืนคือ DataSnapshot

สำหรับเหตุการณ์ onValueWritten หรือ onValueUpdated พารามิเตอร์แรกคือ Change object ที่มีสแน็ปช็อตสองภาพที่แสดงถึงสถานะข้อมูลก่อนและหลังเหตุการณ์ทริกเกอร์

สำหรับเหตุการณ์ onValueCreated และ onValueDeleted อ็อบเจ็กต์ข้อมูลที่ส่งคืนคือสแน็ปช็อตของข้อมูลที่สร้างหรือลบ

ในตัวอย่างนี้ ฟังก์ชันดึงสแน็ปช็อตสำหรับพาธที่ระบุ foo/bar เป็น snap แปลงสตริงที่ตำแหน่งนั้นเป็นตัวพิมพ์ใหญ่ และเขียนสตริงที่แก้ไขไปยังฐานข้อมูล:

// Listens for new messages added to /messages/:pushId/original and creates an
// uppercase version of the message to /messages/:pushId/uppercase
export makeuppercase = onValueCreated("foo/bar", (event) => {
      // Grab the current value of what was written to the Realtime Database.
      const original = event.data.val();
      functions.logger.log('Uppercasing', event.params.pushId, original);
      const uppercase = original.toUpperCase();
      // You must return a Promise when performing asynchronous tasks inside a Functions such as
      // writing to the Firebase Realtime Database.
      // Setting an "uppercase" sibling in the Realtime Database returns a Promise.
      return event.data.ref.parent.child('uppercase').set(uppercase);
    });

การอ่านค่าก่อนหน้า

อ็อบเจ็กต์ Change มีคุณสมบัติ before ที่ให้คุณตรวจสอบสิ่งที่บันทึกไว้ใน Realtime Database ก่อน เหตุการณ์ คุณสมบัติ before ส่งคืน DataSnapshot โดยที่เมธอดทั้งหมด (เช่น val() และ exists() ) อ้างถึงค่าก่อนหน้า คุณสามารถอ่านค่าใหม่ได้อีกครั้งโดยใช้ DataSnapshot เดิมหรืออ่านคุณสมบัติ after คุณสมบัตินี้ใน Change ใด ๆ คือ DataSnapshot อื่นที่แสดงสถานะของข้อมูล หลังจาก เหตุการณ์เกิดขึ้น

ตัวอย่างเช่น สามารถใช้คุณสมบัติ before เพื่อให้แน่ใจว่าฟังก์ชันจะพิมพ์ข้อความตัวพิมพ์ใหญ่เท่านั้นเมื่อสร้างครั้งแรก:

    exports makeuppercase = onValueWritten("/messages/{pushId}/original", (event) => {
          // Only edit data when it is first created.
          if (event.data.before.exists()) {
            return null;
          }
          // Exit when the data is deleted.
          if (!event.data.after.exists()) {
            return null;
          }
          // Grab the current value of what was written to the Realtime Database.
          const original = event.data.after.val();
          console.log('Uppercasing', event.params.pushId, original);
          const uppercase = original.toUpperCase();
          // You must return a Promise when performing asynchronous tasks inside a Functions such as
          // writing to the Firebase Realtime Database.
          // Setting an "uppercase" sibling in the Realtime Database returns a Promise.
          return event.data.after.ref.parent.child('uppercase').set(uppercase);
        });