Escrevendo arquivos no Node.js

Há muitos detalhes no File System API. A forma mais comum é:

const fs = require('fs');

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

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

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

Actualmente existem três formas de escrever um ficheiro:

1. fs.write(fd, buffer, offset, length, position, callback)

   Você precisa esperar pelo retorno da chamada para garantir que o buffer seja gravado no disco. Não está em buffer.

2. 2. fs.writeFile(filename, data, [encoding], callback)

   Todos os dados devem ser armazenados ao mesmo tempo; não é possível realizar gravações seqüenciais.

3. fs.createWriteStream(path, [opções])

   Cria um WriteStream, o que é conveniente porque você não precisa esperar por uma ligação de retorno. Mas, mais uma vez, não é amortecido.

A WriteStream`, como o nome diz, é um fluxo. Um fluxo por definição é "um buffer" contendo dados que se movem em uma direção (fonte ► destino). Mas um fluxo gravável não é necessariamente "armazenado em buffer". Um stream é "em buffer" quando você escreve n vezes, e no momento n+1, o stream envia o buffer para o kernel (porque ele está cheio e precisa ser enxaguado).

Em outras palavras: "Um buffer" é o objecto. Se é ou não "tampão" é uma propriedade desse objeto.

Se você olhar para o código, o WriteStream herda de um objeto escrevível Stream. Se você prestar atenção, você verá como eles descarregam o conteúdo; eles não têm nenhum sistema de buffer.

Se você escrever uma string, ela é convertida em um buffer, e então enviada para a camada nativa e escrita em disco. Ao escrever strings, elas não estão preenchendo nenhum buffer. Então, se o fizeres:

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

Estás a fazer:

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

Isso são três chamadas para a camada I/O. Embora você esteja usando "buffers", os dados não são armazenados em buffer. Um fluxo em buffer faria: fs.write(new Buffer ("abc")), uma chamada para a camada de I/O.

A partir de agora, no Node.js v0.12 (versão estável anunciada 02/06/2015) agora suporta duas funções: cork() e uncork(). Parece que essas funções finalmente permitirão que você faça buffer/flush das chamadas de escrita.

Por exemplo, em Java existem algumas classes que fornecem fluxos buffered (BufferedOutputStream, BufferedWriter...). Se você escrever três bytes, esses bytes serão armazenados no buffer (memória) em vez de fazer uma chamada de E/S apenas por três bytes. Quando o buffer está cheio, o conteúdo é descarregado e salvo no disco. Isto melhora o desempenho.

Não estou a descobrir nada, só a lembrar-me como se deve fazer um acesso ao disco.

Você pode, claro, torná-lo um pouco mais avançado. Não bloquear, escrever pedaços e peças, não escrever o arquivo inteiro de uma só vez:

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