ऑरिजिन निजी फ़ाइल सिस्टम

File System Standard में, ऑरिजिन प्राइवेट फ़ाइल सिस्टम (OPFS) को स्टोरेज एंडपॉइंट के तौर पर शामिल किया गया है. यह पेज की शुरुआत की जगह के लिए निजी होता है. यह फ़ाइल, उस व्यक्ति को नहीं दिखता जो बेहतर परफ़ॉर्मेंस के लिए, एक खास तरह की फ़ाइल का वैकल्पिक ऐक्सेस देता है.

ब्राउज़र समर्थन

ऑरिजिन प्राइवेट फ़ाइल सिस्टम, मॉडर्न ब्राउज़र पर काम करता है. साथ ही, इसे फ़ाइल सिस्टम लिविंग स्टैंडर्ड के वेब हाइपरटेक्स्ट ऐप्लिकेशन टेक्नोलॉजी वर्किंग ग्रुप (WhatWG) की मदद से स्टैंडर्ड बनाया गया है.

वजह

जब आप अपने कंप्यूटर पर मौजूद फ़ाइलों के बारे में सोचते हैं, तो आप शायद फ़ाइल की हैरारकी के बारे में सोचते हैं: फ़ोल्डर में व्यवस्थित की गई फ़ाइलें, जिन्हें आपके ऑपरेटिंग सिस्टम के फ़ाइल एक्सप्लोरर की मदद से एक्सप्लोर किया जा सकता है. उदाहरण के लिए, Windows पर टॉम नाम के उपयोगकर्ता की काम की सूची C:\Users\Tom\Documents\ToDo.txt में हो सकती है. इस उदाहरण में, ToDo.txt फ़ाइल का नाम है और Users, Tom, और Documents फ़ोल्डर के नाम हैं. Windows पर `C:` ड्राइव की रूट डायरेक्ट्री को दिखाता है.

वेब पर फ़ाइलों के साथ काम करने का पारंपरिक तरीका

किसी वेब ऐप्लिकेशन में काम की सूची में बदलाव करने के लिए, यह सामान्य फ़्लो है:

1. उपयोगकर्ता, फ़ाइल को सर्वर पर अपलोड करता है या उसे <input type="file"> की मदद से क्लाइंट पर खोलता है.
2. इसके बाद, उपयोगकर्ता बदलाव करता है. इसके बाद, इंजेक्ट किए गए <a download="ToDo.txt> के साथ उस फ़ाइल को डाउनलोड करता है, जिसे आपने JavaScript के ज़रिए प्रोग्राम के हिसाब से click() तरीके से सेट किया है.
3. फ़ोल्डर खोलने के लिए, <input type="file" webkitdirectory> में एक खास एट्रिब्यूट का इस्तेमाल किया जाता है. अपने मालिकाना नाम के बावजूद, यह ब्राउज़र पर काम करता है.

वेब पर फ़ाइलों के साथ काम करने का आधुनिक तरीका

यह फ़्लो यह नहीं बताता कि उपयोगकर्ता फ़ाइलों में बदलाव करने के बारे में क्या सोचते हैं. इसका मतलब यह है कि उपयोगकर्ताओं को अपनी इनपुट फ़ाइलों की डाउनलोड की गई कॉपी मिलती हैं. इसलिए, File System Access API ने तीन पिकर तरीकों की शुरुआत की है—showOpenFilePicker(), showSaveFilePicker(), और showDirectoryPicker()—ये तरीके ठीक वही काम करते हैं जो उनके नाम से पता चलता है. इनसे यह फ़्लो चालू होता है:

