พื้นที่เก็บข้อมูลประสิทธิภาพสูงสำหรับแอปของคุณ: Storage Foundation API

Thomas Steiner

แพลตฟอร์มเว็บมีเครื่องมือที่นักพัฒนาซอฟต์แวร์จําเป็นต้องใช้ในการสร้างแอปพลิเคชันประสิทธิภาพสูงที่ปรับแต่งได้ละเอียดสําหรับเว็บมากขึ้นเรื่อยๆ สิ่งที่โดดเด่นที่สุดคือ WebAssembly (Wasm) ได้เปิดประตูสู่เว็บแอปพลิเคชันที่รวดเร็วและมีประสิทธิภาพ ในขณะที่เทคโนโลยีอย่าง Emscripten ช่วยให้นักพัฒนาซอฟต์แวร์นําโค้ดที่ผ่านการทดสอบแล้วกลับมาใช้ซ้ำบนเว็บได้ เพื่อให้ใช้ประโยชน์จากศักยภาพนี้ได้อย่างแท้จริง นักพัฒนาซอฟต์แวร์ต้องมีพลังและความยืดหยุ่นในเรื่องพื้นที่เก็บข้อมูลเท่ากัน

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

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

เหตุใดเว็บจึงต้องใช้ Storage API อีกรายการ

แพลตฟอร์มเว็บเสนอตัวเลือกพื้นที่เก็บข้อมูลมากมายให้นักพัฒนาซอฟต์แวร์ โดยแต่ละตัวเลือกสร้างขึ้นโดยคำนึงถึงกรณีการใช้งานที่เฉพาะเจาะจง

  • ตัวเลือกบางอย่างเหล่านี้ไม่ทับซ้อนกับข้อเสนอนี้อย่างชัดเจน เนื่องจากอนุญาตให้จัดเก็บข้อมูลได้เพียงจํานวนเล็กน้อย เช่น คุกกี้ หรือ Web Storage API ซึ่งประกอบด้วยกลไก sessionStorage และ localStorage
  • เราเลิกใช้งานตัวเลือกอื่นๆ แล้วด้วยเหตุผลหลายประการ เช่น File and Directory Entries API หรือ WebSQL
  • File System Access API มีแพลตฟอร์ม API ที่คล้ายกัน แต่มีไว้เพื่อติดต่อกับระบบไฟล์ของลูกค้าและให้สิทธิ์เข้าถึงข้อมูลที่อาจอยู่นอกความเป็นเจ้าของของต้นทางหรือแม้แต่เบราว์เซอร์ แนวทางที่ต่างออกไปนี้มาพร้อมกับการพิจารณาด้านความปลอดภัยที่เข้มงวดขึ้นและต้นทุนด้านประสิทธิภาพที่สูงขึ้น
  • คุณสามารถใช้ IndexedDB API เป็นแบ็กเอนด์สำหรับ Use Case บางส่วนของ Storage Foundation API ได้ ตัวอย่างเช่น Emscripten มี IDBFS ซึ่งเป็นระบบไฟล์ถาวรที่ใช้ IndexedDB อย่างไรก็ตาม เนื่องจาก IndexedDB เป็นที่จัดเก็บคีย์-ค่าโดยพื้นฐาน จึงมีข้อจำกัดด้านประสิทธิภาพอย่างมาก นอกจากนี้ การเข้าถึงส่วนย่อยของไฟล์โดยตรงจะยิ่งยากและช้ากว่าใน IndexedDB
  • สุดท้ายนี้ อินเทอร์เฟซ CacheStorage ได้รับการรองรับอย่างทั่วถึงและปรับให้เหมาะกับพื้นที่เก็บข้อมูลขนาดใหญ่ เช่น ทรัพยากรของเว็บแอปพลิเคชัน แต่ค่านี้จะเปลี่ยนแปลงไม่ได้

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

Use Case ที่แนะนําสําหรับ Storage Foundation API

ตัวอย่างเว็บไซต์ที่อาจใช้ API นี้ ได้แก่

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

Storage Foundation API คืออะไร

API ประกอบด้วย 2 ส่วนหลักๆ ดังนี้

  • การเรียกระบบไฟล์ ซึ่งให้ฟังก์ชันพื้นฐานในการโต้ตอบกับไฟล์และเส้นทางไฟล์
  • แฮนเดิลไฟล์ ซึ่งให้สิทธิ์อ่านและเขียนไฟล์ที่มีอยู่

การเรียกระบบไฟล์

