Réponses:
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!');
/home/...
. Généralement, ce répertoire est 755 root: wheel (ou autre). Si le nœud veut écrire un fichier en tant que jane, il sera plus facile d'y écrire /home/jane/test.txt
. Changer /home
pour quelque chose de plus permissif que 755 est une énorme erreur.
/home
répertoire, j'ai suggéré de le modifier. Je sais que cela pourrait générer un problème de sécurité. Mais bon, si l'utilisateur veut y sauvegarder, c'est la solution. PS: je suis d'accord avec ce que vous avez dit (:
Actuellement, il existe trois façons d'écrire un fichier:
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.
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.
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 n
heures, 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' WriteStream
hérite d'un Stream
objet 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.
cork()
et uncork()
pour ceux d'entre nous qui veulent essayer le noeud pré-version 0.11?
npm
implémentation de l'écriture tamponnée?
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');
})
});
});
fs.write()
), cet exemple ne fonctionne que si tout est suffisamment court pour être écrit en un seul appel d'écriture.
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')
(node:23759) ExperimentalWarning: The fs.promises API is experimental
v10.15.0
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");
}
const
plutôt que var
, c'est const fs = require('fs');
-à- dire pour éviter les effets secondaires indésirables, en particulier si vous travaillez avec une base de code un peu plus grande.
OK, c'est assez simple car Node a une fonctionnalité intégrée pour cela, cela s'appelle fs
qui 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');
fs
a 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");
});
}
});
writeFile
?
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 fs
fonctions 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])
options
peut également inclure unestart
option 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 unflags
moder+
plutôt que le mode par défautw
. L'encodage peut être n'importe lequel de ceux acceptés par Buffer .Si
autoClose
est 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
fd
est spécifié, WriteStream ignorera l'path
argument et utilisera le descripteur de fichier spécifié. Cela signifie qu'aucun'open'
événement ne sera émis.fd
devrait être bloquant; lesfd
s non bloquants doivent être passés à net.Socket .Si
options
est 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);
});
This modules is created to save and remove files.
. Pas une réponse.
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.');
}
});
}
});
writeFile
avait déjà été donnée plusieurs fois, plusieurs années auparavant. Qu'est-ce que cette réponse ajoute?
{ [Error: EACCES, open '/home/test.txt'] errno: 3, code: 'EACCES', path: '/home/test.txt' }
Comment puis-je modifier ce script pour qu'il fonctionne en dehors de/tmp
?