Oefening: gegevens schrijven

5 minuten

Tailwind Traders is onder de indruk van uw API's, die bestaande producten retourneren. U moet nu een API maken waarmee u producten kunt invoegen en bijwerken. De gegevens worden doorgaans opgeslagen in een database en bevatten miljoenen records. Daarom moet u technieken gebruiken die beperken hoeveel gegevens worden doorgegeven aan de API en worden geretourneerd vanuit de API.

Ondersteuning implementeren voor het schrijven van gegevens

Implementeer de CRUD-API op de products resource:

Dit startersproject op nodejs-route\exercise-express-routing\reading-writingbevat de productbestanden en een aantal starterstoepassingscode. U hoeft alleen de ontbrekende onderdelen in te vullen.

Klik met de rechtermuisknop op de naam van de map lezen en selecteer Openen in geïntegreerde terminal.
Voer in de terminal de volgende opdracht uit om deze te installeren:
```
npm install
```

Open app.js om deze te inspecteren. Het bestand moet er als volgt uitzien:

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

 app.use(express.json());

 let products = [];

 app.post('/products', function (req, res) {
   // implement
 });

 app.put('/products', function (req, res) {
   // implement
 });

 app.delete('/products/:id', function (req, res) {
   // implement
 });

 app.get('/products', (req, res) => {
   // implement
 });

 app.listen(port, () =>
   console.log(`Example app listening at http://localhost:${port}`),
 );

Het bestand app.js toont het skelet van een programma. Uw volgende taak bestaat uit het implementeren van de routes.

Route implementeren om gegevens te lezen

Als u routes wilt implementeren, moet u een beetje code toevoegen en deze vervolgens testen. Ga door met het toevoegen van de methode van elke route totdat u een volledig functionele API hebt. Breng uw wijzigingen aan in het app.js-bestand in de map voor lezen/schrijven . Alle bestanden die beginnen met client zijn clienttoepassingen die u kunt gebruiken om uw API te testen.

Als u het lezen vanuit de API wilt ondersteunen, zoekt u het deel van de code dat er als volgt uitziet:
```
app.get('/products', (req, res) => {
  // implement
})
```
Vervang deze door deze code:
```
app.get('/products', (req, res) => {
  res.json(products);
})
```
Als u wilt controleren of de code werkt, start u de Node-toepassing door deze opdracht uit te voeren:
```
node app.js
```
Voer in een afzonderlijke terminal voor dezelfde map de volgende opdracht uit. Het is belangrijk dat u twee terminal open hebt, omdat u de server en de client tegelijkertijd moet uitvoeren.
```
node client-get.js
```
De volgende uitvoer moet worden weergegeven:
```
Received data []
Connection closed
```
De API reageert met een lege matrix omdat u nog geen gegevens naar de API hebt geschreven. Laten we dat nu veranderen.
Selecteer Ctrl+C in de eerste terminal om de toepassing te stoppen.

Route implementeren om gegevens te schrijven

Als u schrijfgegevens naar een in-memory database wilt implementeren, zoekt u deze code:
```
app.post('/products', function (req, res) {
   // implement
});
```
Vervang deze door deze code:
```
app.post('/products', function(req, res) {
  const newProduct = { ...req.body, id: products.length + 1 }
  products = [ ...products, newProduct]
  res.json(newProduct);
});
```
Met de nieuwe code worden binnenkomende gegevens req.body gelezen en wordt er een JavaScript-object van gemaakt. Vervolgens wordt deze toegevoegd aan de databasematrix in het products geheugen. Ten slotte wordt het nieuwe product geretourneerd aan de gebruiker.
Als u de code wilt testen, voert u het serverprogramma uit door deze opdracht uit te voeren:
```
node app.js
```
Voer in een afzonderlijke terminal voor dezelfde map de volgende opdracht uit. Het is belangrijk dat u twee terminal open hebt, omdat u de server en de client tegelijkertijd moet uitvoeren.
```
node client-post.js
```
De uitvoer ziet er als volgt uit:
```
response {"name":"product","id":1}
Closed connection
```
Voer de volgende opdracht uit om te controleren of de gegevens naar de API zijn geschreven:
```
node client-get.js
```
U moet de volgende uitvoer zien:
```
Received data [{"name":"product","id":1}]
Connection closed
```
Uw aanvragen tot nu toe:
- client-post.js: Het antwoord geeft aan dat u tijdens het uitvoeren van client-post.js gegevens naar de API hebt geschreven.
- client-get.js: u hebt client-get.js uitgevoerd om een query uit te voeren op de API voor gegevens. De API antwoordde met de gegevens die u er zojuist naartoe hebt geschreven.
Selecteer Ctrl+C in de eerste terminal om de toepassing te stoppen.