Storage Foundation API เปิดตัวออบเจ็กต์ใหม่ storageFoundation ซึ่งอยู่ในออบเจ็กต์ window และประกอบด้วยฟังก์ชันต่อไปนี้

  • storageFoundation.open(name): เปิดไฟล์ที่มีชื่อที่ระบุ หากมีไฟล์นั้นอยู่แล้ว หรือจะสร้างไฟล์ใหม่ก็ได้ แสดงผลพรอมต์ที่แก้ไขด้วยไฟล์ที่เปิด
  • storageFoundation.delete(name): นำไฟล์ที่มีชื่อตัวออก แสดงผลสัญญาที่ได้รับการแก้ไขเมื่อไฟล์ถูกลบ
  • storageFoundation.rename(oldName, newName): เปลี่ยนชื่อไฟล์จากชื่อเดิมเป็นชื่อใหม่โดยสมบูรณ์ แสดงผลพรอมต์ที่แก้ไขได้เมื่อเปลี่ยนชื่อไฟล์
  • storageFoundation.getAll(): แสดงผลพรอมต์ที่แสดงผลเป็นอาร์เรย์ของชื่อไฟล์ที่มีอยู่ทั้งหมด
  • storageFoundation.requestCapacity(requestedCapacity): ขอความจุใหม่ (ในหน่วยไบต์) เพื่อการใช้งานตามบริบทการดำเนินการปัจจุบัน แสดงผล Promise ที่แก้ไขแล้วพร้อมด้วยจำนวนความจุที่เหลืออยู่
  • storageFoundation.releaseCapacity(toBeReleasedCapacity): ปล่อยจำนวนไบต์ที่ระบุจากบริบทการดำเนินการปัจจุบัน และแสดงผลสัญญาที่จะแก้ไขด้วยความจุที่เหลืออยู่
  • storageFoundation.getRemainingCapacity(): แสดงผลพรอมต์ที่แสดงผลพร้อมความจุที่ใช้ได้สำหรับบริบทการดําเนินการปัจจุบัน

แฮนเดิลไฟล์

การทำงานกับไฟล์จะดำเนินการผ่านฟังก์ชันต่อไปนี้

  • NativeIOFile.close(): ปิดไฟล์และแสดงผลพรอมต์ที่แก้ไขเมื่อการดำเนินการเสร็จสมบูรณ์
  • NativeIOFile.flush(): ซิงค์ (นั่นคือล้าง) สถานะในหน่วยความจำของไฟล์กับอุปกรณ์เก็บข้อมูล และแสดงผลพรอมต์ที่แก้ไขได้เมื่อการดำเนินการเสร็จสมบูรณ์
  • NativeIOFile.getLength(): แสดงผลพรอมต์ที่แสดงผลความยาวของไฟล์เป็นไบต์
  • NativeIOFile.setLength(length): ตั้งค่าความยาวของไฟล์เป็นไบต์ และแสดงผลพรอมต์ที่แก้ไขเมื่อการดำเนินการเสร็จสมบูรณ์ หากความยาวใหม่สั้นกว่าความยาวปัจจุบัน ระบบจะนำไบต์ออกโดยเริ่มจากส่วนท้ายของไฟล์ ไม่เช่นนั้น ระบบจะขยายไฟล์ด้วยไบต์ที่มีค่าเป็น 0

  • NativeIOFile.read(buffer, offset): อ่านเนื้อหาของไฟล์ที่ออฟเซ็ตที่ระบุผ่านบัฟเฟอร์ที่เป็นผลมาจากการโอนบัฟเฟอร์ที่ระบุ ซึ่งจะถูกแยกออกหลังจากนั้น แสดงผล NativeIOReadResult ที่มีบัฟเฟอร์ที่โอนและจํานวนไบต์ที่อ่านได้สําเร็จ

    NativeIOReadResult คือออบเจ็กต์ที่มี 2 รายการ ได้แก่

    • buffer: ArrayBufferView ซึ่งเป็นผลมาจากการโอนบัฟเฟอร์ที่ส่งไปยัง read() โดยจะมีประเภทและความยาวเดียวกับบัฟเฟอร์ต้นทาง
    • readBytes: จํานวนไบต์ที่อ่านลงใน buffer สําเร็จ ซึ่งอาจน้อยกว่าขนาดบัฟเฟอร์ หากเกิดข้อผิดพลาด หรือหากช่วงการอ่านขยายเกินช่วงท้ายของไฟล์ ระบบจะตั้งค่าเป็น 0 หากช่วงการอ่านอยู่นอกขอบเขตของไฟล์

  • NativeIOFile.write(buffer, offset): เขียนเนื้อหาของบัฟเฟอร์ที่ระบุลงในไฟล์ที่ออฟเซตที่ระบุ ระบบจะโอนบัฟเฟอร์ก่อนที่จะมีการเขียนข้อมูลใดๆ ดังนั้นบัฟเฟอร์จึงไม่ได้เชื่อมโยงอยู่ แสดงผล NativeIOWriteResult ที่มีบัฟเฟอร์ที่โอนและจํานวนไบต์ที่เขียนสําเร็จ ระบบจะขยายไฟล์หากช่วงการเขียนมีความยาวเกิน

    NativeIOWriteResult คือออบเจ็กต์ที่มี 2 รายการ ได้แก่

    • buffer: ArrayBufferView ซึ่งเป็นผลมาจากการโอนบัฟเฟอร์ที่ส่งไปยัง write() โดยจะมีประเภทและความยาวเดียวกับบัฟเฟอร์ต้นทาง
    • writtenBytes: จํานวนไบต์ที่เขียนลงใน buffer เรียบร้อยแล้ว ซึ่งอาจน้อยกว่าขนาดบัฟเฟอร์หากเกิดข้อผิดพลาด

