Bootcamp backendontwikkeling met Node.js · Les

RESTful API-endpoints ontwerpen

Leer de kernprincipes van REST en ontwerp duidelijke, efficiënte API-endpoints voor verschillende resources.

Les 3 van 411 stappen

RESTful API-endpoints ontwerpen is een gratis Bootcamp backendontwikkeling met Node.js-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Bootcamp backendontwikkeling met Node.js. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Bootcamp backendontwikkeling met Node.js bevat in totaal 4 lessen.

Introductie tot RESTful API's

Welkom! In deze les duiken we in het ontwerpen van duidelijke en efficiënte API-eindpunten volgens REST-principes. Inzicht in REST is essentieel voor het bouwen van schaalbare webservices.

REST staat voor Representational State Transfer. Het is een architectuurstijl voor toepassingen in een netwerk, met de nadruk op staatloze communicatie tussen client en server.

Resources: de zelfstandige naamwoorden van REST

De kern van REST wordt gevormd door resources. Je kunt resources zien als alle informatie of gegevens die je API kan leveren of bewerken. Het zijn de 'dingen' die je API beheert.

Een resource wordt geïdentificeerd door een unieke URL (Uniform Resource Locator).
Resources worden doorgaans weergegeven als zelfstandige naamwoorden, zoals users, products of orders.
Gebruik bij voorkeur meervoudige zelfstandige naamwoorden voor verzamelingen van resources.

Acties met HTTP-methoden

Resources zijn zelfstandige naamwoorden, maar de acties die je erop uitvoert, worden aangegeven met standaard-HTTP-methoden (ook wel werkwoorden genoemd). Deze methoden komen rechtstreeks overeen met veelvoorkomende gegevensbewerkingen:

GET: Gegevens ophalen (lezen)
POST: Nieuwe gegevens maken (maken)
PUT: Bestaande gegevens vervangen (alles bijwerken)
PATCH: Bestaande gegevens gedeeltelijk bijwerken (gedeeltelijk bijwerken)
DELETE: Gegevens verwijderen (verwijderen)

De eindpunten van je API structureren

De URL van een goed ontworpen eindpunt moet intuïtief en voorspelbaar zijn. Deze volgt doorgaans een patroon:

/api/<version>/<resource_name>

Het gebruiken van een versie, zoals v1, is een goede gewoonte voor toekomstige wijzigingen aan de API. Gebruik altijd meervoudige zelfstandige naamwoorden voor resourcenamen.

Goed: /api/v1/users
Slecht: /api/v1/getUsers

URL's voor verzamelingen en items

REST-API's maken onderscheid tussen een verzameling resources en één resource binnen die verzameling:

URL van verzameling: Verwijst naar een groep resources. Bijvoorbeeld /users (alle gebruikers).
URL van item: Verwijst naar een specifieke resource. Bijvoorbeeld /users/123 (gebruiker met ID 123).

De ID (:id in Express) is een unieke identificatie voor die specifieke resource.

Communiceren met statuscodes

HTTP-statuscodes zijn cruciaal om de uitkomst van een aanvraag aan de client mee te delen. Ze vertellen de client of de aanvraag is geslaagd, of er een fout is opgetreden en waarom.

200 OK: Aanvraag geslaagd.
201 Aangemaakt: Resource succesvol aangemaakt.
204 Geen inhoud: Aanvraag geslaagd, maar er is geen inhoud om terug te sturen (bijvoorbeeld bij DELETE).
400 Ongeldige aanvraag: Client heeft ongeldige gegevens verzonden.
404 Niet gevonden: Resource niet gevonden.
500 Interne serverfout: Fout aan de serverzijde.

Ontwerp van een API-eindpunt voor gebruikers

Laten we eindpunten ontwerpen voor een User-resource. Let erop hoe HTTP-methoden en URL's samen acties beschrijven.

Probeer dit voorbeeld uit te voeren om de routes in actie te zien:

const express = require('express');
const app = express();
const port = 3000;

// Get all users
app.get('/api/v1/users', (req, res) => {
  res.status(200).send('GET /api/v1/users: Retrieve all users');
});

// Create a new user
app.post('/api/v1/users', (req, res) => {
  res.status(201).send('POST /api/v1/users: Create a new user');
});

// Get a specific user by ID
app.get('/api/v1/users/:id', (req, res) => {
  res.status(200).send(`GET /api/v1/users/${req.params.id}: Retrieve user ${req.params.id}`);
});

