Ich möchte eine sehr, sehr große Datei in ein JavaScript-Array in node.js lesen.

Also, wenn die Datei so ist:

first line
two 
three
...
...

Ich hätte das Array:

['first line','two','three', ... , ... ] 

Die Funktion würde folgendermaßen aussehen:

var array = load(filename); 

Daher ist die Idee, alles als Zeichenfolge zu laden und dann zu teilen, nicht akzeptabel.

Wenn Sie die endgültigen Daten in ein Array einpassen können, können Sie sie dann nicht auch in eine Zeichenfolge einfügen und aufteilen, wie vorgeschlagen wurde? Wenn Sie die Datei zeilenweise verarbeiten möchten, können Sie in jedem Fall auch Folgendes versuchen:

var fs = require('fs');

function readLines(input, func) {
  var remaining = '';

  input.on('data', function(data) {
    remaining += data;
    var index = remaining.indexOf('\n');
    while (index > -1) {
      var line = remaining.substring(0, index);
      remaining = remaining.substring(index + 1);
      func(line);
      index = remaining.indexOf('\n');
    }
  });

  input.on('end', function() {
    if (remaining.length > 0) {
      func(remaining);
    }
  });
}

function func(data) {
  console.log('Line: ' + data);
}

var input = fs.createReadStream('lines.txt');
readLines(input, func);

BEARBEITEN: (als Antwort auf einen Kommentar von phopkins ) Ich denke, dass (zumindest in neueren Versionen) Teilzeichenfolgen keine Daten kopieren, sondern ein spezielles SlicedString-Objekt erstellen (aus einem kurzen Blick auf den v8-Quellcode). In jedem Fall handelt es sich hier um eine Modifikation, die den erwähnten Teilstring vermeidet (getestet an einer Datei im Wert von mehreren Megabyte im Wert von "Alle Arbeit und kein Spiel machen Jack zu einem langweiligen Jungen"):

function readLines(input, func) {
  var remaining = '';

  input.on('data', function(data) {
    remaining += data;
    var index = remaining.indexOf('\n');
    var last  = 0;
    while (index > -1) {
      var line = remaining.substring(last, index);
      last = index + 1;
      func(line);
      index = remaining.indexOf('\n', last);
    }

    remaining = remaining.substring(last);
  });

  input.on('end', function() {
    if (remaining.length > 0) {
      func(remaining);
    }
  });
}

Synchron:

var fs = require('fs');
var array = fs.readFileSync('file.txt').toString().split("\n");
for(i in array) {
    console.log(array[i]);
}

Asynchron:

var fs = require('fs');
fs.readFile('file.txt', function(err, data) {
    if(err) throw err;
    var array = data.toString().split("\n");
    for(i in array) {
        console.log(array[i]);
    }
});

Unter Verwendung des Node.js Readline- Modul .

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

var filename = process.argv[2];
readline.createInterface({
    input: fs.createReadStream(filename),
    terminal: false
}).on('line', function(line) {
   console.log('Line: ' + line);
});

js:

var array = fs.readFileSync('file.txt', 'utf8').split('\n');

ts:

var array = fs.readFileSync('file.txt', 'utf8').toString().split('\n');

Verwenden Sie readline ( Dokumentation ). Hier ist ein Beispiel, in dem Sie eine CSS-Datei lesen, nach Symbolen analysieren und diese in json schreiben

var results = [];
  var rl = require('readline').createInterface({
    input: require('fs').createReadStream('./assets/stylesheets/_icons.scss')
  });


  // for every new line, if it matches the regex, add it to an array
  // this is ugly regex :)
  rl.on('line', function (line) {
    var re = /\.icon-icon.*:/;
    var match;
    if ((match = re.exec(line)) !== null) {
      results.push(match[0].replace(".",'').replace(":",''));
    }
  });


  // readline emits a close event when the file is read.
  rl.on('close', function(){
    var outputFilename = './icons.json';
    fs.writeFile(outputFilename, JSON.stringify(results, null, 2), function(err) {
        if(err) {
          console.log(err);
        } else {
          console.log("JSON saved to " + outputFilename);
        }
    });
  });

file.linesmit JFile-Paket

Pseudo

var JFile=require('jfile');

var myF=new JFile("./data.txt");
myF.lines // ["first line","second line"] ....

Vergiss vorher nicht:

npm install jfile --save

Mit einem BufferedReader sollte die Funktion jedoch asynchron sein:

var load = function (file, cb){
    var lines = [];
    new BufferedReader (file, { encoding: "utf8" })
        .on ("error", function (error){
            cb (error, null);
        })
        .on ("line", function (line){
            lines.push (line);
        })
        .on ("end", function (){
            cb (null, lines);
        })
        .read ();
};