1. ToDo.txt को showOpenFilePicker() के साथ खोलें और एक FileSystemFileHandle ऑब्जेक्ट पाएं.
2. FileSystemFileHandle ऑब्जेक्ट से, फ़ाइल हैंडल के getFile() तरीके को कॉल करके File पाएं.
3. फ़ाइल में बदलाव करें. इसके बाद, हैंडल पर requestPermission({mode: 'readwrite'}) को कॉल करें.
4. अगर उपयोगकर्ता अनुमति का अनुरोध स्वीकार कर लेता है, तो बदलावों को वापस मूल फ़ाइल में सेव करें.
5. इसके अलावा, showSaveFilePicker() पर कॉल करें और उपयोगकर्ता को नई फ़ाइल चुनने दें. (अगर उपयोगकर्ता पहले से खुली किसी फ़ाइल को चुनता है, तो उसका कॉन्टेंट ओवरराइट हो जाएगा.) बार-बार सेव करने के लिए, फ़ाइल हैंडल को आस-पास रखा जा सकता है, ताकि आपको फ़ाइल सेव करने वाला डायलॉग दोबारा न दिखाना पड़े.

वेब पर फ़ाइलों के साथ काम करने से जुड़ी पाबंदियां

इन तरीकों से ऐक्सेस की जाने वाली फ़ाइलें और फ़ोल्डर, उपयोगकर्ता को दिखने वाला फ़ाइल सिस्टम होते हैं. वेब से सेव की गई फ़ाइलों और खास तौर पर एक्ज़ीक्यूटेबल फ़ाइलों पर वेब का निशान लगा होता है. इससे, किसी फ़ाइल को एक्ज़ीक्यूट करने से पहले ऑपरेटिंग सिस्टम पर चेतावनी दिख सकती है. सुरक्षा की अतिरिक्त सुविधा के तौर पर, वेब से मिली फ़ाइलों को भी सुरक्षित ब्राउज़िंग की मदद से सुरक्षित किया जाता है. इसे आसान बनाने की वजह से, इस लेख में दी गई जानकारी को क्लाउड-आधारित वायरस स्कैन की तरह माना जा सकता है. जब File System Access API का इस्तेमाल करके किसी फ़ाइल में डेटा लिखा जाता है, तो लिखे गए टेक्स्ट मौजूद नहीं होते, बल्कि अस्थायी फ़ाइल का इस्तेमाल किया जाता है. फ़ाइल में तब तक कोई बदलाव नहीं होता, जब तक वह इन सभी सुरक्षा जांचों में पास नहीं हो जाती. उदाहरण के तौर पर, macOS पर इस तरह के काम करने की वजह से, फ़ाइल की प्रोसेसिंग धीमी हो जाती है. हालांकि, जहां मुमकिन होता है वहां बेहतर तरीके से काम करने के बावजूद, यह प्रोसेस धीमी होती है. अब भी हर write() कॉल अपने-आप में होता है, इसलिए हुड के तहत यह फ़ाइल खोलता है, दिए गए ऑफ़सेट को खोजता है, और आखिर में डेटा लिखता है.

प्रोसेसिंग के आधार के तौर पर फ़ाइलें

साथ ही, फ़ाइलें डेटा रिकॉर्ड करने का शानदार तरीका है. उदाहरण के लिए, SQLite पूरे डेटाबेस को एक ही फ़ाइल में सेव करता है. इसका एक और उदाहरण है, इमेज प्रोसेसिंग में इस्तेमाल किए जाने वाले मिपमैप. मिपमैप, इमेज के ऑप्टिमाइज़ किए गए क्रम होते हैं और इनका पहले से हिसाब लगाया जाता है. हर इमेज का रिज़ॉल्यूशन, पिछली इमेज के मुकाबले कम रिज़ॉल्यूशन के रूप में होता है. इससे तेज़ी से ज़ूम करने जैसी कई कार्रवाइयां की जाती हैं. ऐसे में वेब-आधारित फ़ाइल प्रोसेसिंग की परफ़ॉर्मेंस के बिना, वेब ऐप्लिकेशन को फ़ाइलों का फ़ायदा कैसे मिल सकता है? इसका जवाब है ऑरिजिन प्राइवेट फ़ाइल सिस्टम.

उपयोगकर्ता को दिखने वाला और ऑरिजिन प्राइवेट फ़ाइल सिस्टम की तुलना

