Node.js-tutorial

Na het dubbelklikken op het .msi-bestand verschijnt er een Windows beveiligingswaarschuwing. Klik op ‘Run’ om te bevestigen dat je het geselecteerde bestand wilt uitvoeren. De installatie-setup van Node.js wordt geopend.

Voordat je de installatie kunt starten, moet je eerst de licentievoorwaarden van de software accepteren. Geef aan in welke map van je bestandssysteem Node.js moet worden geïnstalleerd. Installeer Node.js inclusief npm package manager. Start de installatie door op ‘Install’ te klikken.

De installatie van de runtime-omgeving moet binnen enkele seconden voltooid zijn. Voltooi het installatieproces met een klik op ‘Finish’. Je lokale Node.js-installatie is nu klaar voor gebruik.

Je controleert of de installatie geslaagd is door Node.js te starten en een eerste eenvoudige JavaScript-code uit te voeren. De runtime-omgeving biedt daarvoor twee modi: je gebruikt Node.js in de interactieve modus of je voert de applicatiecode uit van een eerder aangemaakt JavaScript (.js)-bestand.

• Interactieve modus: Om Node.js in de interactieve modus te gebruiken, open je de Windows opdrachtprompt (cmd.exe) en voer je het commando node in. De zogenaamde REPL (Read-Evaluation-Print Loop), een interactieve opdrachtregelinterpreter (Command Prompt) wordt gestart. Deze leest JavaScript-code in (Read), evalueert deze (Evaluation) en stuurt het resultaat terug (Print). Daarna begint het geheel weer opnieuw (Loop).
• De JavaScript-code uit een bestand uitvoeren: Om de JavaScript-code uit een bestand naar de runtime-omgeving over te zetten, gebruik je het commando node in combinatie met het pad naar het betreffende bestand.

Test eerst de interactieve modus. Open hiervoor de Windows opdrachtprompt. Start de JavaScript runtime-omgeving via het commando node.

Je bent nu in de interactieve command prompt van Node.js. Om te controleren of Node.js correct geïnstalleerd is en goed werkt, adviseren wij de functie console.log(). Deze neemt waarden op en toont ze in de terminal. Test dit bijvoorbeeld met een eenvoudig ‘Hello World!’-script.

console.log('Hello World!');

De bovenstaande functie, die in de Node.js-prompt is ingevoerd en met de Enter-toets is bevestigd, geeft Node.js opdracht om de tekenreeks (string) 'Hello World!' naar de terminal te schrijven. 

De terminaluitvoer laat zien dat Node.js correct is geïnstalleerd en in staat is om JavaScript-code interactief uit te voeren. Je kunt met console.log() bijvoorbeeld ook het resultaat van een rekensom naar de terminal schrijven:

console.log (15 + 385 * 20);

Wil je gedetailleerde informatie over de geïnstalleerde Node.js-versie en haar modules laten weergeven, gebruik dan de volgende uitdrukking (expression):

process.versions

Wil je Node.js beëindigen en terugkeren naar de Windows opdrachtprompt, gebruik dan de toetsencombinatie [CTRL] + [C]. Er zijn twee toetsaanslagen nodig. Dit voorkomt dat je de interactieve opdrachtprompt per ongeluk verlaat.

Let op: wordt - zoals hierboven beschreven - de installatie-setup gebruikt, dan kan er per systeem slechts één versie van de JavaScript runtime-omgeving worden geïnstalleerd. Bij de installatie van een nieuwe versie van Node.js wordt de oude versie overschreven. Wil je meer dan één versie van Node.js tegelijk laten draaien, dan heb je een versiemanager nodig, zoals de Node Version Manager.

Via de require-functie worden eigen modules, basismodules of modules van derden geïntegreerd. Om dit te illustreren, splitsen we de zojuist aangemaakte webserverapplicatie in twee afzonderlijke bestanden: een bestand met de webservercode en een bestand met de applicatiecode. Vervolgens integreren we de applicatiecode als module in de webservercode.

Let op: Een opdeling naar functionaliteit komt overeen met het ontwerpprincipe Separation of Concerns (SoC). Dit is een fundamenteel ontwerpprincipe van modulaire computerprogramma's waarbij de applicatiecode zo is gestructureerd dat elk onderdeel dat een nieuwe, zelfstandige functionaliteit biedt, in een apart bestand wordt opgeslagen.

