Zapisywanie plików w Node.js

Próbowałem znaleźć sposób na zapisanie pliku przy użyciu Node.js, ale bez powodzenia. Jak mogę to zrobić?

Interfejs API systemu plików zawiera wiele szczegółów . Najczęstszym sposobem jest:

const fs = require('fs');

fs.writeFile("/tmp/test", "Hey there!", function(err) {
    if(err) {
        return console.log(err);
    }
    console.log("The file was saved!");
}); 

// Or
fs.writeFileSync('/tmp/test-sync', 'Hey there!');

Obecnie istnieją trzy sposoby zapisania pliku:

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

   Musisz poczekać na wywołanie zwrotne, aby upewnić się, że bufor jest zapisany na dysku. To nie jest buforowane.

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

   Wszystkie dane muszą być przechowywane jednocześnie; nie można wykonywać zapisów sekwencyjnych.

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

   Tworzy WriteStream, co jest wygodne, ponieważ nie trzeba czekać na oddzwonienie. Ale znowu nie jest buforowane.

A WriteStream, jak sama nazwa wskazuje, jest strumieniem. Strumień z definicji jest „buforem” zawierającym dane, które poruszają się w jednym kierunku (źródło ► miejsce docelowe). Ale zapisywalny strumień niekoniecznie jest „buforowany”. Strumień jest „buforowany” podczas zapisywania nczasów, a jednocześnie n+1strumień wysyła bufor do jądra (ponieważ jest pełny i wymaga opróżnienia).

Innymi słowy: „Bufor” to obiekt. To, czy „jest buforowane”, jest własnością tego obiektu.

Jeśli spojrzysz na kod, WriteStreamdziedziczy po zapisywalnym Streamobiekcie. Jeśli zwrócisz uwagę, zobaczysz, jak opróżniają zawartość; nie mają żadnego systemu buforowania.

Napisany ciąg znaków jest konwertowany na bufor, a następnie wysyłany do warstwy natywnej i zapisywany na dysku. Podczas pisania ciągów nie wypełniają żadnego bufora. Więc jeśli to zrobisz:

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

Robisz:

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

To trzy połączenia z warstwą we / wy. Chociaż używasz „buforów”, dane nie są buforowane. Buforowany strumień wykonałby: fs.write(new Buffer ("abc"))jedno wywołanie warstwy I / O.

Na razie w Node.js v0.12 (stabilna wersja ogłoszona 02/06/2015) obsługuje teraz dwie funkcje: cork()i uncork(). Wygląda na to, że te funkcje pozwolą wreszcie buforować / opróżniać wywołania zapisu.

Na przykład w Javie istnieje kilka klas, które zapewniają buforowane strumienie ( BufferedOutputStream, BufferedWriter...). Jeśli zapiszesz trzy bajty, te bajty zostaną zapisane w buforze (pamięci) zamiast wykonywania We / Wy tylko dla trzech bajtów. Gdy bufor jest pełny, zawartość jest opróżniana i zapisywana na dysku. Poprawia to wydajność.

Nic nie odkrywam, po prostu pamiętam, jak należy uzyskać dostęp do dysku.

Możesz oczywiście uczynić to trochę bardziej zaawansowanym. Nieblokowanie, pisanie bitów i kawałków, nie zapisywanie całego pliku na raz:

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

Zapis synchroniczny

fs.writeFileSync (plik, dane [, opcje])

fs = require('fs');

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

Zapis asynchroniczny

fs.writeFile (plik, dane [, opcje], oddzwanianie)

fs = require('fs');

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

Gdzie

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

Warto przeczytać ten offical File System (FS) docs .

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

Podobał mi się Indeks ./articles/file-system .

To zadziałało dla mnie.

Zobacz także Jak pisać pliki w 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');
});

Zawartość helloworld.txt:

Hello World!