ऑपरेटिंग सिस्टम के फ़ाइल एक्सप्लोरर का इस्तेमाल करके ब्राउज़ किए जाने वाले फ़ाइल सिस्टम के उलट, ऑरिजिन प्राइवेट फ़ाइल सिस्टम लोगों को नहीं दिखता. हालांकि, ऑरिजिन प्राइवेट फ़ाइल सिस्टम को उपयोगकर्ताओं को नहीं देखा जाना चाहिए. जैसा कि नाम से ही पता चलता है, ऑरिजिन प्राइवेट फ़ाइल सिस्टम में मौजूद फ़ाइलें और फ़ोल्डर, निजी होते हैं. साथ ही, साइट की ऑरिजिन तक ही सीमित और निजी होते हैं. DevTools कंसोल में location.origin टाइप करके, पेज के ऑरिजिन के बारे में जानें. उदाहरण के लिए, https://developer.chrome.com/articles/ पेज का ऑरिजिन https://developer.chrome.com है. इसका मतलब है कि /articles पेज, ऑरिजिन का हिस्सा नहीं है. "समान-साइट" को समझना, मूल सिद्धांत के बारे में ज़्यादा जानने के लिए और "सेम-ऑरिजिन" ही होने चाहिए. एक ही ऑरिजिन वाले सभी पेजों पर एक ही ऑरिजिन के निजी फ़ाइल सिस्टम का डेटा दिख सकता है. इसलिए, https://developer.chrome.com/docs/extensions/mv3/getstarted/extensions-101/ के लिए भी पिछले उदाहरण जैसी जानकारी ही दिखेगी. हर ऑरिजिन का अपना इंडिपेंडेंट ऑरिजिन प्राइवेट फ़ाइल सिस्टम होता है. इसका मतलब है कि https://developer.chrome.com का ऑरिजिन प्राइवेट फ़ाइल सिस्टम, https://web.dev जैसे इनमें से किसी एक फ़ाइल सिस्टम से पूरी तरह अलग है. Windows पर, उपयोगकर्ता को दिखने वाले फ़ाइल सिस्टम की रूट डायरेक्ट्री C:\\ होती है. ऑरिजिन प्राइवेट फ़ाइल सिस्टम के लिए, हर ऑरिजिन के लिए शुरुआती तौर पर एक खाली रूट डायरेक्ट्री मौजूद होती है. इसे एसिंक्रोनस तरीके को कॉल करके ऐक्सेस किया जाता है navigator.storage.getDirectory(). उपयोगकर्ता को दिखने वाले फ़ाइल सिस्टम और ऑरिजिन प्राइवेट फ़ाइल सिस्टम की तुलना करने के लिए, नीचे दिया गया डायग्राम देखें. डायग्राम में दिखाया गया है कि रूट डायरेक्ट्री के अलावा, बाकी सब कुछ सैद्धांतिक तौर पर एक जैसा है. इसमें फ़ाइलों और फ़ोल्डर की हैरारकी है, जो आपके डेटा और स्टोरेज की ज़रूरतों के हिसाब से व्यवस्थित और व्यवस्थित की गई है.

ऑरिजिन प्राइवेट फ़ाइल सिस्टम के बारे में खास जानकारी

ब्राउज़र में अन्य स्टोरेज मैकेनिज़्म (उदाहरण के लिए, localStorage या IndexedDB) की तरह, ऑरिजिन प्राइवेट फ़ाइल सिस्टम पर ब्राउज़र कोटा पाबंदियां लागू होती हैं. जब कोई उपयोगकर्ता सारा ब्राउज़िंग डेटा या साइट का सारा डेटा मिटा देता है, तो ऑरिजिन का निजी फ़ाइल सिस्टम भी मिट जाता है. navigator.storage.estimate() को कॉल करें. इसके बाद, जवाब देने वाले ऑब्जेक्ट में usage एंट्री दिखेगी. इससे आपको पता चलेगा कि आपका ऐप्लिकेशन पहले से कितनी स्टोरेज का इस्तेमाल कर रहा है. यह डेटा usageDetails ऑब्जेक्ट में स्टोरेज मैकेनिज़्म के हिसाब से बांटा जाता है, जहां आपको खास तौर पर fileSystem एंट्री देखनी है. उपयोगकर्ता को ऑरिजिन प्राइवेट फ़ाइल सिस्टम नहीं दिखता है. इसलिए, अनुमति का अनुरोध नहीं किया जाता और सुरक्षित ब्राउज़िंग की सुविधा की कोई जांच नहीं की जाती.

