l'écriture de fichiers dans Node.js

Question

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

Answer 1

Il y a beaucoup de détails dans l'API système de fichiers . La façon 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!");
}); 

Answer 2

Il existe actuellement trois façons d'écrire un fichier:

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

   Vous devez attendre le rappel pour faire en sorte que la mémoire tampon est écrit sur le disque. Ce n'est pas tamponne.

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

   Toutes les données doivent être stockées en même temps; vous ne pouvez pas effectuer l'écriture séquentielle.

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

   Crée un WriteStream , ce qui est pratique parce que vous n'avez pas besoin d'attendre un rappel. Mais encore une fois, il ne tamponne.

WriteStream , comme son nom l'indique, est un courant. Un courant est par définition un « tampon » contenant des données qui se déplace dans une direction (source ► destination). Mais un flux inscriptible est pas nécessairement « tamponne ». Un flux est « tamponne » lorsque vous écrivez fois n et à n+1 temps, le flux envoie le tampon au noyau (car il est plein et doit être rincée).

En d'autres termes: « Un tampon » est l'objet. Que ce soit ou non « est tamponne » est une propriété de cet objet.

Si vous regardez le code, le WriteStream hérite d'un objet inscriptible Stream. Si vous faites attention, vous verrez comment ils vident le contenu; ils ne disposent d'aucun système de mise en mémoire tampon.

Si vous écrivez une chaîne, il est converti en un tampon, puis envoyé à la couche native et écrites sur le disque. Lors de l'écriture des chaînes, ils ne sont pas remplir une mémoire tampon. Donc, si vous faites:

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

Vous faites:

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

C'est trois appelle à la couche d'E / S. Bien que vous utilisez la fonctionnalité « tampons », les données ne sont pas en mémoire tampon. Un courant tamponnée 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é 06/02/2015) prend désormais en charge deux fonctions: cork() uncork() . Il semble que ces fonctions seront finalement vous permettre de Buffer / débusquer les appels d'écriture.

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

Je ne suis pas découvrir quoi que ce soit, juste se rappeler comment devrait se faire un accès au disque.

Answer 3

Vous pouvez bien sûr faire un peu plus avancé. Non-blocage, l'écriture des morceaux, ne pas écrire 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();
});

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

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

Answer 5

Ecrire Synchrone

  

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

fs = require('fs');

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

Ecrire Asynchronous

  

fs.writeFile (fichiers, 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 Worth File offical (fs) docs .

Answer 6

J'aimais Index des ./articles/file-system .

Il a travaillé pour moi.

Voir aussi Comment puis-je é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 écriture noeud Linux dans le répertoire courant, il semble dans certains autres ne pas, donc j'ajouter ce commentaire au cas où:
En utilisant cette ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); pour obtenir où le fichier est écrit.

Answer 7

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

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

Answer 8

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

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

Answer 9

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

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

voir les documents ici pour plus d'infos

Answer 10

OK, il est assez simple nœud a une fonctionnalité intégrée pour cela, il est appelé fs qui signifie Système de fichiers et fondamentalement, NodeJS module File System ...

Alors d'abord besoin dans votre server.js fichier comme ceci:

var fs = require('fs');

fs a quelques méthodes pour faire écrire dans le fichier, mais ma façon préférée utilise appendFile, ce ajoutera les choses au fichier et si le fichier n'existe pas, va créer 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!');
});

Answer 11

Vous pouvez écrire dans un fichier en utilisant 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 pouvez également vous débarrasser de cette structure de code-rappel dans la fonction de rappel par useing Promesses et les déclarations async / await. Cela rendra la structure de code asynchrone beaucoup plus plat. Pour faire qu'il ya un href="https://nodejs.org/api/util.html#util_util_promisify_original" pratique util.promisify (original) fonction peut être utilisée. Il nous permet de passer de callbacks aux promesses. Jetez un oeil à l'exemple des fonctions de fs 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);
}

Answer 12

Ici, nous utilisons w + pour la lecture / écriture des deux actions et si le chemin du fichier ne se trouve pas la, il serait 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');
            })
        });
    }
});

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

Answer 13

Voici l'exemple de la façon de lire csv fichier à partir du fichier csv local et écrire au niveau 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()

Answer 14

  

fs.createWriteStream(path[,options])

     

options peut également inclure une option start pour permettre l'écriture de données à une position après le début du fichier. Modification d'un fichier plutôt que de le remplacer peut nécessiter un mode flags de r+ plutôt que le mode par défaut w. Le codage peut être une des personnes acceptées par tampon .

     

Si autoClose est définie sur true (comportement par défaut) sur 'error' ou 'finish' le descripteur de fichier sera fermé automatiquement. Si autoClose est faux, le descripteur de fichier ne sera pas fermé, même s'il y a une erreur. Il est de la responsabilité de l'application pour le fermer et assurez-vous qu'il n'y a pas de fuite de descripteur de fichier.

     

Comme ReadStream , si fd est spécifié, WriteStream ignore l'argument path et utilisera le descripteur de fichier spécifié. Cela signifie qu'aucun événement 'open' sera émis. fd doit bloquer; fds non bloquants doivent être passés à net.Socket .

     

Si options est une chaîne, il spécifie le codage.

Après, la lecture de cet article à long. Vous devez comprendre comment cela fonctionne. Donc, 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');

Answer 15

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

Answer 16

Vous pouvez utiliser easy-file-manager bibliothèque

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

Exemple de 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);
});

Answer 17

Effectuez les opérations suivantes:

fs.readFile(`${__dirname}/fileName`, 'utf-8',(err, contents) => {
    if (err) throw Error(err){
        console.log(contents)
    }
});