जावास्क्रिप्ट फ़ाइल रीडर - भाग में लंबी फ़ाइल को पार्सिंग

Question

मेरे पास लंबी फ़ाइल है जिसे मुझे पार्स करने की आवश्यकता है। क्योंकि यह बहुत लंबा है, मुझे इसे खंड से अलग करने की ज़रूरत है। मैंने यह कोशिश की:

function parseFile(file){ 
    var chunkSize = 2000; 
    var fileSize = (file.size - 1); 

    var foo = function(e){ 
     console.log(e.target.result); 
    }; 

    for(var i =0; i < fileSize; i += chunkSize) 
    { 
     (function(fil, start) { 
      var reader = new FileReader(); 
      var blob = fil.slice(start, chunkSize + 1); 
      reader.onload = foo; 
      reader.readAsText(blob); 
     })(file, i); 
    } 
} 

इसे चलाने के बाद मैं कंसोल में केवल पहला हिस्सा देखता हूं। अगर मैं कुछ div में jquery संलग्न करने के लिए 'console.log' को बदलता हूं तो मुझे उस div में केवल पहला खंड दिखाई देता है। अन्य हिस्सों के बारे में क्या? इसे कार्यशील कैसे करें?

Answer 1

slice का दूसरा तर्क वास्तव में अंत बाइट है।

function parseFile(file){ 
    var chunkSize = 2000; 
    var fileSize = (file.size - 1); 

    var foo = function(e){ 
     console.log(e.target.result); 
    }; 

    for(var i =0; i < fileSize; i += chunkSize) { 
     (function(fil, start) { 
      var reader = new FileReader(); 
      var blob = fil.slice(start, chunkSize + start); 
      reader.onload = foo; 
      reader.readAsText(blob); 
     })(file, i); 
    } 
} 

या आप आसान इंटरफेस के लिए इस BlobReader उपयोग कर सकते हैं:

BlobReader(blob) 
.readText(function (text) { 
    console.log('The text in the blob is', text); 
}); 

अधिक जानकारी:

• README.md
• Docs

आपका कोड कुछ ऐसा दिखाई देगा

Answer 2

FileReader एपीआई असीमित है इसलिए आपको block कॉल के साथ इसे संभालना चाहिए। एक for loop चाल नहीं करेगा क्योंकि यह अगले पढ़ने को पढ़ने से पहले प्रत्येक पढ़ने को पूरा करने की प्रतीक्षा नहीं करेगा। यहां एक कामकाजी दृष्टिकोण है।

function parseFile(file, callback) { 
    var fileSize = file.size; 
    var chunkSize = 64 * 1024; // bytes 
    var offset  = 0; 
    var self  = this; // we need a reference to the current object 
    var chunkReaderBlock = null; 

    var readEventHandler = function(evt) { 
     if (evt.target.error == null) { 
      offset += evt.target.result.length; 
      callback(evt.target.result); // callback for handling read chunk 
     } else { 
      console.log("Read error: " + evt.target.error); 
      return; 
     } 
     if (offset >= fileSize) { 
      console.log("Done reading file"); 
      return; 
     } 

     // of to the next chunk 
     chunkReaderBlock(offset, chunkSize, file); 
    } 

    chunkReaderBlock = function(_offset, length, _file) { 
     var r = new FileReader(); 
     var blob = _file.slice(_offset, length + _offset); 
     r.onload = readEventHandler; 
     r.readAsText(blob); 
    } 

    // now let's start the read with the first block 
    chunkReaderBlock(offset, chunkSize, file); 
} 

Answer 3

मैं एक बहुत ही दिलचस्प विचार है कि शायद बहुत तेजी से है, क्योंकि यह शायद बहुत आसान भी एक ReadableByteStreamReader को ब्लॉब में परिवर्तित कर देंगे, क्योंकि आप हिस्सा आकार की तरह सामान को संभालने और ऑफसेट और फिर कर की जरूरत नहीं है के साथ आया था यह सब एक लूप में रिकर्सिव है - लेकिन केवल ब्लिंक के लिए काम करता है, एज इसे अगले संस्करण में प्राप्त करेगा

let pump = reader => reader.read() 
.then(({ value, done }) => { 
    if(done) return 
    console.log(value) // uint8array chunk 
    return pump(reader); 
}) 


window.blobToStream = blob => 
    fetch(URL.createObjectURL(blob)) 
    .then(res => pump(res.body.getReader()))