रूट डायरेक्ट्री का ऐक्सेस पाना

रूट डायरेक्ट्री का ऐक्सेस पाने के लिए, नीचे दिया गया कमांड चलाएं. आखिर में आपको खाली डायरेक्ट्री हैंडल मिलता है, खास तौर पर FileSystemDirectoryHandle.

const opfsRoot = await navigator.storage.getDirectory();
// A FileSystemDirectoryHandle whose type is "directory"
// and whose name is "".
console.log(opfsRoot);

मुख्य थ्रेड या वेब वर्कर

ऑरिजिन प्राइवेट फ़ाइल सिस्टम का इस्तेमाल करने के दो तरीके हैं: मुख्य थ्रेड पर या वेब वर्कर पर. वेब वर्कर मुख्य थ्रेड को ब्लॉक नहीं कर सकते. इसका मतलब है कि इस कॉन्टेक्स्ट में एपीआई सिंक्रोनस हो सकते हैं. इसका पैटर्न आम तौर पर मुख्य थ्रेड पर अस्वीकार किया जाता है. सिंक्रोनस एपीआई ज़्यादा तेज़ हो सकते हैं, क्योंकि उन्हें वादों को पूरा करने की ज़रूरत नहीं होती. साथ ही, फ़ाइल से जुड़ी कार्रवाइयां आम तौर पर C जैसी भाषाओं में सिंक होती हैं, जिन्हें WebAssembly में कंपाइल किया जा सकता है.

// This is synchronous C code.
FILE *f;
f = fopen("example.txt", "w+");
fputs("Some text\n", f);
fclose(f);

अगर आपको फ़ाइल से जुड़ी सबसे तेज़ कार्रवाइयां चाहिए या आपने WebAssembly का काम हैंडल किया है, तो सीधे वेब वर्कर में ऑरिजिन प्राइवेट फ़ाइल सिस्टम का इस्तेमाल करना पर जाएं. वरना, आगे पढ़ें.

मुख्य थ्रेड पर, ऑरिजिन प्राइवेट फ़ाइल सिस्टम का इस्तेमाल करें

नई फ़ाइलें और फ़ोल्डर बनाना

रूट फ़ोल्डर बनाने के बाद, getFileHandle() और getDirectoryHandle() तरीकों का इस्तेमाल करके फ़ाइलें और फ़ोल्डर बनाएं. {create: true} को पास करने पर, फ़ाइल या फ़ोल्डर के मौजूद न होने पर उसे बनाया जाएगा. शुरुआती पॉइंट के तौर पर, नई बनाई गई डायरेक्ट्री का इस्तेमाल करके इन फ़ंक्शन को कॉल करके फ़ाइलों की हैरारकी बनाएं.

const fileHandle = await opfsRoot
    .getFileHandle('my first file', {create: true});
const directoryHandle = await opfsRoot
    .getDirectoryHandle('my first folder', {create: true});
const nestedFileHandle = await directoryHandle
    .getFileHandle('my first nested file', {create: true});
const nestedDirectoryHandle = await directoryHandle
    .getDirectoryHandle('my first nested folder', {create: true});

मौजूदा फ़ाइलें और फ़ोल्डर ऐक्सेस करें

अगर आपको उनका नाम पता है, तो पहले बनाई गई फ़ाइलों और फ़ोल्डर को ऐक्सेस करने के लिए, getFileHandle() या getDirectoryHandle() तरीकों का इस्तेमाल करें. साथ ही, फ़ाइल या फ़ोल्डर का नाम पास करें.

const existingFileHandle = await opfsRoot.getFileHandle('my first file');
const existingDirectoryHandle = await opfsRoot
    .getDirectoryHandle('my first folder');

पढ़ने के लिए, फ़ाइल हैंडल से जुड़ी फ़ाइल फ़ेच करना

