Lær hvordan du skriver filer i Node

Node gir forskjellige alternativer for å skrive til filer i systemet ditt gjennom den innebygde fs modul. Disse inkluderer skrivefil(), appendFile(), og createWriteStream().

Som mange andre språk lar Node.js deg velge mellom å overskrive en eksisterende fil eller legge til den. Du bør også lære om avveiningene mellom å skrive en fil på en gang og streame den.

Bruke writeFile()

skrivefil() er kanskje den enkleste metoden du kan bruke for å skrive en fil i Node.

fs.writeFile (filnavn, data, tilbakeringing)

Her er et eksempel som viser hvordan du lager en ren tekstfil ved å bruke writeFile(). Du kan selvfølgelig lage andre filtyper som CSV eller JSON.

konst fs = krever("fs")
fs.writeFile("test.txt", "Nytt innhold", err => {
hvis (feil) {
konsoll.log (feil)
 }
});

writeFile() støtter async/await do i stedet for å bruke tilbakeringinger som i eksempelet ovenfor, kan du opprette filen som følger.

konst fs = krever("fs"). lover
asynkronfunksjonwriteToFile() {
prøve {
avvente fs.writeFile("test.txt", "Ny forts")
 } å fange (feil) {
konsoll.log (feil);
 }
}
writeToFile()

Som standard fungerer writeFile() ved å erstatte innholdet i den angitte filen med nytt innhold hvis filen eksisterer. Det er imidlertid flagg du kan bruke for å overstyre denne funksjonaliteten, for eksempel:

• r+ - åpner filen for å lese og skrive.
• w+ - åpner filen for å lese og skrive i begynnelsen av filen
• en - åpner filen for å skrive på slutten av filen.
• a+ - åpner filen for å lese og skrive på slutten av filen.

Du kan for eksempel bruke flagget a+ slik:

konst fs = krever("fs")
fs.writeFile("test.txt", "Nyere innhold", { flagg: "a+" }, feil => {
hvis (feil) {
konsoll.log (feil)
 }
});

Det er mange andre filsystemflagg du kan lære om i Nodedokumentasjon for fs-modulen.

De fs modul gir også skriveFileSync, den synkron versjon av writeFile().

konst fs = krever("fs")
fs.writeFileSync("test.txt", "Nyere innhold", { flagg: "a+" }, feil => {
hvis (feil) {
konsoll.log (feil)
 }
});

Bruke createWriteStream()

Ulempen med å bruke skrivefil() er at du må lagre alt innholdet i filen samtidig som ikke er skalerbart for store filer. createWriteStream() støtter imidlertid sekvensiell skriving. Dette betyr at du kan skrive én del data til en fil om gangen. Her er det generelle systemet for å lage en skrivbar strøm.

fs.createWriteStream (bane, alternativer)

Koden nedenfor skriver data til en tekstfil ved hjelp av strømmer

konst fs = krever("fs")
// lag en skrivbar strøm
la writeableStream = fs.createWriteStream("test.txt") 
// Skriv til filen ved å bruke den skrivbare strømmen
writeableStream.write("Nytt innhold");

Her er et annet eksempel som viser hvordan du kan overføre data til den skrivbare strømmen. Dette programmet skriver alle inndata fra terminalen til test.txt-filen så lenge terminalen er åpen.

konst fs = krever("fs")
la writableStream = fs.createWriteStream("test.txt"); 
process.stdin.pipe (skrivbarStream);

Hvis du kjører dette programmet fra kommandolinjen, kan du avslutte det med Ctrl + d eller Ctrl + c.

Du kan også skrive fra en annen fil til den skrivbare strømmen. Tenk på følgende eksempel:

konst fs = krever("fs")
la readableStream = fs.createReadStream("test.txt");
la writableStream = fs.createWriteStream("test2.txt");
readableStream.on("data", funksjon(del) {
 writableStream.write (klump);
});

Ved å lage en lesbar strøm av filen du vil kopiere, kan du lese innholdet i biter. Så for hver del som mottas, vil programmet skrive til målfilen.

Bruker appendFile()

appendFile() er en enkel metode for å legge til innhold på slutten av filen. Her er et eksempel.

konst fs = krever("fs")
fs.appendFile("test.txt", "tillagt innhold", err => {
hvis (feil) {
konsoll.feil (feil);
 }
});

Du kan også bruke async/wait.

konst fs = krever("fs"). lover
asynkronfunksjonappendToFile() {
prøve {
avvente fs.appendFile("test.txt", "tillagt innhold")
 } å fange (feil) {
konsoll.log (feil);
 }
}
appendToFile()

Som skrivefil(), appendFile har også en synkron versjon:

fs.appendFileSync("test.txt", "tillagt innhold");

Bruk strømmer til å skrive store filer

Denne artikkelen diskuterte flere tilnærminger til å skrive filer i Node. Mens writeFile() er veldig grei, er den bedre egnet for små filstørrelser siden den ikke tillater sekvensiell skriving. Hvis du har å gjøre med store filer, er det bedre å bruke skrivbare strømmer.