Question Écrire des fichiers dans Node.js


J'ai essayé de trouver un moyen d'écrire dans un fichier en utilisant Node.js, mais sans succès. Comment puis je faire ça?


1139
2018-03-23 00:25


origine


Réponses:


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

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

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

1807
2018-03-23 01:50



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

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

    Vous devez attendre le rappel pour vous assurer que le tampon est écrit sur le disque. Ce n'est pas tamponné.

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

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

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

    Crée un WriteStream, ce qui est pratique car vous n'avez pas besoin d'attendre un rappel. Mais encore une fois, ce n'est pas tamponné.

UNE WriteStream, comme son nom l'indique, est un flux. Un flux est par définition "un tampon" contenant des données qui se déplacent dans une direction (source ► destination). Mais un flux inscriptible n'est pas nécessairement "tamponné". Un flux est "tamponné" lorsque vous écrivez n fois, et à l'heure n+1, le flux envoie le tampon au noyau (car il est plein et doit être vidé).

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

Si vous regardez le code, le WriteStream hérite d'un écrit Stream objet. Si vous faites attention, vous verrez comment ils vident le contenu; ils n'ont pas de système tampon.

Si vous écrivez une chaîne, elle est convertie en tampon, puis envoyée à la couche native et écrite sur le disque. En écrivant des chaînes, ils ne remplissent aucun tampon. Donc, si vous faites:

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

Tu fais:

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

C'est Trois appels à la couche d'E / S. Bien que vous utilisiez des "tampons", les données ne sont pas mises en mémoire tampon. Un flux tamponné ferait: fs.write(new Buffer ("abc")), un appel à la couche d'E / S.

A partir de maintenant, dans Node.js v0.12 (version stable annoncée 02/06/2015) prend désormais en charge deux fonctions: cork() et uncork(). Il semble que ces fonctions vont enfin vous permettre de tamponner / vider les appels d'écriture.

Par exemple, en Java, certaines classes fournissent des flux tamponnés (BufferedOutputStream, BufferedWriter...). Si vous écrivez trois octets, ces octets seront stockés dans le tampon (mémoire) au lieu de faire un appel d'E / S seulement pour trois octets. Lorsque le tampon est plein, le contenu est vidé et enregistré sur le disque. Cela améliore les performances.

Je ne découvre rien, je me souviens juste comment un accès au disque devrait être fait.


430
2017-08-05 15:28



Vous pouvez bien sûr le rendre un peu plus avancé. Non-bloquant, écrit des morceaux, n'écrit pas le fichier entier à 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();
});

189
2017-12-16 14:40



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

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

38
2017-11-07 20:54



j'ai aimé Index de ./articles/file-system.

Cela a fonctionné pour moi.

Voir également Comment écrire des fichiers dans node.js?.

fs = require('fs');
fs.writeFile('helloworld.txt', 'Hello World!', function (err) {
    if (err) 
        return console.log(err);
    console.log('Wrote Hello World in file helloworld.txt, just check it');
});

Contenu de helloworld.txt:

Hello World!

Mettre à jour:
Comme dans le noeud Linux écrire dans le répertoire courant, il semble que dans d'autres pas, alors j'ajoute ce commentaire juste au cas où:
En utilisant ce ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); pour obtenir où le fichier est écrit.


20
2017-10-23 07:54



 var fs = require('fs');
 fs.writeFile(path + "\\message.txt", "Hello", function(err){
 if (err) throw err;
  console.log("success");
}); 

Par exemple: lisez le fichier et écrivez dans un autre fichier:

  var fs = require('fs');
    var path = process.cwd();
    fs.readFile(path+"\\from.txt",function(err,data)
                {
                    if(err)
                        console.log(err)
                    else
                        {
                            fs.writeFile(path+"\\to.text",function(erro){
                                if(erro)
                                    console.log("error : "+erro);
                                else
                                    console.log("success");
                            });
                        }
                });

5
2018-05-17 05:54



Écriture synchrone

fs.writeFileSync (fichier, données [, options])

fs = require('fs');

fs.writeFileSync("synchronous.txt", "synchronous write!")

Écriture asynchrone

fs.writeFile (fichier, données [, options], callback)

fs = require('fs');

fs.writeFile('asynchronous.txt', 'asynchronous write!', (err) => {
  if (err) throw err;
  console.log('The file has been saved!');
});

Étaient

file <string> | <Buffer> | <URL> | <integer> filename or file descriptor
data <string> | <Buffer> | <Uint8Array>
options <Object> | <string>
callback <Function>

Il vaut la peine de lire le système de fichiers officiel (fs) docs.


4
2017-10-01 05:39