FileSystemFileHandle, फ़ाइल सिस्टम पर मौजूद फ़ाइल को दिखाता है. इससे जुड़े File को पाने के लिए, getFile() तरीके का इस्तेमाल करें. File ऑब्जेक्ट, खास तरह का Blob है. इसे किसी भी कॉन्टेक्स्ट में इस्तेमाल किया जा सकता है, जैसा कि Blob कर सकता है. खास तौर पर, FileReader, URL.createObjectURL(), createImageBitmap(), और XMLHttpRequest.send(), Blobs और Files, दोनों को स्वीकार करते हैं. अगर हां, तो FileSystemFileHandle "मुफ़्त" से File हासिल करना डेटा की पहचान करना चाहते हैं, ताकि आप उस तक पहुंच सकें और उसे उपयोगकर्ता को दिखाई देने वाले फ़ाइल सिस्टम में उपलब्ध करा सकें.

const file = await fileHandle.getFile();
console.log(await file.text());

स्ट्रीम करके किसी फ़ाइल में लिखना

createWritable() को कॉल करके किसी फ़ाइल में डेटा स्ट्रीम करें. इससे, आपके पास एक FileSystemWritableFileStream बन जाएगा और फिर कॉन्टेंट write() बन जाएगा. आखिर में, आपको स्ट्रीम close() करनी होगी.

const contents = 'Some text';
// Get a writable stream.
const writable = await fileHandle.createWritable();
// Write the contents of the file to the stream.
await writable.write(contents);
// Close the stream, which persists the contents.
await writable.close();

फ़ाइलें और फ़ोल्डर मिटाना

फ़ाइलों और फ़ोल्डर को मिटाने के लिए, उनके फ़ाइल या डायरेक्ट्री हैंडल के खास तरीके remove() को कॉल करें. सभी सब-फ़ोल्डर वाले फ़ोल्डर को मिटाने के लिए, {recursive: true} विकल्प को पास करें.

await fileHandle.remove();
await directoryHandle.remove({recursive: true});

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

इसके अलावा, अगर आपको किसी डायरेक्ट्री में मिटाई जाने वाली फ़ाइल या फ़ोल्डर का नाम पता है, तो removeEntry() तरीका इस्तेमाल करें.

directoryHandle.removeEntry('my first nested file');

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

फ़ाइलों और फ़ोल्डर को मूव करना और उनका नाम बदलना

move() तरीके का इस्तेमाल करके, फ़ाइलों और फ़ोल्डर का नाम बदलें और उनकी जगह बदलें. स्थान बदलना और नाम बदलना एक साथ या अलग-अलग हो सकता है.

// Rename a file.
await fileHandle.move('my first renamed file');
// Move a file to another directory.
await fileHandle.move(nestedDirectoryHandle);
// Move a file to another directory and rename it.
await fileHandle
    .move(nestedDirectoryHandle, 'my first renamed and now nested file');

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

किसी फ़ाइल या फ़ोल्डर का पाथ ठीक करना

यह जानने के लिए कि रेफ़रंस डायरेक्ट्री में दी गई फ़ाइल या फ़ोल्डर कहां है, resolve() तरीके का इस्तेमाल करके, तर्क के तौर पर FileSystemHandle दें. ऑरिजिन प्राइवेट फ़ाइल सिस्टम में किसी फ़ाइल या फ़ोल्डर का पूरा पाथ पाने के लिए, रूट डायरेक्ट्री का इस्तेमाल, navigator.storage.getDirectory() से मिली रेफ़रंस डायरेक्ट्री के तौर पर करें.

const relativePath = await opfsRoot.resolve(nestedDirectoryHandle);
// `relativePath` is `['my first folder', 'my first nested folder']`.

यह जांचें कि दो फ़ाइल या फ़ोल्डर के हैंडल एक ही फ़ाइल या फ़ोल्डर पर ले जाते हैं या नहीं

कभी-कभी आपके पास दो हैंडल होते हैं और आपको नहीं पता होता कि वे एक ही फ़ाइल या फ़ोल्डर पर ले जाते हैं या नहीं. ऐसा है या नहीं, यह देखने के लिए isSameEntry() तरीके का इस्तेमाल करें.

fileHandle.isSameEntry(nestedFileHandle);
// Returns `false`.

