Czyta plik po jednym wierszu na raz w node.js?

Próbuję odczytać duży plik po jednym wierszu na raz. Znalazłem pytanie na temat Quory, które dotyczyło tego tematu, ale brakuje mi niektórych powiązań, aby wszystko to połączyć.

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

Chciałbym dowiedzieć się, jak mógłbym czytać jedną linię na raz z pliku zamiast STDIN, jak w tym przykładzie.

Próbowałem:

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

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

ale to nie działa. Wiem, że w mgnieniu oka mogłem wrócić do używania czegoś takiego jak PHP, ale chciałbym to rozgryźć.

Nie sądzę, aby druga odpowiedź działała, ponieważ plik jest znacznie większy niż serwer, na którym go uruchamiam, ma pamięć.

Od wersji Node.js v0.12 i od wersji Node.js v4.0.0 istnieje stabilny moduł podstawowy readline . Oto najprostszy sposób odczytu linii z pliku, bez żadnych zewnętrznych modułów:

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

Lub alternatywnie:

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

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

Ostatni wiersz jest odczytywany poprawnie (od Node v0.12 lub nowszego), nawet jeśli nie ma końcowego \n.

AKTUALIZACJA : ten przykład został dodany do oficjalnej dokumentacji API Node .

W przypadku tak prostej operacji nie powinno być żadnej zależności od modułów innych firm. Spokojnie.

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

Nie musisz do openpliku, ale zamiast tego musisz utworzyć ReadStream.

fs.createReadStream

Następnie przekaż ten strumień do Lazy

jest bardzo ładny moduł do odczytu pliku linia po linii, nazywa się on czytnikiem linii

dzięki temu po prostu piszesz:

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

możesz nawet iterować plik za pomocą interfejsu w stylu Java, jeśli potrzebujesz większej kontroli:

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

Aktualizacja w 2019 r

Niesamowity przykład opublikowano już w oficjalnej dokumentacji Nodejsa. tutaj

Wymaga to zainstalowania najnowszego oprogramowania Nodejs na twoim komputerze. > 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();

Stary temat, ale to działa:

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

Prosty. Nie potrzeba zewnętrznego modułu.

Zawsze możesz rzucić własny czytnik linii. Jeszcze nie przetestowałem tego fragmentu, ale poprawnie dzieli on przychodzący strumień fragmentów na linie bez końcowego „\ 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();

Wpadłem na to podczas pracy nad szybkim skryptem parsującym dziennik, który musiał gromadzić dane podczas parsowania dziennika i czułem, że fajnie byłoby spróbować to zrobić przy użyciu js i node zamiast perla lub bash.

W każdym razie uważam, że małe skrypty nodejs powinny być samodzielne, a nie polegać na modułach stron trzecich, więc po przeczytaniu wszystkich odpowiedzi na to pytanie, z których każdy używa różnych modułów do parsowania linii, interesujące może być nodejskie rozwiązanie 13 SLOC.

Z modułem nośnym :

var carrier = require('carrier');

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

