javascript - read - require('fs')




Écrire des fichiers dans Node.js (6)

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é.

Un 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'instant 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 objet Stream inscriptible. 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é 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.

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?


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'.


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

Cela a fonctionné 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!

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); ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); pour obtenir où le fichier est écrit.


Voici l'exemple de la façon de lire le fichier csv depuis local et d'écrire le fichier csv en 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()

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

installez d'abord depuis npm npm install easy-file-manager

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

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




fs