txt - javascript FileReader-análisis de archivo largo en trozos

listar archivos de una carpeta javascript

Question

Tengo archivo largo que necesito para analizar. Porque es muy largo, necesito hacerlo parte por parte. Intenté esto:

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 );
    }
}

Después de ejecutarlo veo solo la primera parte en la consola. Si cambio ''console.log'' a jquery anexar a algún div solo veo la primera parte en ese div. ¿Qué pasa con otros trozos? ¿Cómo hacer que funcione?

Answer 1

Analizando el archivo grande en un trozo pequeño usando el método simple:

                //Parse large file in to small chunks
                var parseFile = function (file) {

                        var chunkSize = 1024 * 1024 * 16; //16MB Chunk size
                        var fileSize = file.size;
                        var currentChunk = 1;
                        var totalChunks = Math.ceil((fileSize/chunkSize), chunkSize);

                        while (currentChunk <= scope.totalChunks) {

                            var offset = (currentChunk-1) * chunkSize;
                            var currentFilePart = file.slice(offset, (offset+chunkSize));

                            console.log(''Current chunk number is '', currentChunk);
                            console.log(''Current chunk data'', currentFilePart);

                            currentChunk++;
                        }
                };

Answer 2

El segundo argumento de slice es en realidad el byte final. Su código debe verse algo como:

 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);
    }
}

O puedes usar este BlobReader para una interfaz más fácil:

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

Más información:

• README.md
• Docs

Answer 3

Se me ocurrió un idéa interesante que probablemente sea muy rápido, ya que convertirá el blob en un ReadableByteStreamReader que probablemente sea mucho más fácil ya que no es necesario manejar cosas como el tamaño de trozo y el desplazamiento y luego hacerlo de forma recursiva en un bucle

function streamBlob(blob) {
  const reader = new Response(blob).body.getReader()
  const pump = reader => reader.read()
  .then(({ value, done }) => {
    if (done) return
    console.log(value) // uint8array chunk
    return pump(reader)
  })
  return pump(reader)
}       

Answer 4

Se renovó la respuesta de @alediaferia en una clase ( versión de manuscrito aquí ) y se devuelve el resultado en una promesa. Los codificadores valientes incluso lo habrían envuelto en un iterador asíncrono ...

class FileStreamer {
    constructor(file) {
        this.file = file;
        this.offset = 0;
        this.defaultChunkSize = 64 * 1024; // bytes
        this.rewind();
    }
    rewind() {
        this.offset = 0;
    }
    isEndOfFile() {
        return this.offset >= this.getFileSize();
    }
    readBlockAsText(length = this.defaultChunkSize) {
        const fileReader = new FileReader();
        const blob = this.file.slice(this.offset, this.offset + length);
        return new Promise((resolve, reject) => {
            fileReader.onloadend = (event) => {
                const target = (event.target);
                if (target.error == null) {
                    const result = target.result;
                    this.offset += result.length;
                    this.testEndOfFile();
                    resolve(result);
                }
                else {
                    reject(target.error);
                }
            };
            fileReader.readAsText(blob);
        });
    }
    testEndOfFile() {
        if (this.isEndOfFile()) {
            console.log(''Done reading file'');
        }
    }
    getFileSize() {
        return this.file.size;
    }
}

Ejemplo de impresión de un archivo completo en la consola (dentro de un contexto async )

const fileStreamer = new FileStreamer(aFile);
while (!fileStreamer.isEndOfFile()) {
  const data = await fileStreamer.readBlockAsText();
  console.log(data);
}

Answer 5

FileReader API de FileReader es asíncrona, por lo que debe manejarla con llamadas de block . Un for loop no funcionaría, ya que no esperaría a que se completara cada lectura antes de leer el siguiente fragmento. Aquí hay un enfoque de trabajo.

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);
}