फ़ोल्डर के कॉन्टेंट की सूची बनाएं

FileSystemDirectoryHandle एक एसिंक्रोनस इटरेटर है, जिसे for await…of लूप में फिर से चालू किया जाता है. एसिंक्रोनस इटरेटर के तौर पर, यह entries(), values(), और keys() तरीकों के साथ भी काम करता है. इनमें से अपनी ज़रूरत की जानकारी के हिसाब से, इनमें से कोई तरीका चुना जा सकता है:

for await (let [name, handle] of directoryHandle) {}
for await (let [name, handle] of directoryHandle.entries()) {}
for await (let handle of directoryHandle.values()) {}
for await (let name of directoryHandle.keys()) {}

किसी फ़ोल्डर और सभी सब-फ़ोल्डर के कॉन्टेंट को बार-बार लिस्ट करें

एसिंक्रोनस लूप और बार-बार होने वाले फ़ंक्शन के साथ काम करना आसान होता है. नीचे दिया गया फ़ंक्शन, किसी फ़ोल्डर के कॉन्टेंट और उसके सभी सब-फ़ोल्डर की सूची बनाने के लिए, शुरुआती पॉइंट का काम कर सकता है. इसमें, सभी फ़ाइलें और उनके साइज़ भी शामिल हैं. अगर आपको फ़ाइल के साइज़ की ज़रूरत नहीं है, तो इस फ़ंक्शन को आसान बनाया जा सकता है. फ़ाइल के साइज़ में directoryEntryPromises.push लिखा होता है. इसका मतलब है कि फ़ाइल handle.getFile() प्रॉमिस को पुश नहीं करने के बजाय, सीधे handle को आगे ले जाना है.

  const getDirectoryEntriesRecursive = async (
    directoryHandle,
    relativePath = '.',
  ) => {
    const fileHandles = [];
    const directoryHandles = [];
    const entries = {};
    // Get an iterator of the files and folders in the directory.
    const directoryIterator = directoryHandle.values();
    const directoryEntryPromises = [];
    for await (const handle of directoryIterator) {
      const nestedPath = `${relativePath}/${handle.name}`;
      if (handle.kind === 'file') {
        fileHandles.push({ handle, nestedPath });
        directoryEntryPromises.push(
          handle.getFile().then((file) => {
            return {
              name: handle.name,
              kind: handle.kind,
              size: file.size,
              type: file.type,
              lastModified: file.lastModified,
              relativePath: nestedPath,
              handle
            };
          }),
        );
      } else if (handle.kind === 'directory') {
        directoryHandles.push({ handle, nestedPath });
        directoryEntryPromises.push(
          (async () => {
            return {
              name: handle.name,
              kind: handle.kind,
              relativePath: nestedPath,
              entries:
                  await getDirectoryEntriesRecursive(handle, nestedPath),
              handle,
            };
          })(),
        );
      }
    }
    const directoryEntries = await Promise.all(directoryEntryPromises);
    directoryEntries.forEach((directoryEntry) => {
      entries[directoryEntry.name] = directoryEntry;
    });
    return entries;
  };

वेब वर्कर में ऑरिजिन निजी फ़ाइल सिस्टम का इस्तेमाल करना

जैसा कि पहले बताया गया है, वेब वर्कर मुख्य थ्रेड को ब्लॉक नहीं कर सकते. इसलिए, इस कॉन्टेक्स्ट में सिंक्रोनस मेथड की अनुमति है.

सिंक्रोनस ऐक्सेस हैंडल पाना

फ़ाइल से जुड़ी सबसे तेज़ कार्रवाइयों के लिए एंट्री पॉइंट FileSystemSyncAccessHandle है. यह आम तौर पर, FileSystemFileHandle से createSyncAccessHandle() कॉल करके लिया जाता है.

const fileHandle = await opfsRoot
    .getFileHandle('my highspeed file.txt', {create: true});
const syncAccessHandle = await fileHandle.createSyncAccessHandle();

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

सिंक्रोनस इन-प्लेस फ़ाइल मेथड

