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

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

+1500
источник поделиться
17 ответов

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!");
}); 
+2276
источник

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

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

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

+512
источник
другие ответы

Связанные вопросы


Похожие вопросы

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

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();
});
+241
источник
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');
        })
    });
});
+50
источник

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

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

+49
источник

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

+29
источник

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

var fs = require('fs');
for (var i=0; i<10; i++){
    fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}
+12
источник
 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')

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

+9
источник

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

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

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

+4
источник

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

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');
+2
источник

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

  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.');        
            }        
        });        
    }        
}        
+2
источник

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

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

fs.readFile('${__dirname}/fileName', 'utf-8',(err, contents) => {
    if (err) throw Error(err){
        console.log(contents)
    }
});
0
источник

Посмотрите другие вопросы по меткам или Задайте вопрос