Übung – Schreiben von Daten

5 Minuten

Tailwind Traders ist beeindruckt von Ihren APIs, die vorhandene Produkte zurückgeben. Jetzt müssen Sie eine API erstellen, die Produkte einfügen und aktualisieren kann. Die Daten werden in der Regel in einer Datenbank gespeichert und enthalten Millionen von Datensätzen. Aus diesem Grund müssen Sie Techniken verwenden, die einschränken, wie viele Daten an die API übergeben und von der API zurückgegeben werden.

Implementieren der Unterstützung zum Schreiben von Daten

Implementieren Sie die CRUD-API für die Ressource products:

Dieses Starterprojekt unter nodejs-route\exercise-express-routing\reading-writing beinhaltet die Produktdateien und etwas Starteranwendungscode. Sie müssen lediglich die fehlenden Bestandteile ergänzen.

Klicken Sie mit der rechten Maustaste auf den Ordnernamen reading-writing, und wählen Sie Im integriertem Terminal öffnen aus.
Führen Sie den folgenden Befehl im Terminal aus, um sie zu installieren:
```
npm install
```

Öffnen Sie die Datei app.js, um sie zu untersuchen. Die Datei sollte wie folgt aussehen:

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

Die Datei app.js enthält die Grundlage eines Programms. Ihre nächste Aufgabe besteht darin, die Routen zu implementieren.

Implementieren der Route zum Lesen von Daten

Um Routen zu implementieren, muss man ein wenig Code hinzufügen und ihn dann testen. Fahren Sie mit dem Hinzufügen der Methode jeder Route fort, bis Sie über eine voll funktionsfähige API verfügen. Nehmen Sie Änderungen an der Datei app.js im Lese-/Schreibverzeichnis vor. Alle Dateien, die beginnen, client sind Clientanwendungen, die Sie verwenden können, um Ihre API zu testen.

Um das Lesen aus der API zu unterstützen, suchen Sie den Teil des Codes, der wie folgt aussieht:
```
app.get('/products', (req, res) => {
  // implement
})
```
Ersetzen Sie diesen durch den folgenden Code:
```
app.get('/products', (req, res) => {
  res.json(products);
})
```
Um zu überprüfen, ob der Code funktioniert, starten Sie die Node-Anwendung, indem Sie den folgenden Befehl ausführen:
```
node app.js
```
Führen Sie in einem separaten Terminal für denselben Ordner reading-writing den folgenden Befehl aus: Es ist wichtig, dass zwei Terminal geöffnet sind, da Sie den Server und den Client gleichzeitig ausführen müssen.
```
node client-get.js
```
Die Ausgabe sollte wie folgt aussehen:
```
Received data []
Connection closed
```
Die API gibt ein leeres Array zurück, da Sie bisher noch keine Daten eingegeben haben. Das sollten wir als nächstes ändern.
Drücken Sie im ersten Terminal STRG+C, um die Anwendung zu beenden.

Implementieren der Route zum Schreiben von Daten

Um das Schreiben von Daten in die Speicherdatenbank zu implementieren, suchen Sie diesen Code:
```
app.post('/products', function (req, res) {
   // implement
});
```
Ersetzen Sie diesen durch den folgenden Code:
```
app.post('/products', function(req, res) {
  const newProduct = { ...req.body, id: products.length + 1 }
  products = [ ...products, newProduct]
  res.json(newProduct);
});
```
Der neue Code liest eingehende Daten von req.body und erstellt daraus ein JavaScript-Objekt. Als Nächstes wird es dem products Speicherdatenbankarray hinzugefügt. Schließlich wird das neue Produkt an den Benutzer zurückgegeben.
Führen Sie das Serverprogramm durch Ausführen des folgenden Befehls aus, um den Code zu testen:
```
node app.js
```
Führen Sie in einem separaten Terminal für denselben Ordner reading-writing den folgenden Befehl aus: Es ist wichtig, dass zwei Terminal geöffnet sind, da Sie den Server und den Client gleichzeitig ausführen müssen.
```
node client-post.js
```
Die angezeigte Ausgabe sollte in etwa so aussehen:
```
response {"name":"product","id":1}
Closed connection
```
Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Daten in die API geschrieben wurden:
```
node client-get.js
```
Die folgende Ausgabe wird angezeigt.
```
Received data [{"name":"product","id":1}]
Connection closed
```
Ihre bisherigen Anforderungen:
- client-post.js: Die Antwort teilt Ihnen mit, dass Daten in die API geschrieben wurden, als Sie client-post.js ausgeführt haben.
- client-get.js: Sie haben client-get.js ausgeführt, um die API nach Daten abzufragen. Die API hat mit den Daten geantwortet, die Sie in die API geschrieben haben.
Drücken Sie im ersten Terminal STRG+C, um die Anwendung zu beenden.

