Een CSV-bestand is een plat tekstbestand dat gegevens in tabelvorm opslaat. In de meeste gevallen gebruiken CSV-bestanden komma's (,) als scheidingsteken, vandaar de naam CSV (Comma Separated Values). Het wordt gebruikt in situaties waarin gegevenscompatibiliteit een rol speelt, aangezien CSV’s geopend kunnen worden met elke teksteditor, spreadsheet-apps en andere gespecialiseerde tools. In feite bieden veel programmeertalen ingebouwde ondersteuning voor CSV.
In deze handleiding leren we hoe we CSV kunnen gebruiken in een voorbeeld-Node.js-applicatie.
CSV in Node.js
Node.js is een open-source en cross-platform JavaScript-runtime-omgeving. Het is een van de meest populaire backends geworden die tal van webdiensten over het hele internet aanstuurt. Zelfs grote bedrijven zoals Netflix en Uber gebruiken Node.js om hun diensten aan te sturen.
Node.js heeft ook tal van modules beschikbaar die kunnen worden ingezet om extra functionaliteit aan een project toe te voegen. Als het om CSV gaat, zijn er veel modules beschikbaar om te gebruiken, bijvoorbeeld node-csv, fast-csv, en papaparse etc.
Zoals de titel van de handleiding suggereert, gaan we node-csv gebruiken om CSV-bestanden te lezen met behulp van Node.js-streams. We zullen ook demonstreren hoe we met de geparseerde gegevens kunnen werken, bijvoorbeeld door de gegevens over te zetten naar een SQLite-database.
Vereisten
-
Om de stappen in deze handleiding uit te voeren, heeft u de volgende componenten nodig:
-
Een correct geconfigureerd Linux-systeem. Lees meer over het installeren en configureren van een Ubuntu-cloudserver op CloudSigma.
-
Toegang tot een niet-rootgebruiker met sudo-rechten. Bekijk het beheren van sudo-rechten met sudoers.
-
Een geschikte teksteditor, bijvoorbeeld Brackets, VS Code, Sublime Text, Vim/NeoVim, enz.
-
Andere software:
-
Node.js LTS
-
SQLite
-
Step 1 – Benodigde software installeren
Voor deze handleiding heb ik een lichtgewicht server gemaakt met Ubuntu 22.04 LTS (verbonden via SSH):
Nu zullen we Node.js and SQLite hierop installeren.
-
Node.js LTS installeren
Node.js is rechtstreeks beschikbaar via de officiële Ubuntu-pakketbronnen. Het is echter niet de meest recente versie. Daarom gaan we vertrouwen op een externe repository (Nodesource) om de nieuwste Node.js-pakketten te verkrijgen.
Voeg de repository toe voor Node.js LTS:
|
1 |
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash - |
Installeer nu Node.js LTS:
|
1 |
sudo apt install nodejs -y |
-
SQLite installeren
We installeren SQLite rechtstreeks vanuit de Ubuntu-pakketbronnen. Voer de volgende commando's uit:
|
1 |
sudo apt install sqlite3 -y |
Step 2 – Projectmap instellen
In dit gedeelte bereiden we een speciale map voor ons project voor. Deze zal alle projectbestanden bevatten, samen met aanvullende modules.
Maak een nieuwe map aan:
|
1 |
mkdir -pv csv_practice |
Navigeer naar de map:
|
1 |
cd csv_practice/ |
Voer vervolgens het volgende commando uit om de map te declareren als een npm-project:
|
1 |
npm init -y |
Zodra de projectmap is geïnitialiseerd, kunnen we beginnen met het installeren van de benodigde pakketten en modules. Eerst gaan we installerennode-csv:
|
1 |
npm install csv |
De node-csv-module is eigenlijk een verzameling van verschillende andere modules: csv-generate, csv-parse (voor het parsen van CSV-bestanden), csv-stringify (voor het schrijven van gegevens naar CSV) en stream-transform.
Vervolgens hebben we de module nodig om met SQLite te communiceren. Het volgende commando installeert de node-sqlite3-module:
|
1 |
npm install sqlite3 |
Het component dat we nodig hebben voor ons project is een CSV-bestand. Voor demonstratiedoeleinden gaan we het CSV-bestand met migratiegegevens van Nieuw-Zeeland gebruiken:
|
1 |
wget https://www.stats.govt.nz/assets/Uploads/International-migration/International-migration-September-2021-Infoshare-tables/Download-data/international-migration-September-2021-estimated-migration-by-age-and-sex-csv.csv -O migration_data.csv |
Laten we snel naar de inhoud van het bestand kijken:
|
1 |
cat migration_data.csv | less |
Hier,
-
De eerste regel beschrijft de kolomnamen.
-
De volgende regels bevatten de waarden voor deze velden.
-
Elke rij is gescheiden door een nieuwe regel (\n).
-
Elk datapunt is gescheiden door een komma (,).
CSV is echter niet beperkt tot het gebruik van komma’s als scheidingsteken. Andere veelvoorkomende scheidingstekens zijn dubbele punten (:), puntkomma’s (;) en tabs (\td).
Stap 3 – CSV lezen
In deze sectie demonstreren we het implementeren van een voorbeeldprogramma dat gegevens uit het CSV-bestand leest en parseert.
Maak een nieuw JavaScript-bestand aan:
|
1 |
touch read_csv.js |
Open het bestand in je favoriete tekstverwerker:
|
1 |
nano read_csv.js |
Eerst gaan we de fs en csv-parse modules importeren:
|
1 2 |
const fs = require("fs"); const { parse } = require("csv-parse"); |
Hier,
-
Eerst wordt aan de fs variabele het fs object toegewezen dat de Node.js require() methode retourneert bij het importeren van de module.
-
Vervolgens wordt de parse-methode uit het object dat is geretourneerd door de require() methode geëxtraheerd naar de parse-variabele met behulp van de destructuring-syntaxis.
Vervolgens gaan we code toevoegen om het CSV-bestand te lezen:
|
1 2 3 4 5 |
fs.createReadStream("./migration_data.csv") .pipe(parse({ delimiter: ",", from_line: 2 })) .on("data", function (row) { console.log(row); }) |
Hier,
-
We roepen de createReadStream() aan vanuit de fs-module en geven het CSV-bestand dat we willen lezen door als argument. Dit maakt vervolgens een leesbare stream door het grotere bestand in kleinere stukken op te delen.
-
Na het maken van de stream stuurt de pipe() methode delen van de streamgegevens door naar een andere stream. Deze nieuwe stream wordt gemaakt bij het aanroepen van de parse() methode uit de csv-module.
-
De csv-module stelt een leesbare/schrijfbare transformatiestream beschikbaar die een gegevenssegment neemt en dit in een andere vorm transformeert.
-
De parse() methode accepteert objecten met eigenschappen. Het object verwerkt de geparseerde gegevens verder. Hier neemt het object de volgende eigenschappen aan:
-
delimiter: Het scheidingsteken om waarden te scheiden. In het geval van onze doel-CSV is dit een komma (,).
-
from_line: Het aantal regels vanaf waar de parser begint met parseren. Met de opgegeven waarde 2 slaat de parser regel 1 over en begint op regel 2. Met deze opzet voorkomen we dat de kolomnamen in de geparseerde gegevens worden opgenomen.
-
Vervolgens gaan we een streaming-event koppelen met behulp van de on() methode van Node.js:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
fs.createReadStream("./migration_data.csv") .pipe(parse({ delimiter: ",", from_line: 2 })) .on("data", function (row) { console.log(row); }) .on("end", function () { console.log("finished"); }) .on("error", function (error) { console.log(error.message); }); |
Hier,
-
Bij het activeren van een bepaalde gebeurtenis stelt een streaming-event een methode in staat om een deel van de gegevens te consumeren.
-
Wanneer gegevens die zijn geparseerd door de parse() methode klaar zijn om te worden geconsumeerd, activeert dit de data gebeurtenis.
-
Om toegang te krijgen tot de gegevens, geven we een callback door aan de on() methode die een parameter row accepteert.
-
De parameter row is een deel van de gegevens in de vorm van een array (het resultaat van het parseren).
-
Ten slotte worden de gegevens in de console gelogd met behulp van console.log().
Om het programma te voltooien, gaan we extra stream-events toevoegen om fouten af te handelen en een succesbericht af te drukken wanneer alle gegevens in het CSV-bestand zijn verwerkt. Werk de code als volgt bij:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
fs.createReadStream("./migration_data.csv") .pipe(parse({ delimiter: ",", from_line: 2 })) .on("data", function (row) { console.log(row); }) .on("end", function () { console.log("finished"); }) .on("error", function (error) { console.log(error.message); }); |
Hier,
-
Het end-event wordt geactiveerd wanneer alle gegevens in het CSV-bestand zijn verwerkt. Dit resulteert in het aanroepen van de console.log() methode die een succesbericht afdrukt.
-
Het error-event wordt geactiveerd wanneer er een fout optreedt tijdens het parseren van de CSV-gegevens. Dit resulteert in het aanroepen van de console.log() methode die een foutmelding afdrukt.
De uiteindelijke code zou er als volgt uit moeten zien:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
const fs = require("fs"); const { parse } = require("csv-parse"); fs.createReadStream("./migration_data.csv") .pipe(parse({ delimiter: ",", from_line: 2 })) .on("data", function (row) { console.log(row); }) .on("end", function () { console.log("finished"); }) .on("error", function (error) { console.log(error.message); }); |
Sla het bestand op en sluit de editor. We zijn nu klaar om het programma uit te voeren. Voer het uit met Node.js:
|
1 |
node read_csv.js |
De uitvoer zou er ongeveer zo uit moeten zien:
Merk op dat de gegevens worden verwerkt, getransformeerd en op de console worden afgedrukt. Omdat het een continu proces is, zal het lijken alsof de gegevens worden gedownload in plaats van dat de uitvoer in één keer wordt afgedrukt.
Stap 4 – CSV-gegevens overdragen naar een database
Tot nu toe hebben we geleerd hoe we een CSV-bestand kunnen parseren met node-csv. In deze sectie wordt gedemonstreerd hoe u de geparseerde gegevens overdraagt naar een database (SQLite).
Maak een nieuw JavaScript-bestand om met de database te communiceren:
|
1 |
touch csv-to-sqlite3.js |
Open nu het bestand in een teksteditor:
|
1 |
nano csv-to-sqlite3.js |
We beginnen ons programma met de volgende code:
|
1 2 3 |
const fs = require("fs"); const sqlite3 = require("sqlite3").verbose(); const filepath = "./population.db"; |
Hier,
-
In de eerste regel importeren we de fs module.
-
In de derde regel bevat de variabele filepath het pad van de SQLite-database.
-
Op dit moment bestaat de database nog niet. Deze is echter wel nodig bij het werken met node-sqlite3.
Voeg vervolgens de volgende regels toe om een verbinding met de SQLite-database tot stand te brengen:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
function connectToDatabase() { if (fs.existsSync(filepath)) { return new sqlite3.Database(filepath); } else { const db = new sqlite3.Database(filepath, (error) => { if (error) { return console.error(error.message); } console.log("Succesvol verbonden met de database"); }); return db; } } |
Hier,
-
De methode connectoToDatabase() brengt een verbinding met de database tot stand.
-
Binnen connectToDatabase(), roepen we de existsSync() methode van de fs-module aan binnen een if-statement. Het if-statement controleert het bestaan van de database op de opgegeven locatie.
-
Als de evaluatie van de voorwaarde true is, dan is de Database() klasse van de node-sqlite3 module. Zodra de verbinding tot stand is gebracht, retourneert de functie een object en eindigt deze.
-
Als de evaluatie van de voorwaarde false is (de database bestaat niet), dan springt de uitvoering naar het else-blok. Daar zal de Database() klasse worden geïnitieerd met twee argumenten: een pad naar het databasebestand en een callback.
-
In principe wordt de database aangemaakt als deze niet bestaat. Als er echter een fout optreedt tijdens het aanmaakproces, zal deze het error object instellen en de foutmelding afdrukken.
Vervolgens gaan we code introduceren om een tabel aan te maken als een database niet bestaat:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
const fs = require("fs"); const sqlite3 = require("sqlite3").verbose(); const filepath = "./population.db"; function connectToDatabase() { if (fs.existsSync(filepath)) { return new sqlite3.Database(filepath); } else { const db = new sqlite3.Database(filepath, (error) => { if (error) { return console.error(error.message); } createTable(db); console.log("Succesvol verbonden met de database"); }); return db; } } function createTable(db) { db.exec(` CREATE TABLE migration ( year_month VARCHAR(10), month_of_release VARCHAR(10), passenger_type VARCHAR(50), direction VARCHAR(20), sex VARCHAR(10), age VARCHAR(50), estimate INT ) `); } module.exports = connectToDatabase(); |
Hier,
-
De connectToDatabase() roept de createTable() functie aan die de objecten accepteert die zijn opgeslagen in db als een argument.
-
Buiten connectToDatabase(), hebben we de createTable() methode gedefinieerd die het verbindingsobject db als parameter accepteert.
-
De exec() methode op db neemt een SQL-statement als argument. Binnen dit SQL-statement hebben we de creatie van een tabel gedefinieerd migration met 7 kolommen, waarbij elke kolom overeenkomt met de kolomkoppen in het migration_data.csv bestand.
-
Ten slotte roepen we de connectToDatabase() methode en het exporteren van het verbindingsobject dat het retourneert, zodat we het in andere bestanden kunnen gebruiken.
Sla het bestand op en sluit de editor.
Vervolgens gaan we een ander programma maken om de geparste gegevens in de database in te voegen:
|
1 |
nano insert_data.js |
Voer de volgende code in in insert_data.js:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
const fs = require("fs"); const { parse } = require("csv-parse"); const db = require("./csv-to-sqlite3"); fs.createReadStream("./migration_data.csv") .pipe(parse({ delimiter: ",", from_line: 2 })) .on("data", function (row) { db.serialize(function () { db.run( `INSERT INTO migration VALUES (?, ?, ? , ?, ?, ?, ?)`, [row[0], row[1], row[2], row[3], row[4], row[5], row[6]], function (error) { if (error) { return console.log(error.message); } console.log(`Row inserted, ID: ${this.lastID}`); } ); }); }); |
Hier,
-
We slaan het verbindingsobject verkregen uit csv-to-sqlite3.js op in de variabele db.
-
Binnen de data event callback (gekoppeld aan de fs module stream), roepen we de serialize() methode aan op het verbindingsobject. Dit zorgt ervoor dat de uitvoering van de ene SQL-instructie is voltooid voordat de volgende begint, wat database race conditions (systeem dat concurrerende bewerkingen tegelijkertijd uitvoert) voorkomt.
-
De serialize() accepteert drie argumenten:
-
Het eerste argument is de SQL-instructie.
-
Het tweede argument is een array.
-
Het derde argument is een callback die wordt uitgevoerd wanneer gegevens met succes of onsuccesvol in de database zijn ingevoegd.
-
We zijn klaar om het programma uit te voeren. Voer insert_data.js uit met behulp van Node.js:
|
1 |
node insert_data.js |
Afhankelijk van de prestaties van het systeem kan het proces enige tijd duren om te voltooien. Na voltooiing zou de uitvoer er echter ongeveer zo uit moeten zien:
Stap 5 – Gegevens naar CSV schrijven
Na de laatste sectie hebben we een database met alle records die we hebben geparst uit migration_data.csv. In deze sectie gaan we de gegevens uit de database lezen en in een apart CSV-bestand schrijven.
Maak een nieuw JavaScript-bestand om het programma in op te slaan:
|
1 |
nano write_csv.js |
Voeg eerst de volgende regels toe om te importerenfs and csv-stringify samen met het databaseverbindingsobject uit csv-to-sqlite3.js:
|
1 2 3 |
const fs = require("fs"); const { stringify } = require("csv-stringify"); const db = require("./csv-to-sqlite3"); |
Vervolgens gaan we een variabele toevoegen die de naam van het CSV-bestand bevat waarnaar moet worden geschreven, samen met een writable stream:
|
1 2 3 4 5 6 7 8 9 10 11 |
const filename = "saved_from_db.csv"; const writableStream = fs.createWriteStream(filename); const columns = [ "year_month", "month_of_release", "passenger_type", "direction", "sex", "age", "estimate", ]; |
Hier,
-
De createWriteStream()-methode accepteert de bestandsnaam waarnaar moet worden geschreven als argument. We gaan het bestand saved_from_db.csv.
-
De column-variabele slaat een array op die alle namen van de header voor de CSV-gegevens bevat.
Voeg vervolgens de volgende regels code toe om gegevens uit de database te lezen en deze te schrijven naar saved_from_db.csv:
|
1 2 3 4 5 6 7 8 9 10 11 |
const stringifier = stringify({ header: true, columns: columns }); db.each(`select * from migration`, (error, row) => { if (error) { return console.log(error.message); } stringifier.write(row); }); stringifier.pipe(writableStream); console.log("finished writing to CSV"); |
Hier,
-
We roepen de stringify() methode aan met een object als argument. Dit resulteert in een transform stream die de gegevens van een object naar CSV-indeling converteert. Het object dat wordt doorgegeven aan stringify() heeft twee eigenschappen:
-
header: Accepteert een Boolean-waarde. Als de waarde true is, wordt er een header gegenereerd.
-
columns: Accepteert een array die de kolomnamen bevat die in de eerste regel van het CSV-bestand moeten worden geschreven als header is true.
-
-
De each() methode van het csv-to-sqlite3-verbindingsobject wordt aangeroepen met twee argumenten: de SQL-instructie (gegevens lezen uit de database) en een callback (afhandeling van succes/fout).
-
Bij elke iteratie van each(), pipe() (van de stringifier-stream) begint met het verzenden van gegevens in chunks naar de writable stream writableStream. Elk chunk met gegevens wordt vervolgens geschreven naar saved_from_db.csv.
-
Wanneer alle gegevens naar het CSV-bestand zijn geschreven, wordt er een succesbericht op het consolescherm afgedrukt.
De uiteindelijke code zou er als volgt uit moeten zien:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
const fs = require("fs"); const { stringify } = require("csv-stringify"); const db = require("./csv-to-sqlite3"); const filename = "saved_from_db.csv"; const writableStream = fs.createWriteStream(filename); const columns = [ "year_month", "month_of_release", "passenger_type", "direction", "sex", "age", "estimate", ]; const stringifier = stringify({ header: true, columns: columns }); db.each(`select * from migration`, (error, row) => { if (error) { return console.log(error.message); } stringifier.write(row); }); stringifier.pipe(writableStream); console.log("klaar met schrijven naar CSV"); |
Sla het bestand op en sluit de editor. We kunnen het programma nu uitvoeren met Node.js:
|
1 |
node write_csv.js |
Om te controleren of de gegevens succesvol zijn geëxporteerd, bekijk de inhoud van saved_from_db.csv:
|
1 |
cat saved_from_db.csv | less |
Laatste overwegingen
In deze handleiding hebben we gedemonstreerd hoe u met CSV-bestanden werkt in Node.js met behulp van de modules node-csv en node-sqlite3. We hebben meerdere programma's gemaakt om verschillende taken uit te voeren, bijvoorbeeld het parseren van gegevens uit CSV, het pushen van de gegevens naar een SQLite-database en het schrijven van gegevens naar een nieuw CSV-bestand.
Deze handleiding toont slechts een klein deel van de mogelijkheden van de node-csv module. Lees meer over alle functies op CSV Project. Voor meer informatie over node-sqlite3, bekijk de officiële documentatie op GitHub. Een andere module die het vermelden waard is, is event-stream om het werken met streams te vereenvoudigen.
Geïnteresseerd in het verder uitbreiden van uw Node.js-project? Hier zijn enkele Node.js-handleidingen die u zou moeten bekijken:
-
Node.js-modules gebruiken met npm and package.json: een handleiding
-
Een Node.js (Express.js) app implementeren met Docker op Ubuntu 20.04
-
PostgreSQL verbinden met Node.js-applicaties: een handleiding
-
Node.js-applicaties instellen: productietaken uitvoeren op Ubuntu 20.04 met Node.js
Veel plezier met programmeren!
Reacties
Nog geen reacties. Wees de eerste.