I've telah mencoba untuk menemukan cara untuk menulis ke sebuah file ketika menggunakan Node.js, tetapi tidak berhasil. Bagaimana saya bisa melakukan itu?
Ada banyak rincian dalam File System API. Cara yang paling umum adalah:
const fs = require('fs');
fs.writeFile("/tmp/test", "Hey there!", function(err) {
if(err) {
return console.log(err);
}
console.log("The file was saved!");
});
Saat ini ada tiga cara untuk menulis sebuah file:
Anda harus menunggu untuk callback untuk memastikan bahwa penyangga yang ditulis ke disk. It's tidak buffered.
Semua data harus disimpan pada waktu yang sama; anda tidak dapat melakukan berurutan menulis.
Menciptakan WriteStream
, yang nyaman karena anda don't perlu menunggu panggilan balik. Tapi sekali lagi, itu's tidak buffered.
A WriteStream
, seperti namanya, adalah sebuah aliran. Aliran secara definisi adalah "penyangga" yang berisi data yang bergerak dalam satu arah (source ► tujuan). Tapi writable stream belum tentu "buffered". Sebuah stream "buffered" ketika anda menulis n
kali, dan pada waktu n+1
, aliran mengirimkan buffer kernel (karena itu's penuh dan harus memerah).
Dengan kata lain: "penyangga" adalah objek. Apakah atau tidak itu "buffered" adalah properti dari objek tersebut.
Jika anda melihat kode, WriteStream
mewarisi dari ditulisi Aliran
objek. Jika anda memperhatikan, anda akan melihat bagaimana mereka menyiram konten; mereka don't memiliki sistem buffer.
Jika anda menulis sebuah string, itu dikonversi ke buffer, dan kemudian dikirim ke asli layer dan ditulis ke disk. Ketika menulis string, mereka're tidak mengisi buffer. Jadi, jika anda lakukan:
write("a")
write("b")
write("c")
Anda're lakukan:
fs.write(new Buffer("a"))
fs.write(new Buffer("b"))
fs.write(new Buffer("c"))
Itu tiga panggilan ke I/O lapisan. Meskipun anda're menggunakan "buffer", data tidak disimpan dalam buffer. Sebuah buffered aliran akan melakukan: fs.write(Buffer baru ("abc"))
, satu panggilan untuk I/O lapisan.
Sampai sekarang, di Node.js v0.12 (versi stabil mengumumkan 02/06/2015) sekarang mendukung dua fungsi:
gabus()
dan
membuka sumbat()
. Tampaknya bahwa fungsi-fungsi ini akhirnya akan memungkinkan anda untuk buffer/flush menulis panggilan.
Misalnya, di Jawa ada beberapa kelas yang menyediakan buffer sungai (BufferedOutputStream
, BufferedWriter
...). Jika anda menulis tiga byte, byte ini akan disimpan dalam buffer (memori) bukannya melakukan I/O panggilan hanya untuk tiga byte. Ketika buffer penuh konten memerah dan disimpan ke disk. Hal ini meningkatkan kinerja.
I'm tidak menemukan apa-apa, hanya mengingat bagaimana akses disk harus dilakukan.
Anda dapat saja membuatnya sedikit lebih maju. Non-blocking, menulis potongan-potongan, tidak menulis seluruh file sekaligus:
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');
})
});
});
Sinkron Menulis
fs.writeFileSync(file, data [pilihan])
fs = require('fs');
fs.writeFileSync("synchronous.txt", "synchronous write!")
Asynchronous Menulis
fs.writeFile(file, data [pilihan], callback)
fs = require('fs');
fs.writeFile('asynchronous.txt', 'asynchronous write!', (err) => {
if (err) throw err;
console.log('The file has been saved!');
});
Dimana
file <string> | <Buffer> | <URL> | <integer> filename or file descriptor
data <string> | <Buffer> | <Uint8Array>
options <Object> | <string>
callback <Function>
Layak dibaca resmi File System (fs) docs.
Aku suka Index of ./artikel/file-system.
Ini bekerja untuk saya.
Lihat juga Bagaimana cara menulis file di 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');
});
Isi helloworld.txt:
Hello World!
Update:
Seperti di Linux node menulis di direktori saat ini , tampaknya beberapa orang lain don't, jadi saya tambahkan komentar ini hanya dalam kasus :
Menggunakan ini ROOT_APP_PATH = fs.realpathSync('.'); konsol.log(ROOT_APP_PATH);
untuk mendapatkan di mana file tersebut ditulis.
Saya tahu pertanyaan yang diajukan tentang "menulis" tetapi dalam arti yang lebih umum "tambahkan" mungkin berguna dalam beberapa kasus seperti ini lebih mudah untuk digunakan dalam loop untuk menambahkan teks ke file (apakah file ada atau tidak). Gunakan "\n" jika anda ingin menambahkan baris misalnya:
var fs = require('fs');
for (var i=0; i<10; i++){
fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}
Jawaban yang diberikan adalah tanggal dan baru cara untuk melakukan ini adalah:
const fsPromises = require('fs').promises
await fsPromises.writeFile('/path/to/file.txt', 'data to write')
OK, it's cukup sederhana sebagai Node memiliki fungsi built-in untuk ini,'s disebut fs
yang merupakan singkatan dari Sistem Berkas dan pada dasarnya, NodeJS File Sistem modul...
Jadi pertama mengharuskan anda server.js file seperti ini:
var fs = require('fs');
fs
memiliki beberapa metode untuk menulis ke file, tapi saya cara yang lebih disukai adalah menggunakan appendFile
, ini akan menambahkan hal-hal ke file, dan jika file yang doesn't ada, akan membuat satu, kode bisa seperti di bawah ini:
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");
});
Misalnya : membaca file dan menulis ke file yang lain :
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");
});
}
});
Anda dapat menulis ke file dengan menggunakan fs (sistem file) modul.
Berikut ini adalah contoh bagaimana anda dapat melakukannya:
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');
}
});
};
Anda juga mungkin ingin untuk menyingkirkan virus ini callback-dalam-callback struktur kode dengan menggunakan Janji dan async
/menunggu
pernyataan. Ini akan membuat asynchronous kode struktur yang lebih datar. Untuk melakukan hal yang tidak berguna util.promisify(asli) fungsi yang bisa dimanfaatkan. Hal ini memungkinkan kita untuk beralih dari callback untuk janji-janji. Lihatlah contoh dengan fs
fungsi di bawah ini:
// 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);
}
Di sini kita menggunakan w+ untuk baca/tulis kedua tindakan dan jika path file tidak ditemukan itu akan dibuat secara otomatis.
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');
})
});
}
});
Konten berarti apa yang anda miliki untuk menulis ke file dan panjangnya, 'konten.panjang'.
Berikut adalah contoh cara membaca file csv dari lokal dan menulis file csv untuk lokal.
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()
Anda dapat menulis dalam sebuah file dengan contoh kode berikut:
var data = [{ 'uji': '123', 'test2': 'Lorem Ipsem ' }]; fs.terbuka(datapath + '/data/topplayers.json', 'wx', fungsi (kesalahan, fileDescriptor) { jika (!kesalahan && fileDescriptor) { var stringData = JSON.stringify(data); fs.writeFile(fileDescriptor, stringData, fungsi (error) { jika (!error) { fs.dekat(fileDescriptor, fungsi (error) { jika (!error) { callback(false); } else { callback('Kesalahan dalam menutup file'); } }); } else { callback('Kesalahan dalam penulisan file.'); } }); } });
pilihan
juga mungkin termasukstart
pilihan untuk memungkinkan penulisan data di beberapa posisi masa awal file. Memodifikasi file daripada menggantinya mungkin memerlukanbendera
moder+
daripada default modew
. Pengkodean dapat menjadi salah satu dari mereka diterima oleh Buffer.
Jika
autoClose
diatur ke true (default) pada'kesalahan'
atau'selesai'
file descriptor akan ditutup secara otomatis. JikaautoClose
adalah palsu, maka file descriptor won't ditutup, bahkan jika ada's kesalahan. Ini adalah aplikasi's tanggung jawab untuk menutupnya dan pastikan ada's tidak ada file descriptor bocor.
Seperti ReadStream, jika
fd
ditentukan, WriteStream akan mengabaikanpath
argumen dan akan menggunakan file yang ditentukan deskriptor. Ini berarti bahwa tidak ada'open'
acara akan dipancarkan.fd
harus memblokir; non-blocking `fd ini harus diteruskan ke net.Soket.
Jika
pilihan
adalah string, maka menentukan encoding.
Setelah membaca artikel panjang ini. Anda harus memahami bagaimana cara kerjanya.
Jadi, di sini's contoh 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');
Anda dapat menggunakan library mudah-file-manager
menginstal lebih dari npm
npm install mudah-file-manager
Contoh untuk meng-upload dan menghapus file
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);
});