Wie füge ich eine Datei in Node hinzu?

Ich versuche, eine Zeichenfolge an eine Protokolldatei anzuhängen . WriteFile löscht den Inhalt jedoch jedes Mal, bevor die Zeichenfolge geschrieben wird.

fs.writeFile('log.txt', 'Hello Node', function (err) {
  if (err) throw err;
  console.log('It\'s saved!');
}); // => message.txt erased, contains only 'Hello Node'

Irgendeine Idee, wie man das auf einfache Weise macht?

Für gelegentliche Anhänge können Sie verwenden appendFile, wodurch bei jedem Aufruf ein neues Dateihandle erstellt wird:

Asynchron :

const fs = require('fs');

fs.appendFile('message.txt', 'data to append', function (err) {
  if (err) throw err;
  console.log('Saved!');
});

Synchron :

const fs = require('fs');

fs.appendFileSync('message.txt', 'data to append');

Wenn Sie jedoch wiederholt an dieselbe Datei anhängen, ist es viel besser, das Dateihandle wiederzuverwenden .

Wenn Sie in einer Log - Datei schreiben wollen, das heißt Daten an das Ende einer Datei anhängen, nie verwenden appendFile. appendFileÖffnet ein Dateihandle für jedes Datenelement, das Sie Ihrer Datei hinzufügen. Nach einer Weile wird eine schöne EMFILEFehlermeldung angezeigt.

Ich kann hinzufügen, dass appendFiledas nicht einfacher zu bedienen ist als ein WriteStream.

Beispiel mit appendFile:

console.log(new Date().toISOString());
[...Array(10000)].forEach( function (item,index) {
    fs.appendFile("append.txt", index+ "\n", function (err) {
        if (err) console.log(err);
    });
});
console.log(new Date().toISOString());

Bis zu 8000 auf meinem Computer können Sie Daten an die Datei anhängen, dann erhalten Sie Folgendes:

{ Error: EMFILE: too many open files, open 'C:\mypath\append.txt'
    at Error (native)
  errno: -4066,
  code: 'EMFILE',
  syscall: 'open',
  path: 'C:\\mypath\\append.txt' }

Außerdem appendFilewird geschrieben, wenn es aktiviert ist, sodass Ihre Protokolle nicht per Zeitstempel geschrieben werden. Sie können mit Beispiel testen, 1000 anstelle von 100000 setzen, die Reihenfolge ist zufällig, hängt vom Zugriff auf die Datei ab.

Wenn Sie an eine Datei anhängen möchten, müssen Sie einen beschreibbaren Stream wie den folgenden verwenden:

var stream = fs.createWriteStream("append.txt", {flags:'a'});
console.log(new Date().toISOString());
[...Array(10000)].forEach( function (item,index) {
    stream.write(index + "\n");
});
console.log(new Date().toISOString());
stream.end();

Sie beenden es, wenn Sie wollen. Sie müssen nicht einmal verwenden stream.end(), die Standardoption ist AutoClose:true, sodass Ihre Datei endet, wenn Ihr Prozess endet und Sie vermeiden, zu viele Dateien zu öffnen.

Ihr Code, der createWriteStream verwendet, erstellt für jeden Schreibvorgang einen Dateideskriptor. log.end ist besser, weil es den Knoten auffordert, unmittelbar nach dem Schreiben zu schließen.

var fs = require('fs');
var logStream = fs.createWriteStream('log.txt', {flags: 'a'});
// use {flags: 'a'} to append and {flags: 'w'} to erase and write a new file
logStream.write('Initial line...');
logStream.end('this is the end line');

Außerdem appendFilekönnen Sie ein Flag übergeben writeFile, um Daten an eine vorhandene Datei anzuhängen.

fs.writeFile('log.txt', 'Hello Node',  {'flag':'a'},  function(err) {
    if (err) {
        return console.error(err);
    }
});

Durch Übergeben des Flags 'a' werden Daten am Ende der Datei angehängt.

Sie müssen es öffnen und dann darauf schreiben.

var fs = require('fs'), str = 'string to append to file';
fs.open('filepath', 'a', 666, function( e, id ) {
  fs.write( id, 'string to append to file', null, 'utf8', function(){
    fs.close(id, function(){
      console.log('file closed');
    });
  });
});

Hier sind einige Links, die zur Erläuterung der Parameter beitragen

offen
schreiben
schließen

BEARBEITEN : Diese Antwort ist nicht mehr gültig. Sehen Sie sich die neue Methode fs.appendFile zum Anhängen an.

Node.js 0.8 hat fs.appendFile:

fs.appendFile('message.txt', 'data to append', (err) => {
  if (err) throw err;
  console.log('The "data to append" was appended to file!');
});

Dokumentation

fd = fs.openSync(path.join(process.cwd(), 'log.txt'), 'a')
fs.writeSync(fd, 'contents to append')
fs.closeSync(fd)

Wenn Sie auf einfache und stressfreie Weise zeilenweise Protokolle in eine Datei schreiben möchten, empfehle ich fs-extra :

const os = require('os');
const fs = require('fs-extra');

const file = 'logfile.txt';
const options = {flag: 'a'};

async function writeToFile(text) {
  await fs.outputFile(file, `${text}${os.EOL}`, options);
}