Ga als volgt te werk om je webserver te splitsen in twee afzonderlijke applicaties volgens het principe Separation of Concerns (SoC):

1. Schrijf de applicatiecode voor de handling van verzoeken en antwoorden

Maak een JavaScript bestand handle.js zoals in het volgende voorbeeld en sla het op in de directory my_webserver.

const handle = function (req, res) {
    res.writeHead(200, {
      'Content-Type': 'text/html'
    });
    res.write('Hello World!'); 
    res.end();
};

module.exports = handle;

Het handle.js-bestand bevat het gedeelte van je webserverapplicatie dat verzoeken en antwoorden behandelt. Het omvat in principe de callback-functie function(req, res), die je in het vorige voorbeeld binnen de http.createServer() inline hebt gedefinieerd. Deze callback-functie wordt opgeslagen in de constante handle. Om de als handle gedefinieerde callback-functie ook buiten handle.js te kunnen gebruiken, moet je deze als module exporteren. Node.js heeft daarvoor het object module.exports, waarmee willekeurige elementen (bijv. functies, strings, objecten, etc.) kunnen worden geëxporteerd.

2. Webservercode schrijven

Maak een JavaScript-bestand webserver1.js, zoals in het volgende voorbeeld, en sla het op in je applicatie-directory my_webserver.

const http = require('http');
const port = 8080;
const handle = require('./handle');

const server = http.createServer(handle); 

server.listen(port, () => {
    console.log('Server is available under http://127.0.0.1:' + port + '/');
});

De code is in principe dezelfde als die van de webserverapplicatie uit het vorige voorbeeld. Maar in plaats van de handling van verzoeken inline te definiëren in de createServer-functie, verwijs je in regel 5 naar de eerder aangemaakte module handle (je kunt de extensie .js weglaten). Om ervoor te zorgen dat de resource handle tijdens de programmaverloop beschikbaar is, moet deze als module via require() worden geïntegreerd. Aangezien beide bestanden zich in de huidige werkmap bevinden, gebruiken we het relatieve bestandspad ./handle. Absolute bestandspaden worden meestal niet gebruikt in Node.js-projecten.

3. Webserverapplicatie uitvoeren

Open de Windows opdrachtprompt, navigeer naar de directory my_webserver en voer het JavaScript-bestand Webserver1.js uit met de volgende opdracht:

node webserver1.js

Als de module handle correct geïntegreerd is, verschijnt de statusmelding: “Server is available under http://127.0.0.1:8080”. Als je dit adres oproept, krijg je: “Hello World!”.

Wil je je zelfgemaakte toepassingen of programmaonderdelen aan andere gebruikers van Node.js ter beschikking stellen, dan adviseren wij een publicatie via npm. De npm registry is voor de community een centraal archief voor modules van derden. In principe kan elke gebruiker van Node.js modules aanbieden. Voorwaarde hiervoor is een gratis registratie bij npm.

Let op: Naast een gratis account, biedt npm ook betaalde abonnementen voor individuele ontwikkelaars en teams aan, die een uitgebreide reeks extra functies bieden.

Om je bij npm te registreren, ga je als volgt te werk:

1. Ga naar de npm startpagina .
2. Vul het inschrijfformulier in en stuur het terug.
3. Bevestig je e-mailadres.

Je kunt nu inloggen via de webinterface onder www.npmjs.com. Als alternatief stelt npm ook de volgende opdracht voor het aanmelden via de terminal ter beschikking:

npm login

Telkens wanneer je je via de terminal aanmeldt, wordt je gevraagd om je gebruikersnaam, wachtwoord en e-mailadres. Nadat je bent ingelogd via de terminal kun je een willekeurig aantal Node.js-modules publiceren.

Voorwaarde voor de publicatie van een module is dat deze een volledig package.json bevat, met alle metadata voor de module. Standaard bevat dit metadatabestand de volgende informatie:

