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

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

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

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

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

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

Мне понравился индекс./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); чтобы получить, где файл написан.

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

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 (фс) документы.

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

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

 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 (файловая система).

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

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

Возможно, вы также захотите избавиться от этой структуры кода callback-inside-callback, используя операторы Promises и async/await. Это сделает асинхронную структуру кода намного более плоской. Для этого может быть использована удобная функция util.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);
}

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

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

Хорошо, это довольно просто, поскольку 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!');
});

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

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

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