Я пытался найти способ записи в файл при использовании Node.js, но безуспешно. Как я могу это сделать?
В [File System API] много деталей 1. Самый распространенный способ:
const fs = require('fs');
fs.writeFile("/tmp/test", "Hey there!", function(err) {
if(err) {
return console.log(err);
}
console.log("The file was saved!");
});
В настоящее время есть три способа написать файл:
fs.write (fd, буфер, смещение, длина, позиция, обратный вызов
)
Вам нужно дождаться обратного вызова, чтобы убедиться, что буфер записан на диск. Это не буферизовано.
fs.writeFile (имя файла, данные, [кодирование], обратный вызов)
Все данные должны храниться одновременно; Вы не можете выполнять последовательные записи.
fs.createWriteStream (path, [options]
)
Создает WriteStream
, что удобно, потому что вам не нужно ждать обратного вызова. Но опять же, это не буферизовано.
WriteStream
, как следует из названия, является потоком. Поток по определению - это «буфер», содержащий данные, которые движутся в одном направлении (источник ► назначения). Но поток для записи не обязательно «буферный». Поток «буферен», когда вы пишете n
раз, а в момент времени n + 1
поток отправляет буфер в ядро (потому что он полон и должен быть промыт).
Другими словами: «Буфер» - это объект. Является ли он «буферизованным», является свойством этого объекта.
Если вы посмотрите на код, WriteStream
наследует от записываемого объекта Stream
. Если вы обратите внимание, вы увидите, как они смывают контент; у них нет буферизационной системы.
Если вы пишете строку, она преобразуется в буфер, а затем отправляется на родной слой и записывается на диск. При написании строк они не заполняют буфер. Итак, если вы делаете:
& Лт;!- язык-все: lang-js - >
write("a")
write("b")
write("c")
Вы делаете:
fs.write(new Buffer("a"))
fs.write(new Buffer("b"))
fs.write(new Buffer("c"))
Это три вызова уровня ввода / вывода. Хотя вы используете «буферы», данные не буферизуются. Буферный поток будет делать: fs.write (новый буфер ("abc"))
, один вызов к слою ввода / вывода.
На данный момент в Node.js v0.12 (стабированная версия объявлена 02/06/2015) теперь поддерживаются две функции:
cork ()
и
uncork ()
. Похоже, что эти функции наконец позволят вам буферизовать / промывать вызовы записи.
Например, в Java есть некоторые классы, которые предоставляют буферизованные потоки (BufferedOutputStream
, BufferedWriter
...). Если вы напишите три байта, эти байты будут сохранены в буфере (памяти) вместо вызова ввода / вывода всего за три байта. Когда буфер заполнен, содержимое промывается и сохраняется на диск. Это улучшает производительность.
Я ничего не открываю, просто вспоминаю, как должен быть сделан доступ к диску.
Вы можете, конечно, сделать его немного более продвинутым. Неблокировка, запись кусочков, не запись всего файла сразу:
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');
})
});
});
Синхронная запись
fs.writeFileSync (файл, данные [, параметры])
fs = require('fs');
fs.writeFileSync("synchronous.txt", "synchronous write!")
Асинхронная запись
fs.writeFile (файл, данные [, параметры], обратный вызов)
fs = require('fs');
fs.writeFile('asynchronous.txt', 'asynchronous write!', (err) => {
if (err) throw err;
console.log('The file has been saved!');
});
Где
file <string> | <Buffer> | <URL> | <integer> filename or file descriptor
data <string> | <Buffer> | <Uint8Array>
options <Object> | <string>
callback <Function>
Стоит прочитать официальную файловую систему (fs) docs.
Мне понравилось Индекс ./ article / file-system .
Это сработало для меня.
Смотрите также Как мне писать файлы в 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');
});
Содержание helloworld.txt:
Hello World!
Обновление:
Как и в случае с узлом Linux, пишите в текущем каталоге, в некоторых других это не так, поэтому я добавляю этот комментарий на всякий случай:
Используя это ROOT_APP_PATH = fs.realpathSync ('.«); consol.log (ROOT_APP_PATH);
, чтобы получить, где файл написан.
Я знаю вопрос, задаваемый о «записи», но в более общем смысле «приложение» может быть полезным в некоторых случаях, поскольку его легко использовать в цикле для добавления текста в файл (существует ли файл или нет). Используйте «\ n», если вы хотите добавить строки, например:
var fs = require('fs');
for (var i=0; i<10; i++){
fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}
Предоставленные ответы датированы, и более новый способ сделать это:
const fsPromises = require('fs').promises
await fsPromises.writeFile('/path/to/file.txt', 'data to write')
Хорошо, это довольно просто, так как Node имеет встроенную функциональность для этого, он называется fs
, что означает File System и, в основном, Модуль файловой системы NodeJS ...
Поэтому сначала потребуйте его в вашем файле server.js , как это:
var fs = require('fs');
fs
имеет несколько способов записи в файл, но мой предпочтительный способ - использовать appendFile
, это добавит материал в файл и, если файл не существует, создаст его, код может быть похож на приведенный ниже: ,
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");
});
Например: прочитайте файл и напишите в другой файл:
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 (файловая система).
Вот пример того, как вы можете это сделать
& Лт;!- начать фрагмент: js hide: ложная консоль: истинная павиана: false - >
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');
}
});
};
& Лт;!- конец фрагмента - >
Вы также можете избавиться от этой структуры кода обратного вызова внутри обратного вызова, используя операторы Promises и async
/ await
. Это сделает асинхронную структуру кода гораздо более плоской. Для этого можно использовать удобную функцию util.promisify (original). Это позволяет нам переключаться с обратных вызовов на обещания. Взгляните на пример с функциями fs
ниже:
& Лт;!- начать фрагмент: js hide: ложная консоль: истинная павиана: false - >
// 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);
}
& Лт;!- конец фрагмента - >
Здесь мы используем w + для чтения / записи обоих действий, и если путь к файлу не найден, он будет создан автоматически.
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');
})
});
}
});
Контент означает то, что вы должны написать в файл, и его длину, «content.length».
Вот пример того, как читать файл csv из локального и записывать файл csv в локальный.
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()
Вы можете написать в файле следующим примером кода:
var data = [{'test': '123', 'test2': 'Lorem Ipsem'}] ;
fs.open (datapath + '/data/topplayers.json', 'wx', функция (ошибка, fileDescriptor) {
если (!ошибка & fileDescriptor) {
var stringData = JSON.stringify (data) ;
fs.writeFile (fileDescriptor, stringData, function (error) {
если (!ошибка) {
fs.close (fileDescriptor, функция (ошибка) {
если (!ошибка) {
обратный вызов (ложный) ;
} еще {
обратный вызов («Ошибка в близком файле») ;
}
});
} еще {
обратный вызов («Ошибка в письменной форме».«);
}
});
}
});
options
также может включать опциюstart
, позволяющую записывать данные в некоторой позиции после начала файла. Для изменения файла, а не его замены может потребоваться режимflags
r +
, а не режим по умолчаниюw
. Кодировка может быть любой из тех, которые приняты Buffer.
Если для
autoClose
установлено значение true (поведение по умолчанию) в'error '
или' finish '
, дескриптор файла будет автоматически закрыт. ЕслиautoClose
является ложным, то дескриптор файла не будет закрыт, даже если есть ошибка. Приложение обязано закрыть его и убедиться, что нет утечки дескриптора файла.
Как и ReadStream, если указан
fd
, WriteStream будет игнорировать аргументpathor. Это означает, что никакое «открытое» событие не будет выдано.
fdдолжен быть блокирующим; неблокирующие
fd`s должны быть переданы в net.Socket.
Если
options
является строкой, то она указывает кодировку.
После прочтения этой длинной статьи. Вы должны понимать, как это работает.
Итак, вот пример 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');
Вы можете использовать библиотеку easy-file-manager
установить сначала с npm
npm установить easy-file-manager
Образец для загрузки и удаления файлов
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);
});