• name: de naam van je module (verplicht)
• version: de versie van je module (verplicht)
• description: een korte beschrijving van je module
• entry point: het oorspronkelijke bestand van je applicatie (bijv. index.js)
• test command: een commando dat kan worden gebruikt om tests te starten (indien beschikbaar)
• git repository: URL naar een git repository, bijv. GitHub (indien beschikbaar)
• keywords: sleutelwoorden voor de vindbaarheid via de npm-zoekfunctie
• author: je naam
• license: de licentie waaronder het project wordt gepubliceerd (bv. MIT)

Node.js-gebruikers die de package .json niet handmatig willen schrijven, kunnen de volgende opdrachtregelopdracht gebruiken:

npm init

Deze start een commandoregelprogramma dat basis-metadata in de interactieve modus opzoekt en vervolgens een JSON-bestand aanmaakt volgens onderstaand schema:

{
  "name": "module-name",
  "version": "1.0.0",
  "description": "An example module to illustrate the usage of a package.json",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "repository": {
    "type": "git",
    "url": "https://github.com/username/repo.git"
  },
  "keywords": [
    "example"
  ],
  "author": "John Doe",
  "license": "MIT"
}

Let op: Het via npm init aangemaakte package.json moet normaal gesproken handmatig worden aangevuld, bijvoorbeeld met een lijst van derdenmodules die voor het programmaverloop nodig zijn. Deze worden opgenomen onder dependencies (afhankelijkheden).  

"dependencies": {
    "express": "4.2.x",
    "… "
  }

Het huidige voorbeeld toont een afhankelijkheid van de derdenmodule express in de versie 4.2. x.

Alleen de in package.json opgeslagen metadata maken het mogelijk om een module uniek te identificeren via naam en versienummer. Bovendien biedt package.json andere gebruikers van Node.js alle informatie die ze nodig hebben om de module te gebruiken en de benodigde afhankelijkheden te leveren. Want in principe wordt elke module in het register geladen zonder node_modules-map. Als een module van een derde wordt gebruikt, dan gebruikt Node.js de waarden onder dependencies in plaats daarvan om de vereiste modules automatisch te downloaden. Je moet deze metadata daarom altijd specificeren wanneer je eigen derdenmodules in je toepassing opneemt.

Wanneer je alle relevante metadata in de package.json hebt gestopt, staat niets de publicatie van je toepassing meer in de weg. De upload naar de npm-registry wordt in drie eenvoudige stappen uitgevoerd:

1. Inloggen

Log in bij npm via de terminal.

npm login

2. Applicatie kiezen

Navigeer naar de directory van de toepassing die je als module wilt publiceren.

3. Module publiceren

Voer de volgende opdracht in de terminal in en bevestig met Enter:

npm publish

Het commando npm publish pakt de geselecteerde module (applicatiecode en package.json) als een tar-archief en uploadt deze naar het npm-registry.

Let op: een gepubliceerde module kan alleen binnen de eerste 24 uur na publicatie worden verwijderd. Gebruik daarvoor het volgende commando:

npm unpublish

Modules die langer dan 24 uur online zijn, kunnen niet meer door de gebruiker worden verwijderd. Neem in dit geval contact op met de npm-support. Deze unpublish-functie is bedoeld om te voorkomen dat gebruikers van Node.js applicaties ontwikkelen die afhankelijk zijn van modules die later niet meer beschikbaar zijn.

Writable streams ontvangen data bloksgewijs en bieden je de mogelijkheid deze naar een willekeurige bestemming te schrijven – bijvoorbeeld een bestand of een andere stream. Net als readable streams zijn ook writable streams afgeleid van de EventEmitter klasse en daarom in staat om events te activeren. Deze spelen echter een ondergeschikte rol bij de omgang met writable streams.

Centrale elementen van dit type stream zijn in plaats daarvan de functies write() en end(), die in elk geval geïmplementeerd moeten zijn. De functionaliteit van de writable stream wordt geïllustreerd door een voorbeeld van een eenvoudige bestandsbewerking waarin we tekstelementen uit de programmacode van een JavaScript-toepassing naar een tekstbestand schrijven met behulp van een stream.

1. Toepassingscode schrijven

Maak een JavaScript-toepassing op basis van het volgende voorbeeld en sla deze op onder write-stream.jx in een willekeurige directory.

const fs = require('fs');
const MyWritableStream = fs.createWriteStream('output.txt', { defaultEncoding: 'utf8' });
MyWritableStream.write('Hello');
MyWritableStream.write('World!\n');

