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

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

Ответ 1

There are a lot of details in the API файловой системы содержит множество деталей. Наиболее распространенный способ:

const fs = require('fs');

fs.writeFile("/tmp/test", "Hey there!", function(err) {

    if(err) {
        return console.log(err);
    }

    console.log("The file was saved!");
});

Ответ 2

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

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

Вам нужно дождаться обратного вызова, чтобы убедиться, что буфер записан на диск. Это не буферизировано.
fs.writeFile(filename, data, [encoding], callback)

Все данные должны храниться одновременно; вы не можете выполнять последовательные записи.
fs.createWriteStream(path, [options])

Создает 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...). Если вы пишете три байта, эти байты будут храниться в буфере (памяти) вместо того, чтобы делать вызов ввода-вывода только для трех байтов. Когда буфер заполнен, содержимое очищается и сохраняется на диск. Это повышает производительность.

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

Ответ 3

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

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

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

Ответ 5

Синхронная запись

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>

Стоит прочитать в OFFICAL File System (фс) документы.

Ответ 6

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

Обновить:
Как и в Linux-узле, писать в текущем каталоге, кажется, в некоторых других нет, поэтому я добавляю этот комментарий на всякий случай:
Используя этот ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); чтобы получить, где файл написан.

Ответ 7

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

var fs = require('fs');
for (var i=0; i<10; i++){
    fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}

Ответ 8

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

Ответ 9

Предоставленные ответы датированы, и новый способ сделать это:

const fsPromises = require('fs').promises
await fsPromises.writeFile('/path/to/file.txt', 'data to write')

см. документы здесь для получения дополнительной информации

Ответ 10

Хорошо, это довольно просто, поскольку Node имеет встроенную функциональность для этого, он называется fs что означает файловую систему и, в основном, модуль файловой системы 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\ saved to the file!');
});

Ответ 11

Вы можете записать в файл, используя модуль 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');
    }
  });
};

Ответ 12

Здесь мы используем 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'.

Ответ 13

Вот пример того, как читать файл 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()

Ответ 14

fs.createWriteStream(path[,options])

options могут также включать опцию start позволяющую записывать данные в некоторой позиции после начала файла. Для изменения файла вместо его замены может потребоваться режим flags r+ а не режим по умолчанию w. Кодировка может быть любой из тех, которые приняты буфером.

Если для autoClose задано значение true (поведение по умолчанию) для 'error' или 'finish' дескриптор файла будет автоматически закрыт. Если autoClose равно false, дескриптор файла не будет закрыт, даже если произошла ошибка. Приложение должно закрыть его и убедиться в отсутствии утечки дескриптора файла.

Как и ReadStream, если указан fd, WriteStream будет игнорировать аргумент path и будет использовать указанный дескриптор файла. Это означает, что событие 'open' не генерируется. fd должен быть блокирующим; неблокируемый fd должен быть передан 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');

Ответ 15

Вы можете записать в файл следующий пример кода:

  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.');        
            }        
        });        
    }        
}

Ответ 16

Вы можете использовать библиотеку 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);
});

Ответ 17

Попробуйте следующее:

fs.readFile('${__dirname}/fileName', 'utf-8',(err, contents) => {
    if (err) throw Error(err){
        console.log(contents)
    }
});