Implementieren der Route zum Aktualisieren von Daten

Suchen Sie den wie folgt aussehenden Code, um die Fähigkeit zum Ändern Ihrer Daten zu implementieren:

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

Ersetzen Sie diesen durch den folgenden 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);
});

Der neue Code sucht den Datensatz im Array der products-Datenbank im Speicher, der mit der Eigenschaft id übereinstimmt, und aktualisiert diesen Datensatz.

Starten Sie die Serveranwendung, um den Code zu testen:
```
node app.js
```
Führen Sie den folgenden Befehl im anderen Terminal aus, um einen Datensatz zu erstellen:
```
node client-post.js
```
Führen Sie den folgenden Befehl aus, um den neu erstellten Datensatz zu aktualisieren:
```
node client-put.js
```
Die folgende Aktualisierung sollte im Terminal angezeigt werden:
```
response {"name":"product-updated","id":1}
Closed connection
```
Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Aktualisierung funktioniert:
```
node client-get.js
```
Die folgende Aktualisierung sollte angezeigt werden:
```
Received data [{"name":"product-updated","id":1}]
Connection closed
```
Drücken Sie im ersten Terminal STRG+C, um die Anwendung zu beenden.

Implementieren der Route zum Löschen von Daten

Um den Löschvorgang zu implementieren, suchen Sie den Code, der wie folgt aussieht:
```
app.delete('/products/:id', function (req, res) {
  // implement
});
```
Ersetzen Sie diesen durch den folgenden 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);
});
```
Dieser neue Code sucht nach dem Produktelement, das gelöscht werden soll. Anschließend wird das Element aus dem products Speicherdatenbankarray herausgefiltert und das gelöschte Produkt zurückgegeben.
Starten Sie die Serveranwendung, um den Code zu testen:
```
node app.js
```
Führen Sie in einem separaten Terminal den folgenden Befehl aus, um einen Datensatz zu erstellen:
```
node client-post.js
```
Führen Sie diesen Befehl aus, um den Datensatz zu entfernen:
```
node client-delete.js
```
Die folgende Ausgabe sollte angezeigt werden:
```
response {"name":"product","id":1}
Closed connection
```
Führen Sie diesen Befehl aus, um den Code zu überprüfen:
```
node client-get.js
```
Dieser sollte die folgende Ausgabe zurückgeben:
```
Received data []
Connection closed
```
Herzlichen Glückwunsch! Sie haben eine products Ressource mithilfe einer vollständigen CRUD implementiert (Erstellen, Lesen, Aktualisieren, Löschen).
Drücken Sie im ersten Terminal STRG+C, um die Anwendung zu beenden.

Bereinigung des Entwicklungscontainers

Nach Abschluss des Projekts können Sie Ihre Entwicklungsumgebung bereinigen oder wieder in den normalen Zustand versetzen.

Remoteentwicklung (Browser)
Lokale Entwicklung (Docker)

Durch Löschen der GitHub Codespaces-Umgebung wird sichergestellt, dass Sie die Menge an kostenlosen Kernstunden maximieren können, die Sie für Ihr Konto erhalten.

Wichtig

Weitere Informationen zu den Berechtigungen Ihres GitHub-Kontos finden Sie im Artikel zu monatlich enthaltener Speicherkapazität und Kernstunden in GitHub Codespaces.

Melden Sie sich beim GitHub Codespaces-Dashboard (https://github.com/codespaces) an.
Suchen Sie Ihre derzeit ausgeführten Codespaces, die aus dem GitHub-Repository MicrosoftDocs/node-essentials stammen.
Öffnen Sie das Kontextmenü für den Codespace, und wählen Sie Löschen aus.