Membaca file satu per satu baris di node.js?

Saya mencoba membaca file besar satu per satu. Saya menemukan pertanyaan tentang Quora yang membahas masalah ini, tetapi saya kehilangan beberapa koneksi untuk membuat semuanya cocok.

 var Lazy=require("lazy");
 new Lazy(process.stdin)
     .lines
     .forEach(
          function(line) { 
              console.log(line.toString()); 
          }
 );
 process.stdin.resume();

Bagian yang ingin saya ketahui adalah bagaimana saya bisa membaca satu baris pada satu waktu dari sebuah file, bukan STDIN seperti dalam sampel ini.

Saya mencoba:

 fs.open('./VeryBigFile.csv', 'r', '0666', Process);

 function Process(err, fd) {
    if (err) throw err;
    // DO lazy read 
 }

tapi itu tidak berhasil. Saya tahu bahwa dalam keadaan darurat saya dapat kembali menggunakan sesuatu seperti PHP, tapi saya ingin mencari tahu.

Saya tidak berpikir jawaban lain akan bekerja karena file tersebut jauh lebih besar daripada server tempat saya menjalankannya memiliki memori.

Sejak Node.js v0.12 dan pada Node.js v4.0.0, ada modul inti readline yang stabil . Berikut cara termudah untuk membaca baris dari file, tanpa modul eksternal apa pun:

const fs = require('fs');
const readline = require('readline');

async function processLineByLine() {
  const fileStream = fs.createReadStream('input.txt');

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });
  // Note: we use the crlfDelay option to recognize all instances of CR LF
  // ('\r\n') in input.txt as a single line break.

  for await (const line of rl) {
    // Each line in input.txt will be successively available here as `line`.
    console.log(`Line from file: ${line}`);
  }
}

processLineByLine();

Atau sebagai alternatif:

var lineReader = require('readline').createInterface({
  input: require('fs').createReadStream('file.in')
});

lineReader.on('line', function (line) {
  console.log('Line from file:', line);
});

Baris terakhir dibaca dengan benar (pada Node v0.12 atau yang lebih baru), bahkan jika tidak ada final \n.

PEMBARUAN : contoh ini telah ditambahkan ke dokumentasi resmi API Node .

Untuk operasi sederhana seperti itu seharusnya tidak ada ketergantungan pada modul pihak ketiga. Mudah saja.

var fs = require('fs'),
    readline = require('readline');

var rd = readline.createInterface({
    input: fs.createReadStream('/path/to/file'),
    output: process.stdout,
    console: false
});

rd.on('line', function(line) {
    console.log(line);
});

Anda tidak harus ke openfile, tetapi Anda harus membuat ReadStream.

fs.createReadStream

Kemudian berikan aliran itu ke Lazy

ada modul yang sangat bagus untuk membaca file baris demi baris, itu disebut line-reader

dengan itu Anda cukup menulis:

var lineReader = require('line-reader');

lineReader.eachLine('file.txt', function(line, last) {
  console.log(line);
  // do whatever you want with line...
  if(last){
    // or check if it's the last one
  }
});

Anda bahkan dapat mengulangi file dengan antarmuka "java-style", jika Anda memerlukan lebih banyak kontrol:

lineReader.open('file.txt', function(reader) {
  if (reader.hasNextLine()) {
    reader.nextLine(function(line) {
      console.log(line);
    });
  }
});

require('fs').readFileSync('file.txt', 'utf-8').split(/\r?\n/).forEach(function(line){
  console.log(line);
})

Pembaruan pada tahun 2019

Contoh yang luar biasa sudah diposting pada dokumentasi resmi Nodejs. sini

Ini mengharuskan Nodejs terbaru diinstal pada mesin Anda. > 11.4

const fs = require('fs');
const readline = require('readline');

async function processLineByLine() {
  const fileStream = fs.createReadStream('input.txt');

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });
  // Note: we use the crlfDelay option to recognize all instances of CR LF
  // ('\r\n') in input.txt as a single line break.

  for await (const line of rl) {
    // Each line in input.txt will be successively available here as `line`.
    console.log(`Line from file: ${line}`);
  }
}

processLineByLine();

Topik lama, tetapi ini berfungsi:

var rl = readline.createInterface({
      input : fs.createReadStream('/path/file.txt'),
      output: process.stdout,
      terminal: false
})
rl.on('line',function(line){
     console.log(line) //or parse line
})

