Built-in modules

process

Het process object is een globaal object dat toegang verleent tot de informatie en de controle over het huidige Node.js proces.

Opmerking

Omdat process een globaal object is, moet de require() functie niet vermeld worden, zoals:

const process = require("process"); // Hoeft niet.

process.env

Via de env eigenschap uit het process object kunnen we een object opvragen bestaande uit eigenschappen uit de gebruikersomgeving:

console.log(process.env);

We kunnen in het .env-object configuratievariabelen instellen die door de applicatie kunnen worden gebruikt. Bijvoorbeeld, je kunt een variabele zoals process.env.PORT gebruiken om de poort waarop de server luistert te configureren.

Het is een veilige manier om gevoelige informatie, zoals API-sleutels of databaseverbindingssnaren, op te slaan. Deze waarden kunnen buiten de broncode worden gehouden en dynamisch worden ingesteld op basis van de omgeving.

Tip

We schrijven configuratievariabelen in hoofdletters omdat dit waarden zijn die niet zullen veranderen. Een configuratie- of omgevingsvariabele, kan als waarde enkel een string, numerieke waarde of boolean bevatten.

Hoe ENV-variabelen instellen?

• In lokale ontwikkeling kun je omgevingsvariabelen instellen in het terminalvenster waarin je de Node.js-applicatie start:

  PORT=3000 node app.js
  

• Een veelgebruikte praktijk is om een bestand met de naam .env te maken in de root van je project en daarin de omgevingsvariabelen op te slaan. Hiervoor hebben wel een externe package nodig genaamd dotenv.

  .env

  API_KEY = my_random_api_key;
  

  npm install dotenv
  

  app.js

  require("dotenv").config();
  console.log(process.env.API_KEY);
  

listeners

Via het process object kunnen we ook luisteraars registreren, die reageren op specifieke gebeurtenissen die in het process kunnen plaatsvinden. Via de on methode kunnen we luisteraars koppelen, om bijvoorbeeld iets te doen net voor het programma wordt afgesloten:

process.on("exit", (code) => {
  console.log(`About to exit with code: ${code}`);
});

path

De path module (opens new window) maakt het mogelijk om bestandspaden platformonafhankelijk op te halen en eventueel te bewerken.

Hoewel het verleidelijk kan zijn om paden rechtstreeks te hardcoderen, zorgt de path-module voor:

• Platformonafhankelijkheid

  Verschillende besturingssystemen (Windows, Linux, macOS) gebruiken verschillende notaties voor paden (bijvoorbeeld backslashes \ versus slashes /). De path module zorgt ervoor dat paden correct worden geformatteerd op basis van het gebruikte besturingssysteem. Dit maakt je code platformonafhankelijk.

• Leesbaarheid

  Het gebruik van de path module maakt je code leesbaarder, omdat het duidelijk aangeeft dat je met bestands- of mapstructuren werkt.

• Veiligheid

  De module kan omgaan met speciale tekens en voorkomt hierdoor mogelijks beveiligingslekken.

• Toekomstige Wijzigingen

  Als je code op meerdere platforms moet werken, is het mogelijk dat je padnotaties in de toekomst moet aanpassen als je besluit om te schakelen naar een ander besturingssysteem. Het gebruik van de path module vermindert de kans op fouten bij het beheren van deze veranderingen.

const path = require("path");

Met de path.join() methode kunnen we alle vermelde paden (moet een string-waarde zijn) met elkaar verbinden gebruik makend van de separator van het platform:

let joinedPath = path.join("users", "phildp", "bio.md");
console.log(joinedPath); // users\phildp\bio.md

// Goed
const fullPath = path.join(__dirname, "bestanden", "document.txt");

// Niet aanbevolen (minder leesbaar, minder veilig)
const fullPathHardcoded = __dirname + "/bestanden/document.txt";

fs

De fs module in Node.js staat voor “File System” en biedt functionaliteiten om met het bestandssysteem te werken. Het stelt ontwikkelaars in staat om bestanden te lezen, schrijven, wijzigen, verwijderen en andere bestandsbewerkingen uit te voeren

Tip

Node.js File system (opens new window)

Hiermee kunnen Node.js-applicaties toegang krijgen tot het lokale bestandssysteem. Dit zijn de bestanden opgeslagen op de server, niet op de client-side. Hierdoor kunnen we bestanden, mappen en hun inhoud bewerken. Het biedt zowel synchrone als asynchrone methoden om verschillende taken met betrekking tot het bestandssysteem uit te voeren.

Lezen van bestanden

const fs = require("fs");

fs.readFile("bestand.txt", "utf8", (err, data) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(data);
});

Je kan dit herschrijven om ook de path-module te gebruiken.

const fs = require("fs");
const path = require("path");

const bestandsPad = path.join(__dirname, "bestand.txt");

fs.readFile(bestandsPad, "utf8", (err, data) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(data);
});

Lezen van folders

const fs = require("fs");
const path = require("path");

const mapPad = path.join(__dirname, "pad", "naar", "je", "map");

fs.readdir(mapPad, (err, bestanden) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log("Bestanden in de map:", bestanden);
});

Schrijven naar een bestand

const fs = require("fs");
const path = require("path");

const bestandsPad = path.join(__dirname, "output.txt");
const tekst = "Hallo, dit wordt naar het bestand geschreven!";

fs.writeFile(bestandsPad, tekst, (err) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log("Bestand geschreven!");
});

Asynchroon werken met het filesystem

De ‘fs’ (File System) module in Node.js biedt twee manieren om met bestanden om te gaan: de callback-based benadering ('fs') en de Promise-based benadering ('fs/promises'). Het onderscheid ligt in de manier waarop asynchrone operaties worden afgehandeld.

Bij de ‘fs’-module worden operaties vaak uitgevoerd met behulp van callbacks. Bijvoorbeeld, het lezen van een bestand met ‘fs’:

callback.js

const fs = require("fs");

fs.readFile("bestand.txt", "utf8", (err, data) => {
  if (err) throw err;
  console.log(data);
});

Aan de andere kant maakt de 'fs/promises'-module gebruik van Promises, wat een meer gestructureerde en leesbare asynchrone code mogelijk maakt.

promises.js

const fsp = require("fs/promises");

async function readFileAsync() {
  try {
    const data = await fsp.readFile("bestand.txt", "utf8");
    console.log(data);
  } catch (err) {
    throw err;
  }
}

readFileAsync();

Zie ook

fs/promises (opens new window)

http

Laat toe om data verzenden over het Hyper Text Transfer Protocol (Afk. HTTP). Met deze HTTP module kunnen we een server maken dat luistert naar aanvragen (Eng. requests) naar deze server (met specifieke poort) en geeft een antwoord (Eng. response) terug aan de aanvrager.

Tip

Node.js HTTP (opens new window)

const http = require("http");

http
  .createServer(function (req, res) {
    res.writeHead(200, { "Content-Type": "text/html" });
    res.end("Hello World!");
  })
  .listen(8080);