सिंक्रोनस ऐक्सेस हैंडल मिलने के बाद, आपको फ़ाइल के उन तरीकों का ऐक्सेस तेज़ी से मिलता है जो एक ही जगह पर सिंक होते हैं.

• getSize(): यह विकल्प चुनने पर, फ़ाइल का साइज़ बाइट में दिखाता है.
• write(): यह तय किए गए ऑफ़सेट पर, फ़ाइल में बफ़र के कॉन्टेंट को लिखता है और लिखे गए बाइट की संख्या दिखाता है. लिखी हुई बाइट की दी गई संख्या की जांच करने से, कॉलर को गड़बड़ियों और आंशिक रूप से लिखे गए टेक्स्ट का पता लगाने और उन्हें मैनेज करने की सुविधा मिलती है.
• read(): दिए गए ऑफ़सेट पर, फ़ाइल के कॉन्टेंट को बफ़र में पढ़ता है. हालांकि, यह ज़रूरी नहीं है.
• truncate(): यह विकल्प चुनने पर, फ़ाइल को दिए गए साइज़ में बदला जाता है.
• flush(): यह पक्का करता है कि फ़ाइल के कॉन्टेंट में write() तक किए गए सभी बदलाव शामिल हों.
• close(): ऐक्सेस हैंडल को बंद करता है.

यहां एक उदाहरण दिया गया है, जिसमें ऊपर बताए गए सभी तरीकों का इस्तेमाल किया जाता है.

const opfsRoot = await navigator.storage.getDirectory();
const fileHandle = await opfsRoot.getFileHandle('fast', {create: true});
const accessHandle = await fileHandle.createSyncAccessHandle();

const textEncoder = new TextEncoder();
const textDecoder = new TextDecoder();

// Initialize this variable for the size of the file.
let size;
// The current size of the file, initially `0`.
size = accessHandle.getSize();
// Encode content to write to the file.
const content = textEncoder.encode('Some text');
// Write the content at the beginning of the file.
accessHandle.write(content, {at: size});
// Flush the changes.
accessHandle.flush();
// The current size of the file, now `9` (the length of "Some text").
size = accessHandle.getSize();

// Encode more content to write to the file.
const moreContent = textEncoder.encode('More content');
// Write the content at the end of the file.
accessHandle.write(moreContent, {at: size});
// Flush the changes.
accessHandle.flush();
// The current size of the file, now `21` (the length of
// "Some textMore content").
size = accessHandle.getSize();

// Prepare a data view of the length of the file.
const dataView = new DataView(new ArrayBuffer(size));

// Read the entire file into the data view.
accessHandle.read(dataView);
// Logs `"Some textMore content"`.
console.log(textDecoder.decode(dataView));

// Read starting at offset 9 into the data view.
accessHandle.read(dataView, {at: 9});
// Logs `"More content"`.
console.log(textDecoder.decode(dataView));

// Truncate the file after 4 bytes.
accessHandle.truncate(4);

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

ऑरिजिन के निजी फ़ाइल सिस्टम से उपयोगकर्ता को दिखने वाले फ़ाइल सिस्टम में फ़ाइल कॉपी करें

जैसा कि ऊपर बताया गया है, ऑरिजिन प्राइवेट फ़ाइल सिस्टम से उपयोगकर्ताओं को दिखने वाले फ़ाइल सिस्टम में फ़ाइलें ट्रांसफ़र नहीं की जा सकतीं. हालांकि, फ़ाइलों को कॉपी किया जा सकता है. showSaveFilePicker() को सिर्फ़ मुख्य थ्रेड में दिखाया जाता है, लेकिन वर्कर थ्रेड में नहीं. इसलिए, कोड को वहां ज़रूर चलाएं.

// On the main thread, not in the Worker. This assumes
// `fileHandle` is the `FileSystemFileHandle` you obtained
// the `FileSystemSyncAccessHandle` from in the Worker
// thread. Be sure to close the file in the Worker thread first.
const fileHandle = await opfsRoot.getFileHandle('fast');
try {
  // Obtain a file handle to a new file in the user-visible file system
  // with the same name as the file in the origin private file system.
  const saveHandle = await showSaveFilePicker({
    suggestedName: fileHandle.name || ''
  });
  const writable = await saveHandle.createWritable();
  await writable.write(await fileHandle.getFile());
  await writable.close();
} catch (err) {
  console.error(err.name, err.message);
}