Aktualizacja:
Jak w węźle Linuksa, pisz w bieżącym katalogu, wydaje się, że w niektórych innych tak nie jest, więc dodam ten komentarz na wszelki wypadek:
Używając tego, ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH);aby dostać się tam, gdzie zapisany jest plik.

Odpowiedzi są opatrzone datą, a nowszym sposobem na to jest:

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

zobacz dokumenty tutaj, aby uzyskać więcej informacji

Wiem, że pytanie dotyczące „zapisu”, ale w bardziej ogólnym znaczeniu, „append” może być przydatne w niektórych przypadkach, ponieważ można łatwo użyć go w pętli, aby dodać tekst do pliku (niezależnie od tego, czy plik istnieje). Użyj „\ n”, jeśli chcesz dodać linie, np .:

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

OK, jest to dość proste, ponieważ Node ma wbudowaną funkcjonalność do tego, nazywa się to, fsco oznacza system plików i, w zasadzie, moduł systemu plików NodeJS ...

Więc najpierw wymagaj tego w pliku server.js w następujący sposób:

var fs = require('fs');

fsma kilka metod zapisu do pliku, ale moim preferowanym sposobem jest użycie appendFile, to doda rzeczy do pliku, a jeśli plik nie istnieje, utworzy jeden, kod może wyglądać jak poniżej:

fs.appendFile('myFile.txt', 'Hi Ali!', function (err) {
  if (err) throw err;
  console.log('Thanks, It\'s saved to the file!');
});

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

Na przykład: odczytaj plik i zapisz do innego pliku:

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

Możesz pisać do pliku za pomocą modułu fs (system plików).

Oto przykład, jak możesz to zrobić:

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

Możesz także pozbyć się tej struktury kodu wywołania zwrotnego wewnątrz wywołania zwrotnego, używając Obietnic i async/ lub awaitinstrukcji. Spowoduje to, że struktura kodu asynchronicznego będzie o wiele bardziej płaska. Do tego służy przydatna funkcja util.promisify (oryginalna) . Pozwala nam przejść z oddzwaniania do obietnic. Spójrz na przykład z fsfunkcjami poniżej:

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

Tutaj używamy w + do odczytu / zapisu obu akcji, a jeśli ścieżka pliku nie zostanie znaleziona, zostanie utworzona automatycznie.

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

Treść oznacza, co musisz zapisać do pliku i jego długość, „content.length”.

Oto przykład, jak odczytać plik csv z lokalnego i zapisać plik csv do lokalnego.

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

fs.createWriteStream(path[,options])

optionsmoże również zawierać startopcję umożliwiającą zapis danych w pewnej pozycji poza początkiem pliku. Modyfikowanie pliku zamiast zastępowania może wymagać flagstrybu r+raczej niż trybu domyślnego w. Kodowanie może być dowolnym z zaakceptowanych przez bufor .

Jeśli autoClosejest ustawiony na true (zachowanie domyślne) 'error'lub 'finish'deskryptor pliku zostanie zamknięty automatycznie. Jeśli autoClosema wartość false, deskryptor pliku nie zostanie zamknięty, nawet jeśli wystąpi błąd. Aplikacja jest odpowiedzialna za jej zamknięcie i upewnienie się, że nie ma wycieku deskryptora pliku.

Podobnie jak ReadStream , jeśli fdjest określony, WriteStream zignoruje pathargument i użyje określonego deskryptora pliku. Oznacza to, że żadne 'open'zdarzenie nie będzie emitowane. fdpowinien blokować; nieblokujące fds należy przekazać do net.Socket .

Jeśli optionsjest łańcuchem, to określa kodowanie.

Po przeczytaniu tego długiego artykułu. Powinieneś zrozumieć, jak to działa. Oto przykład 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');

Możesz użyć biblioteki easy-file-manager

zainstaluj najpierw z npm npm install easy-file-manager

Próbka do przesłania i usunięcia plików

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

Możesz zapisać w pliku za pomocą następującego przykładu kodu:

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