Hur man läser och skriver JSON-filer i Node.js
Det är möjligt att läsa och skriva JSON-filer i Node.js. Allt du behöver göra är att använda fs-modulen enligt beskrivningen i vår enkla guide.
Läsa och skriva JSON-filer i Node.js
JavaScript Object Notation (JSON) är en mycket vanlig dataöverföringsstandard, särskilt känd för sin förmåga att representera organiserad information på ett kortfattat sätt. Detta format, som kännetecknas av sin textkaraktär, underlättar förståelsen för mänskliga användare samtidigt som det möjliggör sömlös parsning och generering av maskinbearbetningssystem.
Genom att använda kapaciteten för automatisk parsning och generering av JSON-data i Node.js kan strukturerad information lagras, överföras och hanteras på ett effektivt och enkelt sätt. Få en omfattande förståelse för hur man läser, komponerar och ändrar JSON-filer med hjälp av Node.js filsystemkomponent.
Node.js File System Module
Node.js File System Module, som är inbyggd i Node.js-miljön, gör det möjligt för användare att kommunicera med enhetens filsystem genom olika funktioner som att läsa filer, skapa nya och ta bort dem, bland annat.
Funktionerna som erbjuds av filssystemmodulen är tillgängliga i två olika modaliteter; de kan antingen ske asynkront eller synkront. Asynkrona operationer hindrar inte utvecklingen av din applikation eftersom de tillåter samtidig bearbetning med andra uppgifter. Metoder som följer detta mönster har vanligtvis en beteckning som anger deras asynkrona natur. Till exempel kan man hitta beteckningar som “Async” eller “await” som tillägg till metodnamnet, t.ex. readFileAsync eller writeFileAsync .
Medan synkrona metoder avbryter exekveringen av programmet tills filsystemoperationen är slutförd, tillåter asynkrona metoder att programmet fortsätter med andra uppgifter samtidigt genom att använda en callback-funktion som exekveras när operationen är slutförd. Illustrativa exempel är funktionerna readFile och writeFile.
För att bevara den icke-blockerande egenskapen hos händelseslingan och förbättra programmets övergripande effektivitet och snabbhet vid hantering av filer, är det absolut nödvändigt att använda asynkrona tekniker i alla interaktioner med filsystemet.
I specifika fall där enkelhet är av största vikt och operationen är sällsynt, t.ex. för grundläggande skriptuppgifter eller filhantering för engångsbruk, kanske asynkrona tillvägagångssätt inte är nödvändiga och synkrona tekniker kan visa sig vara en effektiv lösning.
Läsa JSON-filer med fs-modulen
För att kunna bearbeta en JSON-fil med asynkron JavaScript, är det nödvändigt att importera modulen för asynkront filsystem till den primära skriptfilen. Detta kan åstadkommas genom att inkludera en import-sats i början av filen, enligt nedanstående exempel:
const fs = require("node:fs/promises");
Om man använder en version av Node.js som är tidigare än version 18, måste man importera fs-modulen på ett sätt som följande:
const fs = require("fs/promises");
Om man vill importera hela modulen, inklusive både synkrona och asynkrona komponenter, är det nödvändigt att utelämna “/promises” från importangivelsen.
Med funktionen readFile kan man läsa innehållet i en JSON-fil genom att ange både en katalogsökväg och ett valfritt konfigurationsobjekt som parametrar. Detta konfigurationsobjekt kan antingen vara ett JavaScript-objekt som innehåller olika läspreferenser eller en sträng som inkapslar ett förutbestämt kodningsschema.
Objektalternativen inkluderar:
Den angivna parametern avgör vilken teckenuppsättning som används vid läsning av ett visst dokument, där standardkonfigurationen är “utf8”, som vanligtvis används för textinnehåll och “binary” som gäller för datafiler som inte innehåller text.
Symbolen asterisk (*) följt av parenteser, inneslutna i skruvade hängslen ({}), anger ett valfritt argument som standard har värdet “r”, vilket står för läsläge när en fil öppnas i ett specifikt filsystem. Andra vanliga filåtkomstlägen inkluderar “w” för skrivskyddat läge och “a” för append-läge.
Till exempel:
fs.readFile("./users.json", { encoding: "utf-8", flag: "r" })
.then((data) => {
const users = JSON.parse(data);
console.log(users);
})
.catch((error) => {
console.error('Error reading the JSON file:', error);
});
Det aktuella programmet är utformat för att bearbeta information som lagras i en fil med namnet “users.json”, som finns i omedelbar närhet av programvarans exekveringspunkt. För att extrahera innehållet i denna speciella fil kan man använda den inbyggda funktionaliteten i det programmeringsspråk som används. Specifikt kan metoden “JSON.parse” användas för att konvertera de hämtade uppgifterna till ett JavaScript-objekt. På så sätt får användaren möjlighet att interagera med och ändra den information som finns där, allt inom ramen för sin kodbas.
När man hanterar mindre JSON-filer kan man använda funktionen require för att synkront analysera sådana filer och konvertera deras innehåll till JavaScript-objekt. För mer omfattande JSON-filer eller när man arbetar i ett asynkront sammanhang rekommenderas dock att man istället använder metoden fs.readFile .Det är viktigt att notera att metoden kräver har potential att cacha hela filens innehåll i minnet, vilket kan leda till problem om JSON-data genomgår frekventa ändringar.
Skriva JSON-filer med fs-modulen
Funktionen writeFile gör det möjligt att skapa och skriva data i ett JSON-format genom att förse den med tre parametrar, nämligen filsökvägen, de data som ska skrivas och en valfri callback-funktion.
⭐En filsökväg.
Den information som är avsedd att lagras i en fil kan ha olika former, t.ex. en sträng, en buffert, en asynkron iterabel eller ett iterabelt objekt.
⭐Ett valfritt konfigurationsobjekt.
Denna metod använder asynkrona operationer för att skriva data till en angiven fil. Om filen redan existerar kommer dess aktuella innehåll att ersättas med de angivna uppgifterna, vilket effektivt ersätter all tidigare information som kan ha lagrats i den. Omvänt, i de fall filen ännu inte existerar, kommer denna teknik att skapa den och därefter fylla den med de data som skickas som indata, vilket säkerställer att all nödvändig information sparas på den angivna lagringsplatsen.
Till exempel:
const fakeUsers = [
{
id: 1,
name: "John Doe",
username: "johndoe123",
address: {
street: "123 Main St",
city: "Anytown",
},
},
{
id: 2,
name: "Jane Smith",
username: "janesmith456",
address: {
street: "456 Elm St",
city: "Another City",
},
}
];
fs.writeFile("./users.json", JSON.stringify(fakeUsers), {
encoding: "utf-8",
flag: "w",
}).catch((error) => {
console.error('Error writing the JSON file:', error);
});
en sträng eller en buffert. Om man vill spara ett objekt i filen måste man först omvandla det till en sträng med hjälp av metoden JSON.stringify.
Uppdatera JSON-filer med fs-modulen
Den medföljande koden erbjuder inte en direkt metod för att modifiera filer, eftersom skrivning till en fil raderar dess tidigare innehåll.
För att övervinna denna utmaning är ett tillvägagångssätt att hämta det befintliga innehållet i filen med hjälp av funktionen readFile . Därefter kan man konkatenera sina uppdaterade data med den hämtade informationen och tillhandahålla båda dataseten som indata för operationen writeFile .
Här är ett exempel på en funktion i Python som bygger på den beskrivna logiken:
const updateFile = async (filePath, data) => {
try {
const fileContents = await fs.readFile(filePath, {
encoding: "utf-8",
flag: "r",
});
const fileData = JSON.parse(fileContents);
const updatedFileData = [...fileData, ...data];
await fs.writeFile(filePath, JSON.stringify(updatedFileData), {
encoding: "utf-8",
flag: "w",
});
return "File updated successfully";
} catch (error) {
console.error('Error updating the JSON file:', error);
}
};
Du kan anropa funktionen på följande sätt:
updateFile("./users.json", [
{
id: 4,
name: "Jane Doe",
username: "janedoe123",
address: {
street: "123 Main St",
city: "Anytown",
},
},
{
id: 5,
name: "John Smith",
username: "johnsmith456",
address: {
street: "456 Elm St",
city: "Another City",
},
}
]).then((message) => {
console.log(message);
});
Det här kodavsnittet lägger till informationen om de nämnda användarna i en befintlig JSON-fil som heter “users.json”.
Säkerhetsaspekter för läsning och skrivning av JSON-filer
Att säkerställa säkerheten för en Node.js-applikation som hanterar JSON-filer är av största vikt, eftersom sådana åtgärder involverar kritiska aspekter av skydd.Det är viktigt att verifiera giltigheten hos JSON-data för att garantera att de överensstämmer med fördefinierade specifikationer. Dessutom är begränsning av åtkomstbehörigheter för filer och rensning av användarinmatningar effektiva åtgärder mot potentiella hot som kodinjektionsattacker.