Sederhana. Tidak perlu modul eksternal.

Anda selalu dapat memutar pembaca baris Anda sendiri. Saya belum membuat tolok cuplikan ini, tetapi ia dengan benar membagi aliran potongan yang masuk ke dalam garis tanpa mengekor '\ n'

var last = "";

process.stdin.on('data', function(chunk) {
    var lines, i;

    lines = (last+chunk).split("\n");
    for(i = 0; i < lines.length - 1; i++) {
        console.log("line: " + lines[i]);
    }
    last = lines[i];
});

process.stdin.on('end', function() {
    console.log("line: " + last);
});

process.stdin.resume();

Saya memang datang dengan ini ketika bekerja pada skrip parsing log cepat yang diperlukan untuk mengumpulkan data selama log parsing dan saya merasa bahwa akan lebih baik untuk mencoba melakukan ini menggunakan js dan node daripada menggunakan perl atau bash.

Bagaimanapun, saya merasa bahwa skrip nodejs kecil harus mandiri dan tidak bergantung pada modul pihak ketiga sehingga setelah membaca semua jawaban untuk pertanyaan ini, masing-masing menggunakan berbagai modul untuk menangani penguraian garis, solusi nodejs asli 13 SLOC mungkin menarik.

Dengan modul operator :

var carrier = require('carrier');

process.stdin.resume();
carrier.carry(process.stdin, function(line) {
    console.log('got one line: ' + line);
});

Saya berakhir dengan kebocoran memori besar-besaran menggunakan Malas untuk membaca baris demi baris ketika mencoba untuk memproses baris-baris itu dan menulisnya ke aliran lain karena cara menguras / jeda / melanjutkan dalam karya simpul (lihat: http: // elegantcode .com / 2011/04/06 / mengambil-baby-steps-with-node-js-pumping-data-between-stream / (saya suka orang ini btw)). Saya belum melihat dari dekat pada Malas untuk mengerti persis mengapa, tetapi saya tidak bisa menghentikan aliran baca saya untuk memungkinkan pengeringan tanpa Malas keluar.

Saya menulis kode untuk memproses file csv besar menjadi dokumen xml, Anda dapat melihat kode di sini: https://github.com/j03m/node-csv2xml

Jika Anda menjalankan revisi sebelumnya dengan baris Malas bocor. Revisi terbaru tidak bocor sama sekali dan Anda mungkin dapat menggunakannya sebagai dasar untuk pembaca / prosesor. Meskipun saya punya beberapa barang khusus di sana.

Sunting: Saya kira saya juga harus mencatat bahwa kode saya dengan Lazy berfungsi dengan baik sampai saya menemukan diri saya menulis fragmen xml cukup besar yang menguras / jeda / melanjutkan karena suatu keharusan. Untuk potongan yang lebih kecil itu baik-baik saja.

Edit:

Gunakan aliran transformasi .

Dengan BufferedReader Anda dapat membaca baris.

new BufferedReader ("lorem ipsum", { encoding: "utf8" })
    .on ("error", function (error){
        console.log ("error: " + error);
    })
    .on ("line", function (line){
        console.log ("line: " + line);
    })
    .on ("end", function (){
        console.log ("EOF");
    })
    .read ();

Sejak memposting jawaban asli saya, saya menemukan bahwa split adalah modul node yang sangat mudah digunakan untuk membaca baris dalam file; Yang juga menerima parameter opsional.

var split = require('split');
fs.createReadStream(file)
    .pipe(split())
    .on('data', function (line) {
      //each chunk now is a seperate line! 
    });

Belum diuji pada file yang sangat besar. Beri tahu kami jika Anda melakukannya.

Saya frustrasi dengan kurangnya solusi yang komprehensif untuk ini, jadi saya mengumpulkan upaya saya sendiri ( git / npm ). Daftar fitur yang disalin:

• Pemrosesan jalur interaktif (berbasis panggilan balik, tidak memuat seluruh file ke dalam RAM)
• Secara opsional, kembalikan semua baris dalam array (mode detail atau mentah)
• Mengganggu streaming secara interaktif, atau melakukan pemrosesan seperti peta / filter
• Mendeteksi konvensi baris baru (PC / Mac / Linux)
• Bukti benar / pengobatan lini terakhir
• Penanganan karakter multi-byte UTF-8 yang benar
• Mengambil informasi byte offset dan panjang byte berdasarkan per-line
• Akses acak, menggunakan offset berbasis garis atau byte
• Secara otomatis memetakan informasi garis-offset, untuk mempercepat akses acak
• Tanpa ketergantungan
• Tes

NIH? Kamu putuskan :-)

