Запись файлов в Node.js

javascript node.js file express fs

1063482 просмотра

12 ответа

Я пытаюсь найти способ записи в файл при использовании Node.js, но без успеха. Как я могу это сделать?

Автор: Gjorgji Источник Размещён: 17.05.2019 04:03

Ответы (12)


1866 плюса

Решение

В API файловой системы много деталей . Самый распространенный способ (насколько я знаю):

var fs = require('fs');
fs.writeFile("/tmp/test", "Hey there!", function(err) {
    if(err) {
        return console.log(err);
    }

    console.log("The file was saved!");
}); 
Автор: Brian McKenna Размещён: 23.03.2010 01:50

445 плюса

В настоящее время существует три способа записи файла:

  1. fs.write(fd, buffer, offset, length, position, callback)

    Вам нужно дождаться обратного вызова, чтобы убедиться, что буфер записан на диск. Он не буферизирован.

  2. fs.writeFile(filename, data, [encoding], callback)

    Все данные должны храниться одновременно; вы не можете выполнять последовательные записи.

  3. fs.createWriteStream(path, [options])

    Создает a WriteStream, что удобно, потому что вам не нужно ждать обратного вызова. Но опять же, он не буферизирован.

A WriteStream, как говорится в названии, является потоком. Потоком по определению является «буфер», содержащий данные, которые перемещаются в одном направлении (источник ► пункт назначения). Но записываемый поток не обязательно «забуферирован». Поток «буферизуется», когда вы пишете nвремя, и в то время n+1поток посылает буфер в ядро ​​(потому что он заполнен и его нужно очистить).

Другими словами: «Буфер» - это объект. Независимо от того, «буферизовано» или нет, это свойство этого объекта.

Если вы посмотрите на код, WriteStreamнаследуется от записываемого Streamобъекта. Если вы обратите внимание, вы увидите, как они очищают содержимое; у них нет системы буферизации.

Если вы пишете строку, она преобразуется в буфер, а затем отправляется на собственный слой и записывается на диск. При написании строк они не заполняют буфер. Итак, если вы это сделаете:

write("a")
write("b")
write("c")

Ты делаешь:

fs.write(new Buffer("a"))
fs.write(new Buffer("b"))
fs.write(new Buffer("c"))

Это три вызова уровня ввода-вывода. Хотя вы используете «буферы», данные не буферизуются. Буферизованный поток будет делать: fs.write(new Buffer ("abc"))один вызов уровня ввода-вывода.

На данный момент в Node.js v0.12 (стабильная версия, объявленная 02/06/2015) теперь поддерживает две функции: cork()и uncork(). Кажется, что эти функции, наконец, позволят вам буферизовать / стирать вызовы записи.

Например, в Java есть несколько классов, которые предоставляют буферизованные потоки ( BufferedOutputStream, BufferedWriter...). Если вы пишете три байта, эти байты будут храниться в буфере (памяти) вместо того, чтобы делать вызов ввода-вывода только для трех байтов. Когда буфер заполнен, содержимое очищается и сохраняется на диск. Это повышает производительность.

Я ничего не обнаруживаю, просто помню, как сделать доступ к диску.

Автор: Gabriel Llamas Размещён: 28.04.2012 10:52

198 плюса

Конечно, вы можете сделать его немного более продвинутым. Неблокирует, записывает биты и куски, не записывая сразу весь файл:

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();
});
Автор: Fredrik Andersson Размещён: 05.08.2011 03:28

40 плюса

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');
        })
    });
});
Автор: Mister P Размещён: 16.12.2013 02:40

22 плюса

Мне понравился индекс ./articles/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!

Update:
As in Linux node write in current directory , it seems in some others don't, so I add this comment just in case :
Using this ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); to get where the file is written.

Автор: Sérgio Размещён: 07.11.2014 08:54

5 плюса

 var fs = require('fs');
 fs.writeFile(path + "\\message.txt", "Hello", function(err){
 if (err) throw err;
  console.log("success");
}); 

For example : read file and write to another file :

  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");
                            });
                        }
                });
Автор: Masoud Siahkali Размещён: 23.10.2016 07:54

5 плюса

Synchronous Write

fs.writeFileSync(file, data[, options])

fs = require('fs');

fs.writeFileSync("synchronous.txt", "synchronous write!")

Asynchronous Write

fs.writeFile(file, data[, options], callback)

fs = require('fs');

fs.writeFile('asynchronous.txt', 'asynchronous write!', (err) => {
  if (err) throw err;
  console.log('The file has been saved!');
});

Where

file <string> | <Buffer> | <URL> | <integer> filename or file descriptor
data <string> | <Buffer> | <Uint8Array>
options <Object> | <string>
callback <Function>

Worth reading the offical File System (fs) docs.

Автор: Moriarty Размещён: 17.05.2018 05:54

3 плюса

Here we use w+ for read/write both actions and if the file path is not found the it would be created automatically.

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 means what you have to write to the file and its length, 'content.length'.

Автор: Gunjan Patel Размещён: 01.10.2014 05:39

3 плюса

Я знаю, что вопрос задан «написать», но в более общем смысле «append» может быть полезным в некоторых случаях, поскольку он легко использовать в цикле для добавления текста в файл (существует ли файл или нет). Используйте «\ n», если вы хотите добавить строки, например:

var fs = require('fs');
for (var i=0; i<10; i++){
    fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}
Автор: Astra Bear Размещён: 28.05.2018 12:06

2 плюса

Вот пример того, как читать файл 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()
Автор: KARTHIKEYAN.A Размещён: 01.09.2017 11:06

1 плюс

Вы можете использовать библиотеку easy-file-manager

установить сначала с npm npm install 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);
});
Автор: Christoper Размещён: 04.05.2016 05:15

0 плюса

Вы можете писать в файл с помощью модуля fs (файловой системы).

Вот пример того, как вы можете это сделать:

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/ awaitstatements. Это сделает асинхронную структуру кода более плоской. Для этого есть удобная утилита. Может быть использована функция promisify (original) . Это позволяет нам переключаться с обратных вызовов на обещания. Взгляните на пример с fsприведенными ниже функциями:

// 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);
}

Автор: Oleksii Trekhleb Размещён: 20.09.2018 10:36
Вопросы из категории :
32x32