Route implementeren om gegevens bij te werken

Om de mogelijkheid om uw gegevens bij te werken te implementeren, zoekt u de code die er als volgt uitziet:

app.put('/products', function (req, res) {
  // implement
});

Vervang deze door deze code:

app.put('/products', function(req, res) {
  let updatedProduct;
  products = products.map(p => {
    if (p.id === req.body.id) {
      updatedProduct = { ...p, ...req.body };
      return updatedProduct;
    }
    return p;
  })
  res.json(updatedProduct);
});

De nieuwe code zoekt de record in de databasematrix in het products geheugen die overeenkomt met de id eigenschap en werkt die record bij.

Om de code te testen, start u de servertoepassing:
```
node app.js
```
Voer in de andere terminal deze opdracht uit om een record te maken:
```
node client-post.js
```
Voer deze opdracht uit om de zojuist gemaakte record bij te werken:
```
node client-put.js
```
De volgende update wordt in de terminal weergegeven:
```
response {"name":"product-updated","id":1}
Closed connection
```
Voer deze opdracht uit om te controleren of de update werkt:
```
node client-get.js
```
De update moet er ongeveer als volgt uitzien:
```
Received data [{"name":"product-updated","id":1}]
Connection closed
```
Selecteer Ctrl+C in de eerste terminal om de toepassing te stoppen.

Route implementeren om gegevens te verwijderen

Als u verwijderen wilt implementeren, zoekt u de code die er als volgt uitziet:
```
app.delete('/products/:id', function (req, res) {
  // implement
});
```
Vervang deze door deze code:
```
app.delete('/products/:id', function(req, res) {
  const deletedProduct = products.find(p => p.id === +req.params.id);
  products = products.filter(p => p.id !== +req.params.id);
  res.json(deletedProduct);
});
```
Met de nieuwe code wordt het product gevonden dat moet worden verwijderd. Vervolgens wordt dat item uit de databasematrix in het products geheugen gefilterd en wordt het verwijderde product geretourneerd.
Om de code te testen, start u de servertoepassing:
```
node app.js
```
Voer deze opdracht uit in een aparte terminal om een record te maken:
```
node client-post.js
```
Voer deze opdracht uit om de record te verwijderen:
```
node client-delete.js
```
U moet de volgende uitvoer zien:
```
response {"name":"product","id":1}
Closed connection
```
Voer deze opdracht uit om de code te controleren:
```
node client-get.js
```
Als het goed is, krijgt u deze uitvoer:
```
Received data []
Connection closed
```
Gefeliciteerd U hebt een products resource geïmplementeerd met behulp van een volledige CRUD (acties maken, lezen, bijwerken, verwijderen).
Selecteer Ctrl+C in de eerste terminal om de toepassing te stoppen.

Ontwikkelcontainer opschonen

Nadat u het project hebt voltooid, kunt u uw ontwikkelomgeving opschonen of teruggaan naar de typische status.

Externe ontwikkeling (browser)
Lokale ontwikkeling (Docker)

Als u de GitHub Codespaces-omgeving verwijdert, zorgt u ervoor dat u de hoeveelheid gratis kernuren kunt maximaliseren die u voor uw account krijgt.

Belangrijk

Zie GitHub Codespaces maandelijks inbegrepen opslag- en kernuren voor meer informatie over de rechten van uw GitHub-account.

Meld u aan bij het GitHub Codespaces-dashboard (https://github.com/codespaces).
Zoek uw momenteel uitgevoerde Codespaces die afkomstig zijn uit de MicrosoftDocs/node-essentials GitHub-opslagplaats.
Open het contextmenu voor de coderuimte en selecteer Verwijderen.

Doorgaan