function createLineReader(fileName){
    var EM = require("events").EventEmitter
    var ev = new EM()
    var stream = require("fs").createReadStream(fileName)
    var remainder = null;
    stream.on("data",function(data){
        if(remainder != null){//append newly received data chunk
            var tmp = new Buffer(remainder.length+data.length)
            remainder.copy(tmp)
            data.copy(tmp,remainder.length)
            data = tmp;
        }
        var start = 0;
        for(var i=0; i<data.length; i++){
            if(data[i] == 10){ //\n new line
                var line = data.slice(start,i)
                ev.emit("line", line)
                start = i+1;
            }
        }
        if(start<data.length){
            remainder = data.slice(start);
        }else{
            remainder = null;
        }
    })

    stream.on("end",function(){
        if(null!=remainder) ev.emit("line",remainder)
    })

    return ev
}


//---------main---------------
fileName = process.argv[2]

lineReader = createLineReader(fileName)
lineReader.on("line",function(line){
    console.log(line.toString())
    //console.log("++++++++++++++++++++")
})

Saya ingin mengatasi masalah yang sama ini, pada dasarnya seperti apa di Perl:

while (<>) {
    process_line($_);
}

Kasus penggunaan saya hanya skrip mandiri, bukan server, jadi sinkron baik-baik saja. Ini adalah kriteria saya:

• Kode sinkron minimal yang dapat digunakan kembali di banyak proyek.
• Tidak ada batasan ukuran file atau jumlah baris.
• Tidak ada batasan panjang garis.
• Mampu menangani Unicode penuh dalam UTF-8, termasuk karakter di luar BMP.
• Mampu menangani ujung * nix dan Windows (Mac gaya lama tidak diperlukan untuk saya).
• Karakter akhir baris untuk dimasukkan dalam baris.
• Mampu menangani baris terakhir dengan atau tanpa karakter end-of-line.
• Tidak menggunakan perpustakaan eksternal yang tidak termasuk dalam distribusi node.js.

Ini adalah proyek bagi saya untuk merasakan kode jenis scripting tingkat rendah di node.js dan memutuskan seberapa layak itu sebagai pengganti bahasa scripting lain seperti Perl.

Setelah sejumlah usaha yang mengejutkan dan beberapa kesalahan mulai ini adalah kode yang saya buat. Ini cukup cepat tetapi kurang sepele daripada yang saya harapkan: (bercabang di GitHub)

var fs            = require('fs'),
    StringDecoder = require('string_decoder').StringDecoder,
    util          = require('util');

function lineByLine(fd) {
  var blob = '';
  var blobStart = 0;
  var blobEnd = 0;

  var decoder = new StringDecoder('utf8');

  var CHUNK_SIZE = 16384;
  var chunk = new Buffer(CHUNK_SIZE);

  var eolPos = -1;
  var lastChunk = false;

  var moreLines = true;
  var readMore = true;

  // each line
  while (moreLines) {

    readMore = true;
    // append more chunks from the file onto the end of our blob of text until we have an EOL or EOF
    while (readMore) {

      // do we have a whole line? (with LF)
      eolPos = blob.indexOf('\n', blobStart);

      if (eolPos !== -1) {
        blobEnd = eolPos;
        readMore = false;

      // do we have the last line? (no LF)
      } else if (lastChunk) {
        blobEnd = blob.length;
        readMore = false;

      // otherwise read more
      } else {
        var bytesRead = fs.readSync(fd, chunk, 0, CHUNK_SIZE, null);

        lastChunk = bytesRead !== CHUNK_SIZE;

        blob += decoder.write(chunk.slice(0, bytesRead));
      }
    }

    if (blobStart < blob.length) {
      processLine(blob.substring(blobStart, blobEnd + 1));

      blobStart = blobEnd + 1;

      if (blobStart >= CHUNK_SIZE) {
        // blobStart is in characters, CHUNK_SIZE is in octets
        var freeable = blobStart / CHUNK_SIZE;

        // keep blob from growing indefinitely, not as deterministic as I'd like
        blob = blob.substring(CHUNK_SIZE);
        blobStart -= CHUNK_SIZE;
        blobEnd -= CHUNK_SIZE;
      }
    } else {
      moreLines = false;
    }
  }
}