ตัวอย่างแบบเต็ม

ตัวอย่างต่อไปนี้จะช่วยให้คุณเข้าใจแนวคิดที่อธิบายไว้ข้างต้นได้ชัดเจนยิ่งขึ้น โดยเราจะอธิบายขั้นตอนต่างๆ ในวงจรชีวิตของไฟล์ Storage Foundation

การเปิด การเขียน การอ่าน การปิด

// Open a file (creating it if needed).
const file = await storageFoundation.open('test_file');
try {
  // Request 100 bytes of capacity for this context.
  await storageFoundation.requestCapacity(100);

  const writeBuffer = new Uint8Array([64, 65, 66]);
  // Write the buffer at offset 0. After this operation, `result.buffer`
  // contains the transferred buffer and `result.writtenBytes` is 3,
  // the number of bytes written. `writeBuffer` is left detached.
  let result = await file.write(writeBuffer, 0);

  const readBuffer = new Uint8Array(3);
  // Read at offset 1. `result.buffer` contains the transferred buffer,
  // `result.readBytes` is 2, the number of bytes read. `readBuffer` is left
  // detached.
  result = await file.read(readBuffer, 1);
  // `Uint8Array(3) [65, 66, 0]`
  console.log(result.buffer);
} finally {
  file.close();
}

การเปิด รายการ การลบ

// Open three different files (creating them if needed).
await storageFoundation.open('sunrise');
await storageFoundation.open('noon');
await storageFoundation.open('sunset');
// List all existing files.
// `["sunset", "sunrise", "noon"]`
await storageFoundation.getAll();
// Delete one of the three files.
await storageFoundation.delete('noon');
// List all remaining existing files.
// `["sunrise", "noon"]`
await storageFoundation.getAll();

สาธิต

คุณสามารถใช้การสาธิต Storage Foundation API ในการฝังด้านล่าง สร้าง เปลี่ยนชื่อ เขียน และอ่านจากไฟล์ รวมถึงดูพื้นที่ว่างที่คุณขออัปเดตขณะทำการเปลี่ยนแปลง คุณดูซอร์สโค้ดของเดโมได้ใน Glitch

ความปลอดภัยและสิทธิ์

ทีม Chromium ได้ออกแบบและติดตั้งใช้งาน Storage Foundation API โดยใช้หลักการหลักที่ระบุไว้ในการควบคุมการเข้าถึงฟีเจอร์ที่มีประสิทธิภาพของแพลตฟอร์มเว็บ ซึ่งรวมถึงการควบคุมของผู้ใช้ ความโปร่งใส และลักษณะการใช้งานที่สะดวกสบาย

การเข้าถึง Storage Foundation API จะเชื่อมโยงกับต้นทางตามรูปแบบเดียวกับ API พื้นที่เก็บข้อมูลสมัยใหม่อื่นๆ บนเว็บ ซึ่งหมายความว่าต้นทางจะเข้าถึงได้เฉพาะข้อมูลที่สร้างขึ้นเองเท่านั้น และจำกัดไว้เฉพาะบริบทที่ปลอดภัย

การควบคุมของผู้ใช้

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

ลิงก์ที่มีประโยชน์

ขอขอบคุณ

Storage Foundation API ได้รับการระบุและติดตั้งใช้งานโดย Emanuel Krivoy และ Richard Stotz บทความนี้ผ่านการตรวจสอบโดย Pete LePage และ Joe Medley

รูปภาพหลักจาก Markus Spiske ใน Unsplash