MyWritableStream.end(); 

MyWritableStream.on('finish', function() {
    console.log("Write completed.");
});
MyWritableStream.on('error', function(err) {
   console.log(err.stack);
});

Net als readable streams kunnen writable streams ook met de module fs worden aangemaakt, die je in je toepassing laadt via de functie require(). Gebruik daarvoor de functie fs.createWriteStream(). Deze functie verwacht als eerste parameter ook een pad- of bestandsnaam die aangeeft waar de streamingdata moeten worden opgeslagen.

Als het bestand output.txt nog niet bestaat, dan wordt het tijdens de uitvoering van het programma automatisch aangemaakt. Anders overschrijft de writable stream een bestaand bestand met dezelfde naam. Stel ook de optionele coderingsparameter voor writable streams in. Anders dan bij readable stream wordt daarvoor het keyword defaultEncoding gebruikt.

Zodra de writable stream is aangemaakt op het output.txt bestand, kun je de functie write() gebruiken om gegevens bloksgewijs naar de stream te schrijven. Zolang de writable stream is geopend, kan de write functie een willekeurig aantal keren worden opgeroepen. Hiermee kun je gegevens in delen naar de stream schrijven. Als je geen verdere gegevens naar de stream wilt schrijven, dan sluit je deze af met de end functie.

Writable streams veroorzaken ook gebeurtenissen. In de voorbeeldtoepassing reageren we op het finish-en het error-event. Het finish-event wordt altijd geactiveerd wanneer alle streaming gegevens met succes naar het opslagdoel zijn geschreven. Wil je in dit geval een statusmelding krijgen (bijv. write completed), voeg dan een bijbehorende console.log() toe aan het finish-event via on().

Net als readable streams, genereren writable streams ook error-events als er een fout optreedt tijdens het schrijfproces. Voeg een console.log-functie toe aan dit event om de foutmelding als terminaluitvoer te ontvangen.

2. Toepassingscode uitvoeren

Open de Windows opdrachtprompt, navigeer naar de geselecteerde directory en start write-stream.js met het volgende commando:

node write-stream.js

Als het programma foutloos is uitgevoerd, dan krijg je de uitvoer ‘write completed’. In je bestandssysteem is het tekstbestand output.txt gecreëerd met de inhoud ‘Hello World!’.

In de context van database-operaties spreek je ook de constante connection aan, die je in het vorige voorbeeld hebt gedefinieerd, om toegang te krijgen tot createConnection() en de parameters voor de totstandbrenging van de verbinding. Alle database-taken worden uitgevoerd met de functie query(). Deze verwacht als eerste parameter een SQL-statement, die aangeeft welke taak moet worden uitgevoerd en op welke data deze betrekking heeft. De feitelijke interactie met de database vindt plaats in de databasetaal SQL. De SQL-statement kan inline gedefinieerd worden of in een variabele/constante worden opgeslagen.

Let op: Hoewel MongoDB asynchroon loopt – wat kenmerkend is voor Node.js – werkt MySQL synchroon.

Vergelijk:

connection.connect();
connection.query(…);

en

connection.connect(xy => {xy.query()})

Dat is niet te wijten aan de database - het is een beslissing van de moduleontwikkelaars.

Inline:

connection.query('SELECT column FROM table', function(error, results, fields) {
    if (err) {
    console.log('Failed to select column Form table.', err.message);
    process.exit(1);
  }

  console.log('The solution is: ', results[0].column;
});

Uitbestede SQL-statement:

const sql = "SELECT-kolom FROM-tabel";
connection.query(sql, function(err, results, fields) {
  if (err) {
    console.log('Failed to connect.', err.message);
    process.exit(1);
  }
  console.log('The solution is: ', results[0].column;
});

De tweede parameter van de query-functie is een callback met drie argumenten:

• err slaat fouten op die optreden tijdens de uitvoering van de SQL-statement.
• results bevat de resultaten van de query.
• fields bevat gedetailleerde informatie over de betreffende gegevensvelden.

Voor gedetailleerde informatie over het opzetten van een MySQL-database en het formuleren van SQL-statements om databasebewerkingen uit te voeren, zie onze MySQL tutorial voor beginners.