// Update a specific user by ID
app.put('/api/v1/users/:id', (req, res) => {
  res.status(200).send(`PUT /api/v1/users/${req.params.id}: Update user ${req.params.id}`);
});

// Delete a specific user by ID
app.delete('/api/v1/users/:id', (req, res) => {
  res.status(204).send(`DELETE /api/v1/users/${req.params.id}: Delete user ${req.params.id}`);
});

app.listen(port, () => {
  console.log(`User API running on http://localhost:${port}`);
});

Ontwerp van een API-eindpunt voor producten

Hier is nog een voorbeeld voor een Product-resource. De patronen blijven consistent, waardoor je API gemakkelijk te begrijpen en te gebruiken is voor ontwikkelaars.

Voer deze code uit om een productgerichte API te bekijken:

const express = require('express');
const app = express();
const port = 3001; // Using a different port

// Get all products
app.get('/api/v1/products', (req, res) => {
  res.status(200).send('GET /api/v1/products: Retrieve all products');
});

// Create a new product
app.post('/api/v1/products', (req, res) => {
  res.status(201).send('POST /api/v1/products: Create a new product');
});

// Get a specific product by ID
app.get('/api/v1/products/:id', (req, res) => {
  res.status(200).send(`GET /api/v1/products/${req.params.id}: Retrieve product ${req.params.id}`);
});

// Delete a specific product by ID
app.delete('/api/v1/products/:id', (req, res) => {
  res.status(204).send(`DELETE /api/v1/products/${req.params.id}: Delete product ${req.params.id}`);
});

app.listen(port, () => {
  console.log(`Product API running on http://localhost:${port}`);
});

Aanbevolen werkwijzen voor duidelijke URL's

Volg deze aanbevolen werkwijzen om je API gebruiksvriendelijk en onderhoudbaar te maken:

Gebruik meervoudige zelfstandige naamwoorden: Voor verzamelingen, bijvoorbeeld /products en niet /product.
Vermijd werkwoorden in URL's: Laat HTTP-methoden de acties definiëren, bijvoorbeeld POST /users en niet /createUser.
Gebruik koppeltekens: Voor de leesbaarheid van resourcenamen met meerdere woorden, bijvoorbeeld /order-items.
Houd URL's eenvoudig: Vermijd diepe nesten; queryparameters kunnen filteren en sorteren afhandelen.

Test je kennis van REST

Welke van de volgende ontwerpen van eindpunten volgt de RESTful-principes correct voor het maken van een nieuw product en het ophalen van een specifiek product?

Beantwoord dit in de interactieve les

Samenvatting: RESTful-eindpunten ontwerpen

Goed gedaan! Je hebt de basisprincipes geleerd van het ontwerpen van RESTful API-eindpunten. Onthoud deze belangrijkste punten:

Resources zijn de zelfstandige naamwoorden en worden geïdentificeerd door URL's.
HTTP-methoden (GET, POST, PUT, DELETE) definiëren acties.
Gebruik meervoudige zelfstandige naamwoorden voor verzamelingen en specifieke ID's voor items.
Communiceer uitkomsten met geschikte HTTP-statuscodes.
Streef naar duidelijke, voorspelbare URL's voor een gebruiksvriendelijke API.

Deze basis helpt je robuuste en intuïtieve API's te bouwen!

Gratis beginnen

Leer JavaScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 22
Lessen: 92

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “RESTful API-endpoints ontwerpen” gratis?

Ja — de volledige tekst van “RESTful API-endpoints ontwerpen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Bootcamp backendontwikkeling met Node.js wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Bootcamp backendontwikkeling met Node.js bevat in totaal 4 lessen.

Wat leer ik in “RESTful API-endpoints ontwerpen”?

Leer de kernprincipes van REST en ontwerp duidelijke, efficiënte API-endpoints voor verschillende resources. Je oefent met Bootcamp backendontwikkeling met Node.js door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Bootcamp backendontwikkeling met Node.js te beginnen?

Ervaring vooraf is niet nodig. Bootcamp backendontwikkeling met Node.js op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “RESTful API-endpoints ontwerpen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Bootcamp backendontwikkeling met Node.js?

Ja. Elke les over Bootcamp backendontwikkeling met Node.js bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

De basis van het Express.js-framework
Routing en middleware in Express
RESTful API-endpoints ontwerpen
Requestgegevens verwerken: body, query en params

← Terug naar Bootcamp backendontwikkeling met Node.js