Mungkin bisa dibersihkan lebih lanjut, itu adalah hasil coba-coba.

Dalam kebanyakan kasus ini seharusnya cukup:

const fs = require("fs")

fs.readFile('./file', 'utf-8', (err, file) => {
  const lines = file.split('\n')

  for (let line of lines)
    console.log(line)
});

Pembaca garis berbasis generator: https://github.com/neurosnap/gen-readlines

var fs = require('fs');
var readlines = require('gen-readlines');

fs.open('./file.txt', 'r', function(err, fd) {
  if (err) throw err;
  fs.fstat(fd, function(err, stats) {
    if (err) throw err;

    for (var line of readlines(fd, stats.size)) {
      console.log(line.toString());
    }

  });
});

Jika Anda ingin membaca file baris demi baris dan menulis ini di yang lain:

var fs = require('fs');
var readline = require('readline');
var Stream = require('stream');

function readFileLineByLine(inputFile, outputFile) {

   var instream = fs.createReadStream(inputFile);
   var outstream = new Stream();
   outstream.readable = true;
   outstream.writable = true;

   var rl = readline.createInterface({
      input: instream,
      output: outstream,
      terminal: false
   });

   rl.on('line', function (line) {
        fs.appendFileSync(outputFile, line + '\n');
   });
};

var fs = require('fs');

function readfile(name,online,onend,encoding) {
    var bufsize = 1024;
    var buffer = new Buffer(bufsize);
    var bufread = 0;
    var fd = fs.openSync(name,'r');
    var position = 0;
    var eof = false;
    var data = "";
    var lines = 0;

    encoding = encoding || "utf8";

    function readbuf() {
        bufread = fs.readSync(fd,buffer,0,bufsize,position);
        position += bufread;
        eof = bufread ? false : true;
        data += buffer.toString(encoding,0,bufread);
    }

    function getLine() {
        var nl = data.indexOf("\r"), hasnl = nl !== -1;
        if (!hasnl && eof) return fs.closeSync(fd), online(data,++lines), onend(lines); 
        if (!hasnl && !eof) readbuf(), nl = data.indexOf("\r"), hasnl = nl !== -1;
        if (!hasnl) return process.nextTick(getLine);
        var line = data.substr(0,nl);
        data = data.substr(nl+1);
        if (data[0] === "\n") data = data.substr(1);
        online(line,++lines);
        process.nextTick(getLine);
    }
    getLine();
}

Saya memiliki masalah yang sama dan muncul dengan solusi di atas terlihat mirip dengan yang lain tetapi aSync dan dapat membaca file besar dengan sangat cepat

Semoga ini bisa membantu

Saya memiliki modul kecil yang melakukan ini dengan baik dan digunakan oleh beberapa proyek lain npm readline Catatan thay di node v10 ada modul readline asli jadi saya menerbitkan kembali modul saya sebagai linebyline https://www.npmjs.com/package/ baris demi baris

jika Anda tidak ingin menggunakan modul, fungsinya sangat sederhana:

var fs = require('fs'),
EventEmitter = require('events').EventEmitter,
util = require('util'),
newlines = [
  13, // \r
  10  // \n
];
var readLine = module.exports = function(file, opts) {
if (!(this instanceof readLine)) return new readLine(file);

EventEmitter.call(this);
opts = opts || {};
var self = this,
  line = [],
  lineCount = 0,
  emit = function(line, count) {
    self.emit('line', new Buffer(line).toString(), count);
  };
  this.input = fs.createReadStream(file);
  this.input.on('open', function(fd) {
    self.emit('open', fd);
  })
  .on('data', function(data) {
   for (var i = 0; i < data.length; i++) {
    if (0 <= newlines.indexOf(data[i])) { // Newline char was found.
      lineCount++;
      if (line.length) emit(line, lineCount);
      line = []; // Empty buffer.
     } else {
      line.push(data[i]); // Buffer new line data.
     }
   }
 }).on('error', function(err) {
   self.emit('error', err);
 }).on('end', function() {
  // Emit last line if anything left over since EOF won't trigger it.
  if (line.length){
     lineCount++;
     emit(line, lineCount);
  }
  self.emit('end');
 }).on('close', function() {
   self.emit('close');
 });
};
util.inherits(readLine, EventEmitter);

