javascript - renamesync - write file js




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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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


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

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

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

Стоит прочитать официальные документы файловой системы (fs).


 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