Écriture de fichiers dans Node.js

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

Il y a beaucoup de détails dans l' API du système de fichiers . La manière la plus courante est:

const fs = require('fs');

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

// Or
fs.writeFileSync('/tmp/test-sync', 'Hey there!');

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 mis en mémoire tampon.

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 mis en mémoire tampon.

A WriteStream, comme son nom l'indique, est un flux. Un flux par définition est «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 des nheures, et à un moment donné 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, l' WriteStreamhérite d'un Streamobjet accessible en écriture . Si vous faites attention, vous verrez comment ils vident le contenu; ils n'ont pas de système de mise en mémoire tampon.

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

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

Tu fais:

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

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

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

Par exemple, en Java, certaines classes fournissent des flux mis en mémoire tampon ( BufferedOutputStream,BufferedWriter ...). Si vous écrivez trois octets, ces octets seront stockés dans le tampon (mémoire) au lieu d'effectuer un appel d'E / S uniquement 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 doit être fait.

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

É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], rappel)

fs = require('fs');

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

Où

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

Lire le système vaut fichier fs (offical) docs .

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

J'ai aimé Index of ./articles/file-system .

Ça a marché pour moi.

Voir aussi 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!

Mise à jour:
Comme dans le nœud Linux, écrivez dans le répertoire actuel, il semble que dans certains autres non, alors j'ajoute ce commentaire juste au cas où: l'
utiliser ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH);pour obtenir où le fichier est écrit.

Les réponses fournies sont datées et une nouvelle façon de procéder est:

const fsPromises = require('fs').promises
await fsPromises.writeFile('/path/to/file.txt', 'data to write')

voir les documents ici pour plus d'informations

Je sais que la question posée sur "écrire" mais dans un sens plus général "ajouter" pourrait être utile dans certains cas car il est facile à utiliser en boucle pour ajouter du texte à un fichier (que le fichier existe ou non). Utilisez un "\ n" si vous souhaitez ajouter des lignes, par exemple:

var fs = require('fs');
for (var i=0; i<10; i++){
    fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}

OK, c'est assez simple car Node a une fonctionnalité intégrée pour cela, cela s'appelle fsqui signifie File System et, fondamentalement, NodeJS File System module ...

Vous devez donc d'abord l'exiger dans votre fichier server.js comme ceci:

var fs = require('fs');

fsa peu de méthodes pour écrire dans un fichier, mais ma façon préférée est d'utiliser appendFile, cela ajoutera le contenu au fichier et si le fichier n'existe pas, en créera un, le code pourrait être comme ci-dessous:

fs.appendFile('myFile.txt', 'Hi Ali!', function (err) {
  if (err) throw err;
  console.log('Thanks, It\'s saved to the file!');
});

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

Par exemple: lire un fichier et écrire 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");
                            });
                        }
                });

Vous pouvez écrire dans un fichier en utilisant le module fs (système de fichiers).

Voici un exemple de la façon dont vous pouvez le faire:

const fs = require('fs');

const writeToFile = (fileName, callback) => {
  fs.open(fileName, 'wx', (error, fileDescriptor) => {
    if (!error && fileDescriptor) {
      // Do something with the file here ...
      fs.writeFile(fileDescriptor, newData, (error) => {
        if (!error) {
          fs.close(fileDescriptor, (error) => {
            if (!error) {
              callback(false);
            } else {
              callback('Error closing the file');
            }
          });
        } else {
          callback('Error writing to new file');
        }
      });
    } else {
      callback('Could not create new file, it may already exists');
    }
  });
};

Vous voudrez peut-être également vous débarrasser de cette structure de code de rappel à l'intérieur en utilisant Promises et async/await instructions . Cela rendra la structure du code asynchrone beaucoup plus plate. Pour ce faire, il existe une fonction util.promisify (originale) pratique qui peut être utilisée. Cela nous permet de passer des rappels aux promesses. Jetez un œil à l'exemple avec les fsfonctions ci-dessous:

// Dependencies.
const util = require('util');
const fs = require('fs');

// Promisify "error-back" functions.
const fsOpen = util.promisify(fs.open);
const fsWrite = util.promisify(fs.writeFile);
const fsClose = util.promisify(fs.close);

// Now we may create 'async' function with 'await's.
async function doSomethingWithFile(fileName) {
  const fileDescriptor = await fsOpen(fileName, 'wx');

  // Do something with the file here...

  await fsWrite(fileDescriptor, newData);
  await fsClose(fileDescriptor);
}

