Övning – Skriva data

5 minuter

Tailwind Traders är imponerade av dina API:er som returnerar befintliga produkter. Nu måste du skapa ett API som kan infoga och uppdatera produkter. Data lagras vanligtvis i en databas och innehåller miljontals poster. Därför måste du använda tekniker som begränsar hur mycket data som skickas till API:et och returneras från API:et.

Implementera stöd för att skriva data

Implementera CRUD-API:et på resursen products :

Det här startprojektet på nodejs-route\exercise-express-routing\reading-writinginnehåller produktfilerna och viss startprogramkod. Allt du behöver göra är att fylla i de saknade delarna.

Högerklicka på mappnamnet för lässkrivning och välj Öppna i integrerad terminal.
I terminalen kör du följande kommando för att installera det:
```
npm install
```

Öppna app.js för att kontrollera den. Filen bör se ut så här:

 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}`),
 );

Filen app.js visar ett programs skelett. Din nästa uppgift är att implementera vägarna.

Implementera väg för att läsa data

För att implementera vägar är processen att lägga till lite kod och sedan testa den. Fortsätt att lägga till varje vägs metod tills du har ett fullt fungerande API. Gör dina ändringar i app.js-filen i katalogen lässkrivning. Alla filer som börjar med client är klientprogram som du kan använda för att testa ditt API.

Om du vill ha stöd för läsning från API:et letar du upp den del av koden som ser ut så här:
```
app.get('/products', (req, res) => {
  // implement
})
```
Ersätt den med den här koden:
```
app.get('/products', (req, res) => {
  res.json(products);
})
```
Om du vill kontrollera att koden fungerar startar du Node-programmet genom att köra det här kommandot:
```
node app.js
```
Kör följande kommando i en separat terminal för samma mapp , lässkrivning. Det är viktigt att ha två terminaler öppna eftersom du måste köra servern och klienten samtidigt.
```
node client-get.js
```
Du bör se följande utdata:
```
Received data []
Connection closed
```
API:et svarar med en tom matris eftersom du inte har skrivit några data till den ännu. Låt oss ändra på det härnäst.
I den första terminalen väljer du Ctrl+C för att stoppa programmet.

Implementera vägen för att skriva data

Om du vill implementera skrivdata till minnesintern databas letar du upp den här koden:
```
app.post('/products', function (req, res) {
   // implement
});
```
Ersätt den med den här koden:
```
app.post('/products', function(req, res) {
  const newProduct = { ...req.body, id: products.length + 1 }
  products = [ ...products, newProduct]
  res.json(newProduct);
});
```
Den nya koden läser inkommande data från req.body och konstruerar ett JavaScript-objekt från den. Därefter läggs den till i den minnesinterna databasmatrisen products . Slutligen returneras den nya produkten till användaren.
Testa koden genom att köra serverprogrammet genom att köra det här kommandot:
```
node app.js
```
Kör följande kommando i en separat terminal för samma mapp , lässkrivning. Det är viktigt att ha två terminaler öppna eftersom du måste köra servern och klienten samtidigt.
```
node client-post.js
```
Utdata bör ser ut så här:
```
response {"name":"product","id":1}
Closed connection
```
Kör följande kommando för att kontrollera att data skrivs till API:et:
```
node client-get.js
```
Du bör se följande utdata:
```
Received data [{"name":"product","id":1}]
Connection closed
```
Dina begäranden hittills:
- client-post.js: Svaret anger att när du körde client-post.js skrev du data till API:et.
- client-get.js: Du körde client-get.js för att fråga API:et om data. API:et svarade med de data som du precis skrev till det.
I den första terminalen väljer du Ctrl+C för att stoppa programmet.

Implementera väg för att uppdatera data

När du ska implementera möjligheten att uppdatera data, letar du reda på koden som ser ut så här:

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

Ersätt den med den här koden:

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);
});

Den nya koden letar upp posten i den products minnesinterna databasmatrisen id som matchar egenskapen och uppdaterar posten.

Om du vill testa koden startar du serverprogrammet:
```
node app.js
```
I den andra terminalen kör du det här kommandot för att skapa en post:
```
node client-post.js
```
Kör kommandot för att uppdatera den nyss skapade posten:
```
node client-put.js
```
Du bör se följande uppdatering i terminalen:
```
response {"name":"product-updated","id":1}
Closed connection
```
Kontrollera att uppdateringen fungerar genom att köra det här kommandot:
```
node client-get.js
```
Du bör se den här uppdateringen:
```
Received data [{"name":"product-updated","id":1}]
Connection closed
```
I den första terminalen väljer du Ctrl+C för att stoppa programmet.

Implementera väg för att ta bort data

Om du vill implementera borttagning letar du reda på koden som ser ut så här:

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

Ersätt den med den här koden:

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);
});

Den nya koden hittar produkten som ska tas bort. Sedan filtreras objektet bort från den minnesinterna databasmatrisen products och returnerar den borttagna produkten.

Om du vill testa koden startar du serverprogrammet:
```
node app.js
```
I en separat terminal kör du det här kommandot för att skapa en post:
```
node client-post.js
```

Kör kommandot för att ta bort posten:

node client-delete.js

Du bör se följande utdata:

response {"name":"product","id":1}
Closed connection

Kör följande kommando för att kontrollera koden:
```
node client-get.js
```
Då bör följande utdata visas:
```
Received data []
Connection closed
```
Grattis! Du har implementerat en products resurs med hjälp av en fullständig CRUD (skapa, läsa, uppdatera, ta bort åtgärder).
I den första terminalen väljer du Ctrl+C för att stoppa programmet.

Rensningsutvecklingscontainer

När du har slutfört projektet kanske du vill rensa utvecklingsmiljön eller återställa den till dess typiska tillstånd.

Fjärrutveckling (webbläsare)
Lokal utveckling (Docker)

Om du tar bort GitHub Codespaces-miljön kan du maximera mängden kostnadsfria kärntimmar som du får för ditt konto.

Viktigt!

Mer information om ditt GitHub-kontos rättigheter finns i GitHub Codespaces månadsvis inkluderade lagrings- och kärntimmar.

Logga in på GitHub Codespaces-instrumentpanelen (https://github.com/codespaces).
Leta upp de codespaces som körs från MicrosoftDocs/node-essentials GitHub-lagringsplatsen.
Öppna snabbmenyn för kodområdet och välj Ta bort.

Fortsätt