ऑरिजिन के निजी फ़ाइल सिस्टम को डीबग करें

जब तक DevTools के लिए सहायता पहले से मौजूद न हो जाए (crbug/1284595 देखें), तब तक ऑरिजिन के निजी फ़ाइल सिस्टम को डीबग करने के लिए, OPFS Explorer का Chrome एक्सटेंशन इस्तेमाल करें. नई फ़ाइलें और फ़ोल्डर बनाना सेक्शन में ऊपर दिया गया स्क्रीनशॉट, एक्सटेंशन से लिया गया है.

एक्सटेंशन इंस्टॉल करने के बाद, Chrome DevTools खोलें और OPFS एक्सप्लोरर टैब चुनें. इसके बाद, फ़ाइल की हैरारकी की जांच की जा सकती है. ऑरिजिन प्राइवेट फ़ाइल सिस्टम से फ़ाइलों को उपयोगकर्ता को दिखने वाले फ़ाइल सिस्टम में सेव करें. इसके लिए, फ़ाइल नाम पर क्लिक करें और ट्रैश कैन के आइकॉन पर क्लिक करके, फ़ाइलों और फ़ोल्डर को मिटाएं.

डेमो

ऑरिजिन प्राइवेट फ़ाइल सिस्टम को किसी डेमो में देखें और यह देखें कि अगर आपने OPFS एक्सप्लोरर एक्सटेंशन इंस्टॉल किया है, तो यह सुविधा उसे WebAssembly के लिए कंपाइल किए गए SQLite डेटाबेस के लिए बैकएंड के तौर पर इस्तेमाल करती है. glitch पर सोर्स कोड ज़रूर देखें. ध्यान दें कि नीचे दिया गया एम्बेड किया गया वर्शन, ऑरिजिन प्राइवेट फ़ाइल सिस्टम बैकएंड का इस्तेमाल कैसे नहीं करता, क्योंकि iframe क्रॉस-ऑरिजिन है. हालांकि, डेमो को किसी अलग टैब में खोलने पर, यह वर्शन काम करता है.

मीटिंग में सामने आए नतीजे

RIGHTWG में बताए गए ऑरिजिन प्राइवेट फ़ाइल सिस्टम ने, वेब पर फ़ाइलों को इस्तेमाल करने और उनके साथ इंटरैक्ट करने का तरीका तैयार किया है. इससे इस्तेमाल के ऐसे नए मामले सामने आए हैं जिन्हें उपयोगकर्ताओं को दिखने वाले फ़ाइल सिस्टम से हासिल नहीं किया जा सकता था. ब्राउज़र के सभी बड़े वेंडर—Apple, Mozilla, और Google—इस प्रोग्राम में शामिल हैं. साथ ही, इसका एक साझा विज़न भी है. ऑरिजिन प्राइवेट फ़ाइल सिस्टम को डेवलप करने के लिए हमें मिल-जुलकर काम करना होता है. साथ ही, इसकी प्रोग्रेस के लिए डेवलपर और उपयोगकर्ताओं से सुझाव लेना भी बेहद ज़रूरी है. हम इस स्टैंडर्ड को लगातार बेहतर बना रहे हैं. साथ ही, समस्याओं या पुल के अनुरोधों के तौर पर whatwg/fs डेटा स्टोर करने की जगह पर सुझाव, शिकायत या राय भेज सकते हैं.

इसी विषय से जुड़े कुछ लिंक

• फ़ाइल सिस्टम स्टैंडर्ड की खास जानकारी
• फ़ाइल सिस्टम का स्टैंडर्ड रेपो
• Origin Private File System WebKit के साथ File System API
• OPFS एक्सप्लोरर एक्सटेंशन

स्वीकार की गई

इस लेख की समीक्षा ऑस्टिन सली, एटियन नोएल, और रेचल एंड्रयू ने की है. Unस्प्लैश पर क्रिस्टीना रम्पफ़ की हीरो इमेज.