Bestanden schrijven in Node.js

Er zijn een heleboel details in de File System API. De meest gebruikelijke manier is:

const fs = require('fs');

fs.writeFile("/tmp/test", "Hey there!", function(err) {

    if(err) {
        return console.log(err);
    }

    console.log("The file was saved!");
}); 

Momenteel zijn er drie manieren om een bestand te schrijven:

1. fs.write(fd, buffer, offset, lengte, positie, callback)

   Je moet wachten op de callback om ervoor te zorgen dat de buffer naar schijf wordt geschreven. Het is niet gebufferd.

2. fs.writeFile(bestandsnaam, gegevens, [codering], callback)

   Alle gegevens moeten tegelijkertijd worden opgeslagen; u kunt geen sequentiële schrijfacties uitvoeren.

3. fs.createWriteStream(path, [options])

   Creëert een WriteStream, wat handig is omdat je'niet op een callback hoeft te wachten. Maar nogmaals, het'is niet gebufferd.

Een WriteStream, zoals de naam al zegt, is een stream. Een stream is per definitie "een buffer" met data die in één richting beweegt (bron ► bestemming). Maar een beschrijfbare stream is niet noodzakelijkerwijs "gebufferd". Een stream is "gebufferd" als je n keer schrijft, en op tijdstip n+1, stuurt de stream de buffer naar de kernel (omdat hij'vol is en doorgespoeld moet worden).

Met andere woorden: "Een buffer" is het object. Of het al dan niet "gebufferd wordt" is een eigenschap van dat object.

Als je naar de code kijkt, erft de WriteStream van een beschrijfbaar Stream object. Als je goed oplet, zie je hoe ze de inhoud doorspoelen; ze hebben geen buffersysteem.

Als je een string schrijft, wordt het geconverteerd naar een buffer, en dan naar de native laag gestuurd en naar schijf geschreven. Wanneer je strings schrijft, vullen ze geen enkele buffer. Dus, als je dat doet:

write("a")
write("b")
write("c")

Je bent bezig:

fs.write(new Buffer("a"))
fs.write(new Buffer("b"))
fs.write(new Buffer("c"))

Dat zijn drie aanroepen naar de I/O laag. Hoewel je "buffers" gebruikt, is de data niet gebufferd. Een gebufferde stream zou doen: fs.write(new Buffer ("abc")), één aanroep aan de I/O laag.

Vanaf nu, in Node.js v0.12 (stabiele versie aangekondigd 02/06/2015) ondersteunt nu twee functies: cork() en uncork(). Het lijkt erop dat deze functies je eindelijk in staat stellen om de schrijfaanroepen te bufferen/flushen.

Bijvoorbeeld, in Java zijn er enkele klassen die gebufferde streams aanbieden (BufferedOutputStream, BufferedWriter...). Als je drie bytes schrijft, zullen deze bytes worden opgeslagen in de buffer (geheugen) in plaats van een I/O oproep te doen voor slechts drie bytes. Als de buffer vol is, wordt de inhoud doorgespoeld en op schijf opgeslagen. Dit verbetert de prestaties.

Ik'ben niets aan het ontdekken, alleen aan het herinneren hoe een schijf toegang zou moeten worden gedaan.

Je kunt het natuurlijk een beetje geavanceerder maken. Non-blocking, stukjes en beetjes schrijven, niet het hele bestand in een keer:

var fs = require('fs');
var stream = fs.createWriteStream("my_file.txt");
stream.once('open', function(fd) {
  stream.write("My first row\n");
  stream.write("My second row\n");
  stream.end();
});