Ici, nous utilisons w + pour lire / écrire les deux actions et si le chemin du fichier n'est pas trouvé, il sera créé automatiquement.

fs.open(path, 'w+', function(err, data) {
    if (err) {
        console.log("ERROR !! " + err);
    } else {
        fs.write(data, 'content', 0, 'content length', null, function(err) {
            if (err)
                console.log("ERROR !! " + err);
            fs.close(data, function() {
                console.log('written success');
            })
        });
    }
});

Le contenu signifie ce que vous devez écrire dans le fichier et sa longueur, «content.length».

Voici l'exemple de la façon de lire le fichier csv du local et d'écrire le fichier csv au local.

var csvjson = require('csvjson'),
    fs = require('fs'),
    mongodb = require('mongodb'),
    MongoClient = mongodb.MongoClient,
    mongoDSN = 'mongodb://localhost:27017/test',
    collection;

function uploadcsvModule(){
    var data = fs.readFileSync( '/home/limitless/Downloads/orders_sample.csv', { encoding : 'utf8'});
    var importOptions = {
        delimiter : ',', // optional 
        quote     : '"' // optional 
    },ExportOptions = {
        delimiter   : ",",
        wrap        : false
    }
    var myobj = csvjson.toSchemaObject(data, importOptions)
    var exportArr = [], importArr = [];
    myobj.forEach(d=>{
        if(d.orderId==undefined || d.orderId=='') {
            exportArr.push(d)
        } else {
            importArr.push(d)
        }
    })
    var csv = csvjson.toCSV(exportArr, ExportOptions);
    MongoClient.connect(mongoDSN, function(error, db) {
        collection = db.collection("orders")
        collection.insertMany(importArr, function(err,result){
            fs.writeFile('/home/limitless/Downloads/orders_sample1.csv', csv, { encoding : 'utf8'});
            db.close();
        });            
    })
}

uploadcsvModule()

fs.createWriteStream(path[,options])

optionspeut également inclure une startoption pour autoriser l'écriture de données à une certaine position après le début du fichier. La modification d'un fichier plutôt que son remplacement peut nécessiter un flagsmode r+plutôt que le mode par défaut w. L'encodage peut être n'importe lequel de ceux acceptés par Buffer .

Si autoCloseest défini sur true (comportement par défaut) sur 'error'ou 'finish'le descripteur de fichier sera fermé automatiquement. SiautoClose est faux, le descripteur de fichier ne sera pas fermé, même en cas d'erreur. Il est de la responsabilité de l'application de la fermer et de s'assurer qu'il n'y a pas de fuite de descripteur de fichier.

Comme ReadStream , si fdest spécifié, WriteStream ignorera l' pathargument et utilisera le descripteur de fichier spécifié. Cela signifie qu'aucun 'open'événement ne sera émis. fddevrait être bloquant; les fds non bloquants doivent être passés à net.Socket .

Si optionsest une chaîne, elle spécifie l'encodage.

Après avoir lu ce long article. Vous devez comprendre comment cela fonctionne. Alors, voici un exemple de createWriteStream().

/* The fs.createWriteStream() returns an (WritableStream {aka} internal.Writeable) and we want the encoding as 'utf'-8 */
/* The WriteableStream has the method write() */
fs.createWriteStream('out.txt', 'utf-8')
.write('hello world');

Vous pouvez utiliser la bibliothèque easy-file-manager

installer d'abord à partir de npm npm install easy-file-manager

Échantillon pour télécharger et supprimer des fichiers

var filemanager = require('easy-file-manager')
var path = "/public"
var filename = "test.jpg"
var data; // buffered image

filemanager.upload(path,filename,data,function(err){
    if (err) console.log(err);
});

filemanager.remove(path,"aa,filename,function(isSuccess){
    if (err) console.log(err);
});

Vous pouvez écrire dans un fichier par l'exemple de code suivant:

var data = [{ 'test': '123', 'test2': 'Lorem Ipsem ' }];
fs.open(datapath + '/data/topplayers.json', 'wx', function (error, fileDescriptor) {
  if (!error && fileDescriptor) {
    var stringData = JSON.stringify(data);
    fs.writeFile(fileDescriptor, stringData, function (error) {
      if (!error) {
        fs.close(fileDescriptor, function (error) {
          if (!error) {
            callback(false);
          } else {
            callback('Error in close file');
          }
        });
      } else {
        callback('Error in writing file.');
      }
    });
  }
});