writeToFile('First line');
writeToFile('Second line');
writeToFile('Third line');
writeToFile('Fourth line');
writeToFile('Fifth line');

Getestet mit Node v8.9.4.

Mein Ansatz ist etwas Besonderes. Ich benutze im Grunde die WriteStreamLösung, aber ohne das fd tatsächlich mit zu "schließen" stream.end(). Stattdessen benutze ich cork/uncork . Dies hatte den Vorteil einer geringen RAM-Auslastung (wenn dies für jemanden von Bedeutung ist) und ich glaube, dass es sicherer für die Protokollierung / Aufzeichnung ist (mein ursprünglicher Anwendungsfall).

Das Folgende ist ein ziemlich einfaches Beispiel. Beachten Sie, dass ich gerade eine Pseudo- forSchleife für die Präsentation hinzugefügt habe - im Produktionscode warte ich auf Websocket-Nachrichten.

var stream = fs.createWriteStream("log.txt", {flags:'a'});
for(true) {
  stream.cork();
  stream.write("some content to log");
  process.nextTick(() => stream.uncork());
}

uncork Leert die Daten im nächsten Tick in die Datei.

In meinem Szenario gibt es Spitzenwerte von bis zu ~ 200 Schreibvorgängen pro Sekunde in verschiedenen Größen. In der Nacht werden jedoch nur eine Handvoll Schreibvorgänge pro Minute benötigt. Der Code funktioniert auch in Spitzenzeiten sehr zuverlässig.

Ich biete diesen Vorschlag nur an, weil die Kontrolle über geöffnete Flags manchmal nützlich ist. Sie möchten beispielsweise zuerst eine vorhandene Datei abschneiden und dann eine Reihe von Schreibvorgängen anhängen. Verwenden Sie in diesem Fall beim Öffnen der Datei das Flag 'w' und schließen Sie es erst, wenn alle Schreibvorgänge abgeschlossen sind. Natürlich kann appendFile das sein, wonach Sie suchen :-)

  fs.open('log.txt', 'a', function(err, log) {
    if (err) throw err;
    fs.writeFile(log, 'Hello Node', function (err) {
      if (err) throw err;
      fs.close(log, function(err) {
        if (err) throw err;
        console.log('It\'s saved!');
      });
    });
  });

Verwenden des jfile- Pakets:

myFile.text+='\nThis is new line to be appended'; //myFile=new JFile(path);

Verwenden von fs.appendFileoderfsPromises.appendFile sind die schnellsten und robustesten Optionen, wenn Sie etwas an eine Datei anhängen müssen.

Im Gegensatz zu einigen der vorgeschlagenen Antworten wird der Dateipfad, wenn er an die appendFileFunktion übergeben wird, tatsächlich von selbst geschlossen . Nur wenn Sie ein Dateihandle übergeben, das Sie von so etwas bekommen, müssen fs.open()Sie darauf achten, es zu schließen.

Ich habe es mit über 50.000 Zeilen in einer Datei versucht.

Beispiele:

(async () => {
  // using appendFile.
  const fsp = require('fs').promises;
  await fsp.appendFile(
    '/path/to/file', '\r\nHello world.'
  );

  // using apickfs; handles error and edge cases better.
  const apickFileStorage = require('apickfs');
  await apickFileStorage.writeLines(
    '/path/to/directory/', 'filename', 'Hello world.'
  );
})();

Ref: https://github.com/nodejs/node/issues/7560
Beispielausführung: https://github.com/apickjs/apickFS/blob/master/writeLines.js

Hier ist ein vollständiges Skript. Geben Sie Ihre Dateinamen ein und führen Sie es aus und es sollte funktionieren! Hier ist ein Video-Tutorial zur Logik hinter dem Skript.

var fs = require('fs');

function ReadAppend(file, appendFile){
  fs.readFile(appendFile, function (err, data) {
    if (err) throw err;
    console.log('File was read');

    fs.appendFile(file, data, function (err) {
      if (err) throw err;
      console.log('The "data to append" was appended to file!');

    });
  });
}
// edit this with your file names
file = 'name_of_main_file.csv';
appendFile = 'name_of_second_file_to_combine.csv';
ReadAppend(file, appendFile);

Ein einfacher Weg, dies zu tun, ist

const fs = require('fs');
fs.appendFileSync('file.txt', 'message to append into file');

const inovioLogger = (logger = "") => {
    const log_file = fs.createWriteStream(__dirname + `/../../inoviopay-${new Date().toISOString().slice(0, 10)}.log`, { flags: 'a' });
    const log_stdout = process.stdout;
    log_file.write(logger + '\n');
}

Zusätzlich zur Antwort von appendFiledenysonique werden in NodeJS manchmal asynchrone und andere asynchrone Methoden verwendet, bei denen Versprechen zurückgegeben werden, anstatt Rückrufe weiterzuleiten. Dazu müssen Sie die Funktion mit promisifyHOF umschließen oder asynchrone Funktionen aus dem versprochenen Namespace importieren:

const { appendFile } = require('fs').promises;

await appendFile('path/to/file/to/append', dataToAppend, optionalOptions);

Ich hoffe es wird helfen 😉