Solusi lain adalah menjalankan logika melalui nsynjs executor berurutan . Bunyinya file baris demi baris menggunakan modul node readline, dan tidak menggunakan janji atau rekursi, karena itu tidak akan gagal pada file besar. Berikut adalah tampilannya:

var nsynjs = require('nsynjs');
var textFile = require('./wrappers/nodeReadline').textFile; // this file is part of nsynjs

function process(textFile) {

    var fh = new textFile();
    fh.open('path/to/file');
    var s;
    while (typeof(s = fh.readLine(nsynjsCtx).data) != 'undefined')
        console.log(s);
    fh.close();
}

var ctx = nsynjs.run(process,{},textFile,function () {
    console.log('done');
});

Kode di atas didasarkan pada contoh ini: https://github.com/amaksr/nsynjs/blob/master/examples/node-readline/index.js

Dua pertanyaan yang harus kita tanyakan pada diri sendiri saat melakukan operasi adalah:

1. Berapa jumlah memori yang digunakan untuk melakukan itu?
2. Apakah konsumsi memori meningkat secara drastis dengan ukuran file?

Solusi seperti require('fs').readFileSync()memuat seluruh file ke dalam memori. Itu berarti jumlah memori yang diperlukan untuk melakukan operasi akan hampir setara dengan ukuran file. Kita harus menghindari ini untuk hal yang lebih besar dari50mbs

Kita dapat dengan mudah melacak jumlah memori yang digunakan oleh suatu fungsi dengan menempatkan baris kode ini setelah pemanggilan fungsi:

    const used = process.memoryUsage().heapUsed / 1024 / 1024;
    console.log(
      `The script uses approximately ${Math.round(used * 100) / 100} MB`
    );

Saat ini cara terbaik untuk membaca baris tertentu dari file besar adalah dengan menggunakan node readline . Dokumentasi memiliki contoh luar biasa .

Meskipun kami tidak membutuhkan modul pihak ketiga untuk melakukannya. Tetapi, jika Anda menulis kode perusahaan, Anda harus menangani banyak kasus tepi. Saya harus menulis modul yang sangat ringan yang disebut Apick File Storage untuk menangani semua kasus tepi itu.

Modul Penyimpanan File Apick: https://www.npmjs.com/package/apickfs Dokumentasi: https://github.com/apickjs/apickFS#readme

Contoh file: https://1drv.ms/t/s!AtkMCsWInsSZiGptXYAFjalXOpUx

Contoh: Pasang modul

npm i apickfs

// import module
const apickFileStorage = require('apickfs');

//invoke readByLineNumbers() method
apickFileStorage
  .readByLineNumbers(path.join(__dirname), 'big.txt', [163845])
  .then(d => {
    console.log(d);
  })
  .catch(e => {
    console.log(e);
  });

Metode ini berhasil diuji dengan file padat hingga 4 GB.

big.text adalah file teks padat dengan 163.845 baris dan berukuran 124 Mb. Script untuk membaca 10 baris berbeda dari file ini hanya menggunakan sekitar 4,63 MB Memori saja. Dan mem-parsing JSON yang valid ke Objects atau Array secara gratis. 🥳 Luar Biasa !!

Kita dapat membaca satu baris file atau ratusan baris file dengan konsumsi memori yang sangat sedikit.

saya menggunakan ini:

function emitLines(stream, re){
    re = re && /\n/;
    var buffer = '';

    stream.on('data', stream_data);
    stream.on('end', stream_end);

    function stream_data(data){
        buffer += data;
        flush();
    }//stream_data

    function stream_end(){
        if(buffer) stream.emmit('line', buffer);
    }//stream_end


    function flush(){
        var re = /\n/;
        var match;
        while(match = re.exec(buffer)){
            var index = match.index + match[0].length;
            stream.emit('line', buffer.substring(0, index));
            buffer = buffer.substring(index);
            re.lastIndex = 0;
        }
    }//flush

}//emitLines