Skończyło się na masywnym przecieku pamięci przy użyciu Lazy do odczytu linii po linii podczas próby przetworzenia tych linii i zapisania ich do innego strumienia ze względu na sposób, w jaki działa odpływ / pauza / wznowienie w węźle (patrz: http: // elegantcode .com / 2011/04/06 / taking-baby-steps-with-node-js-pumping-data-between-streams / (I love this guy btw)). Nie spojrzałem wystarczająco uważnie na Lazy'ego, aby dokładnie zrozumieć, dlaczego, ale nie mogłem wstrzymać strumienia odczytu, aby pozwolić na drenaż bez wyjścia Lazy'ego.

Napisałem kod do przetwarzania ogromnych plików csv na dokumenty XML, możesz zobaczyć kod tutaj: https://github.com/j03m/node-csv2xml

Jeśli uruchomisz poprzednie wersje z linią Lazy, wycieka. Najnowsza wersja wcale nie wycieka i prawdopodobnie możesz użyć jej jako podstawy dla czytnika / procesora. Chociaż mam tam trochę niestandardowych rzeczy.

Edycja: Myślę, że powinienem również zauważyć, że mój kod z Lazy działał dobrze, dopóki nie znalazłem pisania wystarczająco dużych fragmentów xml, które wyczerpują / wstrzymują / wznawiają z konieczności. W przypadku mniejszych kawałków było w porządku.

Edytować:

Użyj strumienia transformacji .

Za pomocą BufferedReadera możesz czytać wiersze.

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

Od czasu opublikowania mojej oryginalnej odpowiedzi stwierdziłem, że split jest bardzo łatwym w użyciu modułem węzła do odczytu linii w pliku; Który akceptuje również parametry opcjonalne.

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

Nie testowałem na bardzo dużych plikach. Daj nam znać, jeśli tak.

Byłem sfrustrowany brakiem kompleksowego rozwiązania tego problemu, więc przygotowałem własną próbę ( git / npm ). Skopiowana lista funkcji:

• Interaktywne przetwarzanie linii (oparte na wywołaniu zwrotnym, bez ładowania całego pliku do pamięci RAM)
• Opcjonalnie zwróć wszystkie wiersze w tablicy (tryb szczegółowy lub surowy)
• Interaktywnie przerywaj przesyłanie strumieniowe lub wykonaj przetwarzanie typu mapa / filtr
• Wykryj dowolną konwencję nowego wiersza (PC / Mac / Linux)
• Prawidłowe leczenie EOF / ostatniej linii
• Prawidłowa obsługa wielobajtowych znaków UTF-8
• Pobieranie informacji o przesunięciu bajtów i długości bajtów dla poszczególnych linii
• Dostęp przypadkowy, z wykorzystaniem przesunięć liniowych lub bajtowych
• Automatycznie mapuj informacje o przesunięciu linii, aby przyspieszyć losowy dostęp
• Zero zależności
• Testy

NIH? Ty decydujesz :-)

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("++++++++++++++++++++")
})

Chciałem rozwiązać ten sam problem, w zasadzie w Perlu:

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

Mój przypadek użycia był tylko samodzielnym skryptem, a nie serwerem, więc synchronizacja była w porządku. To były moje kryteria:

• Minimalny kod synchroniczny, który można ponownie wykorzystać w wielu projektach.
• Brak ograniczeń rozmiaru pliku lub liczby linii.
• Brak ograniczeń długości linii.
• Potrafi obsłużyć pełny Unicode w UTF-8, w tym znaki poza BMP.
• W stanie obsłużyć * nix i zakończenia linii Windows (Mac w starym stylu nie jest dla mnie potrzebny).
• Znaki końca linii, które mają być zawarte w wierszach.
• W stanie obsłużyć ostatni wiersz ze znakami końca linii lub bez nich.
• Nie używaj żadnych zewnętrznych bibliotek nieuwzględnionych w dystrybucji node.js.

Jest to dla mnie projekt, aby zapoznać się z kodem typu skryptowego niskiego poziomu w node.js i zdecydować, jak opłacalne jest to zastąpienie innych języków skryptowych, takich jak Perl.

Po zaskakującym nakładzie pracy i kilku fałszywych startach jest to kod, który wymyśliłem. Jest dość szybki, ale mniej trywialny, niż bym się spodziewał: (rozwidl go na 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;
    }
  }
}

Prawdopodobnie można go jeszcze wyczyścić, to wynik prób i błędów.

W większości przypadków powinno to wystarczyć:

const fs = require("fs")

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

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

Czytnik linii oparty na generatorze: 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());
    }

  });
});

Jeśli chcesz przeczytać plik wiersz po wierszu i zapisać go w innym:

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

Miałem ten sam problem i wymyśliłem powyższe rozwiązanie, które wygląda podobnie dla innych, ale jest aSync i może bardzo szybko odczytywać duże pliki

Mam nadzieję, że to pomoże

