L'écriture de fichiers dans NodeJS

Question

J'ai essayé de trouver une façon d'écrire de fichier lors de l'utilisation de NodeJS, mais sans succès. Pouvez-vous m'aider?

Answer 1

Il y a beaucoup de détails dans le système de fichiers de l'API. La façon la plus courante (autant que je sache) est:

var fs = require('fs');
fs.writeFile("/tmp/test", "Hey there!", function(err) {
    if(err) {
        console.log(err);
    } else {
        console.log("The file was saved!");
    }
}); 

Answer 2

Actuellement, il existe 3 façons d'écrire un fichier:

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

   Vous avez besoin d'attendre le rappel pour s'assurer que le tampon est écrit sur le disque. Il n'est pas mis en mémoire tampon.

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

   Toutes les données doivent être stockées dans le même temps; vous ne pouvez pas effectuer les écritures séquentielles.

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

   Crée un WriteStream, ce qui est pratique car vous n'avez pas besoin d'attendre pour un rappel. Mais encore une fois, il n'est pas mis en mémoire tampon.

Un WriteStream, comme son nom l'indique, est un flux. Un flux, par définition, est "un tampon contenant les données qui se déplace dans une direction (source ► destination). Mais une écriture stream n'est pas nécessairement "tampon". Un flux est "tampon" quand vous écrivez n temps, et au moment n+1, le flux envoie le buffer du noyau (parce que c'est plein et doit être vidé).

En d'autres termes: Un "tampon" est l'objet. Qu'il soit ou non "tampon" est une propriété de cet objet.

Si vous regardez le code, l' WriteStream hérite d'une écriture Stream objet. Si vous payez attention, vous allez voir comment ils s'en vider le contenu; ils n'ont pas de système tampon.

Si vous écrivez une chaîne de caractères, il est converti en mémoire tampon, puis envoyé à la couche indigène et écrites sur le disque. Lors de l'écriture de chaînes de caractères, ils ne sont pas du remplissage jusqu'à une mémoire tampon. Donc, si vous n':

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

Vous êtes en train de faire:

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

C'est 3 appels à l'I/O de la couche. Bien que vous êtes à l'aide de "tampons", les données ne sont pas mises en mémoire tampon. Un tampon de flux: fs.write(new Buffer ("abc")), 1 appel à l'I/O de la couche.

La prochaine version de Node (v0.12) ont 2 fonctions: cork() et uncork(). Il semble que ces fonctions va enfin vous permettre de tampon de rinçage/l'écriture des appels.

Par exemple, en Java il y a certaines classes qui fournissent en tampon de flux (BufferedOutputStream, BufferedWriter...). Si vous écrivez à 3 octets, ces octets seront stockées dans la mémoire tampon (de mémoire) au lieu de faire un appel d'e/S seulement pour les 3 octets. Lorsque le tampon est plein, le contenu est vidé et enregistré sur le disque. Cela améliore les performances.

Je ne suis pas de découvrir quoi que ce soit, juste se souvenir de la façon dont un accès disque qui devrait être fait.

Answer 3

Vous pouvez bien sûr en faire un peu plus en avance. Non bloquant, l'écriture de pièces et de morceaux, pas de l'écriture de l'ensemble du dossier à la fois.

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

Answer 4

var path = 'public/uploads/file.txt',
buffer = new Buffer("some content\n");

fs.open(path, 'w', function(err, fd) {
    if (err) {
        throw 'error opening file: ' + err;
    } else {
        fs.write(fd, buffer, 0, buffer.length, null, function(err) {
            if (err) throw 'error writing file: ' + err;
            fs.close(fd, function() {
                console.log('file written');
            })
        });
    }
});