Ik heb geprobeerd een manier te vinden om naar een bestand te schrijven wanneer ik Node.js gebruik, maar zonder succes. Hoe kan ik dat doen?
Antwoord 1, autoriteit 100%
Er zijn veel details in de Bestandssysteem API. De meest gebruikelijke manier is:
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!');
Antwoord 2, autoriteit 21%
Momenteel zijn er drie manieren om een bestand te schrijven:
-
fs.write(fd, buffer, offset, length, position, callback)U moet wachten op de callback om er zeker van te zijn dat de buffer naar de schijf wordt geschreven. Het is niet gebufferd.
-
fs.writeFile(filename, data, [encoding], callback)Alle gegevens moeten tegelijkertijd worden opgeslagen; u kunt geen opeenvolgende schrijfbewerkingen uitvoeren.
-
fs.createWriteStream(path, [options])Maakt een
WriteStream, wat handig is omdat u niet hoeft te wachten op een terugbelverzoek. Maar nogmaals, het is niet gebufferd.
Een WriteStream, zoals de naam al zegt, is een stroom. Een stream is per definitie “een buffer” met data die in één richting beweegt (bron ► bestemming). Maar een beschrijfbare stream is niet noodzakelijkerwijs “gebufferd”. Een stream wordt “gebufferd” wanneer u nkeer schrijft, en op het moment n+1stuurt de stream de buffer naar de kernel (omdat deze vol is en moet worden leeggemaakt) ).
Met andere woorden:“Een buffer” is het object. Of het wel of niet “gebufferd” is, is een eigenschap van dat object.
Als je naar de code kijkt, erft de WriteStreamvan een beschrijfbaar Stream-object. Als je goed oplet, zie je hoe ze de inhoud doorspoelen; ze hebben geen buffersysteem.
Als u een tekenreeks schrijft, wordt deze geconverteerd naar een buffer en vervolgens naar de oorspronkelijke laag verzonden en naar schijf geschreven. Bij het schrijven van strings vullen ze geen enkele buffer op. Dus, als je dat doet:
write("a")
write("b")
write("c")
Je doet:
fs.write(new Buffer("a"))
fs.write(new Buffer("b"))
fs.write(new Buffer("c"))
Dat zijn drieaanroepen naar de I/O-laag. Hoewel u “buffers” gebruikt, worden de gegevens niet gebufferd. Een gebufferde stream zou volstaan: fs.write(new Buffer ("abc")), één aanroep naar de I/O-laag.
Vanaf nu ondersteunt Node.js v0.12 (stabiele versie aangekondigd op 02/06/2015) nu twee functies:
cork()en
uncork(). Het lijkt erop dat deze functies uiteindelijk de schrijfoproepen kunnen bufferen / doorspoelen.
Bijvoorbeeld, in Java zijn er enkele klassen die gebufferde streams bieden (BufferedOutputStream, BufferedWriter…). Als u drie bytes schrijft, worden deze bytes opgeslagen in de buffer (geheugen) in plaats van een I / O-oproep te doen, alleen voor drie bytes. Wanneer de buffer vol is, wordt de inhoud gespoeld en opgeslagen op schijf. Dit verbetert de prestaties.
Ik ontdek niets, gewoon onthouden hoe een schijftoegang moet worden gedaan.
3, Autoriteit 11%
U kunt het natuurlijk een beetje geavanceerd maken. Niet-blokkering, schrijfbits en stukken, niet het hele bestand met één keer schrijven:
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();
});
4, Autoriteit 3%
synchroon schrijven
Fs.WriteFilesync (Bestand, Gegevens [, Opties])
fs = require('fs');
fs.writeFileSync("foo.txt", "bar");
asynchroon schrijven
Fs.WriteFile (bestand, gegevens [, opties], callback)
fs = require('fs');
fs.writeFile('foo.txt', 'bar', (err) => { if (err) throw err; });
waar
file <string> | <Buffer> | <URL> | <integer> filename or file descriptor
data <string> | <Buffer> | <Uint8Array>
options <Object> | <string>
callback <Function>
Het is de moeite waard om het officiële bestandssysteem (fs) docste lezen.
Update: async/wachten
fs = require('fs');
util = require('util');
writeFile = util.promisify(fs.writeFile);
fn = async () => { await writeFile('foo.txt', 'bar'); }
fn()
Antwoord 5, autoriteit 2%
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');
})
});
});
Antwoord 6
De gegeven antwoorden zijn gedateerd en een nieuwere manier om dit te doen is:
const fsPromises = require('fs').promises
await fsPromises.writeFile('/path/to/file.txt', 'data to write')
bekijk hier documenten voor meer info
Antwoord 7
Ik vond Index van ./articles/file-system.
Het werkte voor mij.
Zie ook Hoe kan ik Schrijf bestanden in 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');
});
Inhoud van HLELLDORLD.TXT:
Hello World!
Update:
Net als in Linux Node Schrijf in de huidige map, lijkt het in sommige anderen niet, dus ik voeg deze opmerking toe voor het geval:
Gebruik deze ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH);om te krijgen waar het bestand is geschreven.
8
Ik weet dat de vraag over “Write” is gevraagd, maar in een meer algemene zin kan “Appd” in sommige gevallen nuttig zijn, omdat het gemakkelijk in een lus is om tekst toe te voegen aan een bestand (of het bestand bestaat of niet) . Gebruik een “\ n” als u regels wilt toevoegen, bijvoorbeeld:
var fs = require('fs');
for (var i=0; i<10; i++){
fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}
9
U kunt naar een bestand schrijven met fs (bestandssysteem) module.
Hier is een voorbeeld van hoe u het kunt doen:
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');
}
});
};
Misschien wil je ook van deze callback-inside-callback-codestructuur af door de instructies Promisesen async/awaitte gebruiken. Dit maakt de asynchrone codestructuur veel vlakker. Hiervoor kan een handige util.promisify(original)functie worden gebruikt. Het stelt ons in staat om over te schakelen van terugbellen naar beloften. Bekijk het voorbeeld met fsfuncties hieronder:
// 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);
}
Antwoord 10
var fs = require('fs');
fs.writeFile(path + "\\message.txt", "Hello", function(err){
if (err) throw err;
console.log("success");
});
Bijvoorbeeld: lees bestand en schrijf naar een ander bestand:
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");
});
}
});
11
Hier gebruiken we W + voor het lezen / schrijven van beide acties als als het bestandspad niet is gevonden, dan zou het automatisch worden gemaakt.
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');
})
});
}
});
Inhoud betekent wat u moet schrijven naar het bestand en de lengte ervan, ‘content.length’.
12
Hier is het voorbeeld van het lezen van bestand CSV van lokaal en schrijven CSV-bestand naar 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()
Antwoord 13
fs.createWriteStream(path[,options])
optionskunnen ook eenstart-optie bevatten om het schrijven van gegevens op een positie voorbij het begin van het bestand toe te staan. Voor het wijzigen van een bestand in plaats van het te vervangen, is mogelijk eenflags-modus vanr+vereist in plaats van de standaardmodusw. De codering kan een van de codering zijn die wordt geaccepteerd door Buffer.Als
autoCloseis ingesteld op true (standaardgedrag) op'error'of'finish'wordt de bestandsdescriptor automatisch gesloten. AlsautoCloseonwaar is, wordt de bestandsdescriptor niet gesloten, zelfs niet als er een fout is. Het is de verantwoordelijkheid van de applicatie om deze te sluiten en ervoor te zorgen dat er geen bestandsdescriptor lekt.Zoals ReadStream, als
fdis opgegeven, WriteStreamnegeert het argumentpathen gebruikt de opgegeven bestandsdescriptor . Dit betekent dat er geen'open'-gebeurtenis wordt verzonden.fdzou moeten blokkeren; niet-blokkerendefds moeten worden doorgegeven aan net.Socket.Als
optionseen tekenreeks is, specificeert het de codering.
Na het lezen van dit lange artikel. Je moet begrijpen hoe het werkt.
Dus, hier is een voorbeeld van 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');
Antwoord 14
U kunt bibliotheek easy-file-manager
. gebruiken
eerst installeren vanaf npm
npm install easy-file-manager
Voorbeeld om bestanden te uploaden en te verwijderen
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);
});
Antwoord 15
Je kunt met streams naar bestanden schrijven.
Doe het gewoon zo:
const fs = require('fs');
const stream = fs.createWriteStream('./test.txt');
stream.write("Example text");
16
Punt 1:
Als u iets in een bestand wilt schrijven.
Betekent: het verwijdert alles die al in het bestand is opgeslagen en de nieuwe inhoud schrijven. Gebruik Fs.promises.WriteFile ()
Punt 2:
Als u iets in een bestand wilt toevoegen.
betekent: het zal niets in het bestand worden opgeslagen, maar voegt het nieuwe item in de bestandsinhoud toe. Lees eerst het bestand en voeg dan de inhoud toe aan de leesbare waarde en schrijf het vervolgens naar het bestand. Gebruik dus Fs.promises.Leadfile en Fs.promises.WriteFile ()
Voorbeeld 1: Ik wil een JSON-object in My JSON-bestand schrijven.
const fs = require('fs');
writeFile ('./my_data.json' , {id:1, name:'my name'} )
async function writeFile (filename ,writedata) {
try {
await fs.promises.writeFile(filename, JSON.stringify(writedata,null, 4), 'utf8');
console.log ('data is written successfully in the file')
}
catch(err) {
console.log ('not able to write data in the file ')
}
}
Voorbeeld2:
Als u gegevens aan een JSON-bestand wilt toevoegen.
U wilt gegevens toevoegen {ID: 1, naam: ‘Mijn naam’} om my_data.json op dezelfde mapwortel in te dienen. Bel gewoon append_data (file_path, gegevens) -functie.
Het voegt gegevens in het JSON-bestand toe als het bestand bestond. of het zal het bestand maken en de gegevens toevoegen.
const fs = require('fs');
data = {id:1, name:'my name'}
file_path = './my_data.json'
append_data (file_path , data )
async function append_data (filename , data ) {
if (fs.existsSync(filename)) {
read_data = await readFile(filename)
if (read_data == false) {
console.log('not able to read file')
}
else {
read_data.push(data)
dataWrittenStatus = await writeFile(filename, read_data)
if dataWrittenStatus == true {
console.log('data added successfully')
}
else{
console.log('data adding failed')
}
}
else{
dataWrittenStatus = await writeFile(filename, [data])
if dataWrittenStatus == true {
console.log('data added successfully')
}
else{
console.log('data adding failed')
}
}
}
async function readFile (filePath) {
try {
const data = await fs.promises.readFile(filePath, 'utf8')
return JSON.parse(data)
}
catch(err) {
return false;
}
}
async function writeFile (filename ,writedata) {
try {
await fs.promises.writeFile(filename, JSON.stringify(writedata,null, 4), 'utf8');
return true
}
catch(err) {
return false
}
}
Antwoord 17
Punt 1:
Als u iets in een bestand wilt schrijven.
betekent: het verwijdert alles dat al in het bestand is opgeslagen en schrijft de nieuwe inhoud. gebruik fs.promises.writeFile()
Punt 2:
Als je iets aan een bestand wilt toevoegen.
betekent: het verwijdert niets dat al in het bestand is opgeslagen, maar voegt het nieuwe item toe aan de inhoud van het bestand. Lees dan eerst het bestand en voeg vervolgens de inhoud toe aan de leesbare waarde en schrijf het vervolgens naar het bestand. gebruik dus fs.promises.readFile en fs.promises.writeFile()
Voorbeeld 1: Ik wil een JSON-object in My JSON-bestand schrijven.
const fs = require('fs');
Wrifefile (FileName, Writeata)
Async-functie Wrifefile (FileName, Writeata) {
proberen {
Wacht op fs.promissen.WriteFile (bestandsnaam, JSON.Strationify (Wringsata, NULL, 4), ‘UTF8’);
rendement waar
}
vang (err) {
rendement false
}
}
18
U kunt in een bestand schrijven door het volgende CODE-voorbeeld:
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.');
}
});
}
});