gunakan fungsi ini pada aliran dan dengarkan acara baris yang akan dipancarkan.

gr-

Meskipun Anda mungkin harus menggunakan readlinemodul seperti jawaban atas menyarankan, readlinetampaknya lebih berorientasi pada antarmuka baris perintah daripada membaca garis. Ini juga sedikit lebih buram tentang buffering. (Siapa pun yang membutuhkan pembaca berorientasi garis streaming mungkin ingin mengubah ukuran buffer). Modul readline adalah ~ 1000 baris sementara ini, dengan statistik dan tes, adalah 34.

const EventEmitter = require('events').EventEmitter;
class LineReader extends EventEmitter{
    constructor(f, delim='\n'){
        super();
        this.totalChars = 0;
        this.totalLines = 0;
        this.leftover = '';

        f.on('data', (chunk)=>{
            this.totalChars += chunk.length;
            let lines = chunk.split(delim);
            if (lines.length === 1){
                this.leftover += chunk;
                return;
            }
            lines[0] = this.leftover + lines[0];
            this.leftover = lines[lines.length-1];
            if (this.leftover) lines.pop();
            this.totalLines += lines.length;
            for (let l of lines) this.onLine(l);
        });
        // f.on('error', ()=>{});
        f.on('end', ()=>{console.log('chars', this.totalChars, 'lines', this.totalLines)});
    }
    onLine(l){
        this.emit('line', l);
    }
}
//Command line test
const f = require('fs').createReadStream(process.argv[2], 'utf8');
const delim = process.argv[3];
const lineReader = new LineReader(f, delim);
lineReader.on('line', (line)=> console.log(line));

Inilah versi yang lebih pendek, tanpa statistik, pada 19 baris:

class LineReader extends require('events').EventEmitter{
    constructor(f, delim='\n'){
        super();
        this.leftover = '';
        f.on('data', (chunk)=>{
            let lines = chunk.split(delim);
            if (lines.length === 1){
                this.leftover += chunk;
                return;
            }
            lines[0] = this.leftover + lines[0];
            this.leftover = lines[lines.length-1];
            if (this.leftover) 
                lines.pop();
            for (let l of lines)
                this.emit('line', l);
        });
    }
}

const fs = require("fs")

fs.readFile('./file', 'utf-8', (err, data) => {
var innerContent;
    console.log("Asynchronous read: " + data.toString());
    const lines = data.toString().split('\n')
    for (let line of lines)
        innerContent += line + '<br>';


});

Saya membungkus seluruh logika pemrosesan garis harian sebagai modul npm: line-kit https://www.npmjs.com/package/line-kit

// example
var count = 0
require('line-kit')(require('fs').createReadStream('/etc/issue'),
                    (line) => { count++; },
                    () => {console.log(`seen ${count} lines`)})

Saya menggunakan kode di bawah ini untuk membaca baris setelah memverifikasi bahwa ini bukan direktori dan tidak termasuk dalam daftar file tidak perlu diperiksa.

(function () {
  var fs = require('fs');
  var glob = require('glob-fs')();
  var path = require('path');
  var result = 0;
  var exclude = ['LICENSE',
    path.join('e2e', 'util', 'db-ca', 'someother-file'),
    path.join('src', 'favicon.ico')];
  var files = [];
  files = glob.readdirSync('**');

  var allFiles = [];

  var patternString = [
    'trade',
    'order',
    'market',
    'securities'
  ];

  files.map((file) => {
    try {
      if (!fs.lstatSync(file).isDirectory() && exclude.indexOf(file) === -1) {
        fs.readFileSync(file).toString().split(/\r?\n/).forEach(function(line){
          patternString.map((pattern) => {
            if (line.indexOf(pattern) !== -1) {
              console.log(file + ' contain `' + pattern + '` in in line "' + line +'";');
              result = 1;
            }
          });
        });
      }
    } catch (e) {
      console.log('Error:', e.stack);
    }
  });
  process.exit(result);

})();

Saya telah melihat semua jawaban di atas, semuanya menggunakan perpustakaan pihak ketiga untuk menyelesaikannya. Ini memiliki solusi sederhana di API Node. misalnya

const fs= require('fs')

let stream = fs.createReadStream('<filename>', { autoClose: true })

stream.on('data', chunk => {
    let row = chunk.toString('ascii')
}))