load ("file", function (error, lines){
    if (error) return console.log (error);
    console.log (lines);
});

Ich möchte nur @finbarr großartige Antwort hinzufügen, eine kleine Korrektur im asynchronen Beispiel:

Asynchron:

var fs = require('fs');
fs.readFile('file.txt', function(err, data) {
    if(err) throw err;
    var array = data.toString().split("\n");
    for(i in array) {
        console.log(array[i]);
    }
    done();
});

@MadPhysicist, done () gibt den Async frei. Anruf.

Dies ist eine Variation der obigen Antwort von @mtomis.

Es entsteht ein Linienstrom. Es gibt "Daten" - und "End" -Ereignisse aus, sodass Sie das Ende des Streams verwalten können.

var events = require('events');

var LineStream = function (input) {
    var remaining = '';

    input.on('data', function (data) {
        remaining += data;
        var index = remaining.indexOf('\n');
        var last = 0;
        while (index > -1) {
            var line = remaining.substring(last, index);
            last = index + 1;
            this.emit('data', line);
            index = remaining.indexOf('\n', last);
        }
        remaining = remaining.substring(last);
    }.bind(this));

    input.on('end', function() {
        if (remaining.length > 0) {
            this.emit('data', remaining);
        }
        this.emit('end');
    }.bind(this));
}

LineStream.prototype = new events.EventEmitter;

Verwenden Sie es als Wrapper:

var lineInput = new LineStream(input);

lineInput.on('data', function (line) {
    // handle line
});

lineInput.on('end', function() {
    // wrap it up
});

Ich hatte das gleiche Problem und habe es mit dem Modul Zeile für Zeile gelöst

https://www.npmjs.com/package/line-by-line

Zumindest für mich funktioniert es wie ein Zauber, sowohl im synchronen als auch im asynchronen Modus.

Außerdem kann das Problem mit nicht terminierenden Leitungen \ n mit der folgenden Option gelöst werden:

{ encoding: 'utf8', skipEmptyLines: false }

Synchrone Verarbeitung von Zeilen:

var LineByLineReader = require('line-by-line'),
    lr = new LineByLineReader('big_file.txt');

lr.on('error', function (err) {
    // 'err' contains error object
});

lr.on('line', function (line) {
    // 'line' contains the current line without the trailing newline character.
});

lr.on('end', function () {
    // All lines are read, file is closed now.
}); 

Die Verwendung von Node.js v8 oder höher verfügt über eine neue Funktion, die die normale Funktion in eine asynchrone Funktion umwandelt.

util.promisify

Es ist eine großartige Funktion. Hier ist das Beispiel für das Parsen von 10000 Zahlen aus der txt-Datei in ein Array, wobei Inversionen mithilfe der Zusammenführungssortierung für die Zahlen gezählt werden.

// read from txt file
const util = require('util');
const fs = require('fs')
fs.readFileAsync = util.promisify(fs.readFile);
let result = []

const parseTxt = async (csvFile) => {
  let fields, obj
  const data = await fs.readFileAsync(csvFile)
  const str = data.toString()
  const lines = str.split('\r\n')
  // const lines = str
  console.log("lines", lines)
  // console.log("str", str)

  lines.map(line => {
    if(!line) {return null}
    result.push(Number(line))
  })
  console.log("result",result)
  return result
}
parseTxt('./count-inversion.txt').then(() => {
  console.log(mergeSort({arr: result, count: 0}))
})

Um eine große Datei in ein Array einzulesen, können Sie Zeile für Zeile oder Block für Block lesen.

Zeile für Zeile beziehen Sie sich auf meine Antwort hier

var fs = require('fs'),
    es = require('event-stream'),

var lines = [];

var s = fs.createReadStream('filepath')
    .pipe(es.split())
    .pipe(es.mapSync(function(line) {
        //pause the readstream
        s.pause();
        lines.push(line);
        s.resume();
    })
    .on('error', function(err) {
        console.log('Error:', err);
    })
    .on('end', function() {
        console.log('Finish reading.');
        console.log(lines);
    })
);

Stück für Stück finden Sie in diesem Artikel

var offset = 0;
var chunkSize = 2048;
var chunkBuffer = new Buffer(chunkSize);
var fp = fs.openSync('filepath', 'r');
var bytesRead = 0;
while(bytesRead = fs.readSync(fp, chunkBuffer, 0, chunkSize, offset)) {
    offset += bytesRead;
    var str = chunkBuffer.slice(0, bytesRead).toString();
    var arr = str.split('\n');

    if(bytesRead = chunkSize) {
        // the last item of the arr may be not a full line, leave it to the next chunk
        offset -= arr.pop().length;
    }
    lines.push(arr);
}
console.log(lines);