Am'am fost încercarea de a găsi o modalitate de a scrie într-un fișier atunci când se utilizează Node.js, dar fără succes. Cum pot face asta?
Există o mulțime de detalii în Sistem de Fișiere API. Cel mai comun mod este:
const fs = require('fs');
fs.writeFile("/tmp/test", "Hey there!", function(err) {
if(err) {
return console.log(err);
}
console.log("The file was saved!");
});
În prezent, există trei moduri de a scrie un fișier:
Ai nevoie să așteptați pentru apel invers pentru a se asigura că buffer-ul este scris pe disc. L's nu tamponată.
Toate datele trebuie să fie stocate în același timp; nu puteți efectua secvențial scrie.
Creează o WriteStream
, care este convenabil pentru că tu nu't trebuie să așteptați pentru un apel invers. Dar, din nou, l's nu tamponată.
O WriteStream
, după cum spune și numele, este un flux. Un stream, prin definiție, este "un tampon" care conțin datele care se mișcă într-o direcție (sursa ► destinație). Dar o scriere stream nu este neapărat "tamponat". Un stream este "tamponat", atunci când scrie " n "ori, si la momentul "n+1", fluxul trimite tampon pentru a kernel-ului (pentru ca's deplină și are nevoie să fie spălată).
Cu alte cuvinte: "Un tampon" este obiectul. Dacă este sau nu "este tamponat" este o proprietate a acestui obiect.
Daca te uiti la cod, WriteStream
moștenește de la o scriere "Stream" obiect. Dacă ești atent, vei vedea cum se trage apa la conținut; ei't au orice sistem tampon.
Dacă ați scrie un șir de caractere, acesta este convertit la un tampon, și apoi trimis la strat nativ și scrise pe disc. Atunci când scrieți siruri de caractere, ele're nu umple nici un tampon. Deci, dacă faci:
write("a")
write("b")
write("c")
Te're face:
fs.write(new Buffer("a"))
fs.write(new Buffer("b"))
fs.write(new Buffer("c"))
E trei apeluri pentru I/O strat. Deși te're folosind "tampoane", datele nu este tamponat. Un tampon stream va face: fs.scrie(nou Tampon ("abc"))
, un apel la I/O strat.
Ca de acum, în Node.js v0.12 (versiune stabilă a anunțat 02/06/2015) suportă acum două funcții:
cork()
și
destupa()
. Se pare că aceste funcții vor permite în cele din urmă să-tampon/flush scrie apeluri.
De exemplu, în Java există unele clase care oferă tamponat fluxuri (BufferedOutputStream
, BufferedWriter
...). Dacă ai scrie trei octeți, aceste bytes vor fi stocate în buffer (memorie) în loc de a face o I/O suni doar pentru trei octeți. Atunci când buffer-ul este plin de conținut este spălată și salvate pe disc. Acest lucru îmbunătățește performanța.
Am'm nu descoperi nimic, doar amintindu-și cum un disc de acces ar trebui să fie făcut.
Desigur, puteți face un pic mai avansat. Non-blocare, scris biți și piese, nu ai scris tot de fișiere de la o dată:
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();
});
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');
})
});
});
Scrie Sincrone
fs.writeFileSync(fișier, date [opțiuni])
fs = require('fs');
fs.writeFileSync("synchronous.txt", "synchronous write!")
Asincron Scrie
fs.writeFile(fișier, date [opțiuni], callback)
fs = require('fs');
fs.writeFile('asynchronous.txt', 'asynchronous write!', (err) => {
if (err) throw err;
console.log('The file has been saved!');
});
Unde
file <string> | <Buffer> | <URL> | <integer> filename or file descriptor
data <string> | <Buffer> | <Uint8Array>
options <Object> | <string>
callback <Function>
În valoare de lectură oficial Sistemul de Fișiere (fs) documente.
Mi-a placut Index de ./articole/file-system.
Ea a lucrat pentru mine.
A se vedea, de asemenea, Cum să scrie fișiere în 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');
});
Conținutul de helloworld.txt:
Hello World!
Update:
Ca și în Linux nod scrie în directorul curent , se pare că în unele de altele't, deci adaug acest comentariu doar în cazul în care :
Folosind acest ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH);
pentru a obține în cazul în care fișierul este scris.
Știu că întrebarea a fost întrebat despre "scrie" dar într-un sens mai general "adăugați" ar putea fi util în unele cazuri este ușor de utilizat într-o buclă pentru a adăuga text într-un fișier (dacă fișierul există sau nu). Utilizați un "\n" dacă doriți să adăugați linii, de exemplu:
var fs = require('fs');
for (var i=0; i<10; i++){
fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}
Răspunsurile oferite sunt datate și un nou mod de a face acest lucru este:
const fsPromises = require('fs').promises
await fsPromises.writeFile('/path/to/file.txt', 'data to write')
OK, l's destul de simplu ca Nod are built-in funcționalitate pentru acest lucru, l's a numit " fs " care vine de la Sistemul de Fișiere și, practic, NodeJS de Fișiere de Sistem modulul...
Deci, în primul rând nevoie de ea în server.js file de genul asta:
var fs = require('fs');
"fs" are câteva metode pentru a nu scrie la dosar, dar modul meu preferat este folosind appendFile
, acest lucru va adăuga lucruri la dosar și, dacă fișierul nu't există, se va crea unul, codul ar putea fi ca mai jos:
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");
});
De exemplu : citește fișier și scrie în alt fișier :
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");
});
}
});
S-ar putea scrie într-un fișier folosind fs (sistem de fișiere) module.
Aici este un exemplu de cum se poate face:
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');
}
});
};
S-ar putea dori, de asemenea, pentru a scăpa de acest callback-interior-callback structura codului de useing Promisiuni și "asincron" /`așteaptă declarații. Acest lucru va face asincron structura de cod mult mai plat. Pentru a face asta nu este un îndemână util.promisify(original) funcția ar putea fi utilizate. Ea ne permite să treceți de la callback pentru promisiuni. Uită-te la exemplul cu " fs " funcțiile de mai jos:
// 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);
}
Aici vom folosi w+ pentru a citi/scrie atât în acțiuni, cât și în cazul în care calea de fișier nu este găsit, ar fi creat automat.
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');
})
});
}
});
Conținutul înseamnă ce trebuie să scrie în fișier și de lungimea acestuia, 'conținut.lungime'.
Aici este o mostră de cum să citească fișierul csv de la nivel local și de a scrie fișier csv locale.
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()
Puteți scrie într-un fișier de următorul exemplu de cod:
var datele = [{ 'test': '123', 'test2': 'Lorem Ipsem ' }]; fs.deschis(datapath + '/date/topplayers.json', 'wx', funcția (eroare, fileDescriptor) { dacă (!eroare && fileDescriptor) { var stringData = JSON.stringify(date); fs.writeFile(fileDescriptor, stringData, funcția (eroare) { dacă (!eroare) { fs.aproape(fileDescriptor, funcția (eroare) { dacă (!eroare) { callback(false); } else { callback('de Eroare în fișierul aproape'); } }); } else { callback('de Eroare în scris de fișier.'); } }); } });
"opțiuni" poate include, de asemenea, un "start" opțiune pentru a permite scrierea de date la un post trecut de la începutul fișierului. Modificarea unui fișier, mai degrabă decât înlocuirea se poate solicita o "steaguri" modul de
r+
, mai degrabă decât implicit modul "w". Codificarea poate fi oricare dintre cele acceptate de Buffer.
Dacă
autoClose
este setată la true (comportament implicit) pe'eroare' " sau " 'termin'
descriptorul de fișier va fi închis automat. Dacă autoClose` este fals, atunci descriptorul de fișier câștigat't fi închise, chiar dacă nu's o eroare. Aceasta este aplicația's responsabilitatea să-l închideți și asigurați-vă că nu's nici un descriptor de fisier scurgere.
Ca ReadStream, dacă
fd
este specificat, WriteStream va ignora "cale" argument și va folosi fișierul specificat de descriptori. Acest lucru înseamnă că nu'deschis' evenimentul va fi emis.
fdar trebui să fie de blocare; non-blocking
fd ar trebui să fie trecut la net.Soclu.
Dacă "opțiuni" este un șir de caractere, atunci se specifică codare.
După citirea acestui articol lung. Tu ar trebui să înțeleagă cum funcționează.
Deci, aici's un exemplu 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');
Puteți folosi biblioteca ușor-file-manager`
instalați mai întâi de la npm
npm instala easy-file-manager
Proba a încărca și șterge fișiere
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);
});