Mam mały moduł, który robi to dobrze i jest używany w wielu innych projektach npm readline. Uwaga: w węźle v10 jest natywny moduł readline, więc ponownie opublikowałem mój moduł jako linebyline https://www.npmjs.com/package/ linebyline

jeśli nie chcesz korzystać z modułu, funkcja jest bardzo prosta:

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

Innym rozwiązaniem jest uruchomienie logiki za pomocą sekwencyjnego modułu wykonującego nsynjs . Czyta plik linia po linii za pomocą modułu readline węzła i nie używa obietnic ani rekurencji, dlatego nie zawiedzie dużych plików. Oto jak będzie wyglądał kod:

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

Powyższy kod oparty jest na tym przykładzie: https://github.com/amaksr/nsynjs/blob/master/examples/node-readline/index.js

Dwa pytania, które musimy sobie zadać podczas wykonywania takich operacji, to:

1. Jaka ilość pamięci została użyta do jej wykonania?
2. Czy zużycie pamięci gwałtownie rośnie wraz z rozmiarem pliku?

Rozwiązania takie jak require('fs').readFileSync()ładują cały plik do pamięci. Oznacza to, że ilość pamięci wymagana do wykonania operacji będzie prawie równa rozmiarowi pliku. Powinniśmy tego unikać w przypadku czegoś większego niż50mbs

Możemy łatwo śledzić ilość pamięci używanej przez funkcję, umieszczając następujące wiersze kodu po wywołaniu funkcji:

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

W tej chwili najlepszym sposobem na odczyt poszczególnych linii z dużego pliku jest użycie readline węzła . Dokumentacja zawiera niesamowite przykłady .

Chociaż nie potrzebujemy do tego żadnego modułu innej firmy. Ale jeśli piszesz kod korporacyjny, musisz obsłużyć wiele przypadkowych przypadków. Musiałem napisać bardzo lekki moduł o nazwie Apick File Storage aby obsłużyć wszystkie te przypadki brzegowe.

Moduł przechowywania plików Apick: https://www.npmjs.com/package/apickfs Dokumentacja: https://github.com/apickjs/apickFS#readme

Przykładowy plik: https://1drv.ms/t/s!AtkMCsWInsSZiGptXYAFjalXOpUx

Przykład: zainstaluj moduł

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

Ta metoda została pomyślnie przetestowana z gęstymi plikami do 4 GB.

big.text to gęsty plik tekstowy z 163 845 liniami i ma 124 Mb. Skrypt do odczytu 10 różnych wierszy z tego pliku zużywa tylko około 4,63 MB pamięci. I za darmo analizuje prawidłowy JSON na Objects lub Arrays. 🥳 Niesamowite !!

Możemy odczytać jedną linię pliku lub setki linii pliku przy bardzo małym zużyciu pamięci.

używam tego:

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

użyj tej funkcji w strumieniu i nasłuchuj emitowanych zdarzeń linii.

gr-

Chociaż prawdopodobnie powinieneś użyć readlinemodułu, jak sugeruje górna odpowiedź, readlinewydaje się być zorientowany raczej na interfejsy linii poleceń niż na czytanie linii. Jest również nieco bardziej nieprzejrzysty w zakresie buforowania. (Każdy, kto potrzebuje czytnika zorientowanego na przesyłanie strumieniowe, prawdopodobnie będzie chciał dostosować rozmiary buforów). Moduł readline ma ~ 1000 linii, podczas gdy ten, ze statystykami i testami, ma 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));

Oto jeszcze krótsza wersja, bez statystyk, w 19 liniach:

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>';


});

Opieram całą logikę codziennego przetwarzania linii jako moduł 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`)})

Używam poniżej kodu linii odczytu po sprawdzeniu, że nie jest to katalog i nie ma go na liście plików, nie trzeba go sprawdzać.

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

})();

Przejrzałem wszystkie powyższe odpowiedzi, wszystkie wykorzystują bibliotekę innej firmy do rozwiązania tego problemu. Ma proste rozwiązanie w interfejsie API Node. na przykład

const fs= require('fs')

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

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