const fs = require(‘fs’); const filename=»binary.bin»; fs.readFile(filename, (err, data) => { if (err) { console.error(‘Error al leer el archivo:’, err); return; } console.log(data); // procesar los datos de Buffer usando los métodos de Buffer (por ejemplo, slice, copy) }); Transmisión de archivos en JavaScript Otra faceta del manejo de archivos es la transmisión en fragmentos de datos, lo que se vuelve una necesidad cuando se trabaja con archivos grandes. Aquí hay un ejemplo artificial de escritura en fragmentos de transmisión: const fs = require(‘fs’); const filename=»large_file.txt»; const chunkSize = 1024 * 1024; // (1) const content=»Este es un contenido que se escribirá en fragmentos.»; // (2) const fileSizeLimit = 5 * 1024 * 1024; // // (3) let writtenBytes = 0; // (4) const writeStream = fs.createWriteStream(filename, { highWaterMark: chunkSize }); // (5) function writeChunk() { // (6) const chunk = content.repeat(Math.ceil(chunkSize / content.length)); // (7) if (writtenBytes + chunk.length fileSizeLimit) { console.error(‘Se alcanzó el límite de tamaño de archivo’); writeStream.end(); return; } console.log(`Se escribió un fragmento de tamaño: ${chunk.length}, Total escrito: ${writtenBytes}`); } } writeStream.on(‘error’, (err) => { // (10) console.error(‘Error al escribir el archivo:’, err); }); writeStream.on(‘finish’, () => { // (10) console.log(‘Se terminó de escribir el archivo’); }); writeChunk(); El streaming te da más poder, pero notarás que implica más trabajo. El trabajo que estás haciendo es establecer tamaños de fragmentos y luego responder a eventos basados ​​en los fragmentos. Esta es la esencia de evitar poner demasiado de un archivo enorme en la memoria a la vez. En cambio, lo divides en fragmentos y te ocupas de cada uno. Aquí están mis notas sobre las partes interesantes del ejemplo de escritura anterior: Especificamos un tamaño de fragmento en kilobytes. En este caso, tenemos un fragmento de 1 MB, que es la cantidad de contenido que se escribirá a la vez. Aquí hay un contenido falso para escribir. Ahora, creamos un límite de tamaño de archivo, en este caso, 5 MB. Esta variable rastrea cuántos bytes hemos escrito (para que podamos dejar de escribir después de 5 MB). Creamos el objeto writeStream real. El elemento highWaterMark le dice qué tan grandes son los fragmentos que aceptará. La función writeChunk() es recursiva. Siempre que se necesita manejar un fragmento, se llama a sí misma. Hace esto a menos que se haya alcanzado el límite de archivo, en cuyo caso sale. Aquí, simplemente repetimos el texto de muestra hasta que alcanza el tamaño de 1 MB. Esta es la parte interesante. Si no se excede el tamaño del archivo, entonces llamamos a writeStream.write(chunk): writeStream.write(chunk) devuelve falso si se excede el tamaño del búfer. Eso significa que no podemos colocar más en el búfer dado el límite de tamaño. Cuando se excede el búfer, se produce el evento de vaciado, manejado por el primer controlador, que definimos aquí con writeStream.once(‘drain’, writeChunk);. Observe que se trata de una devolución de llamada recursiva a writeChunk. Esto realiza un seguimiento de cuánto hemos escrito. Esto maneja el caso en el que terminamos de escribir y finaliza el escritor de secuencias con writeStream.end();. Esto demuestra cómo agregar controladores de eventos para error y fin. Y para leerlo nuevamente desde el disco, podemos usar un enfoque similar: