Express war einst das beliebteste Framework für die Entwicklung von Webanwendungen mit node.js. Der Rahmen hat jedoch in den letzten Jahren die aktive Entwicklung verringert, was zu einer mangelnden Unterstützung für moderne JavaScript -Merkmale führte. Gleichzeitig entstehen viele neue Frameworks, die unterschiedliche Ansätze zur Entwicklung von Node.js anwenden, und Fastify ist einer davon.
In diesem Artikel wird untersucht, warum Fastify zu einer überzeugenden Alternative zur Entwicklung von Node.js -Webanwendungen geworden ist. Wir werden lernen, wie Sie vorhandenen Expressanwendungen von Grund auf neu einschreiben und stattdessen Schritt für Schritt zu Fastify wechseln. Nach dem Studium dieses Artikels können Sie Ihre vorhandenen Express -Anwendungen sicher migrieren und das Fastify -Framework ausnutzen.
Die folgenden Bedingungen müssen beim Lesen dieses Artikels erfüllt sein:
Alle Beispielcode in diesem Artikel finden Sie in GitHub und Sie können damit durchsuchen, herunterladen und experimentieren.
Die Videoversion dieses Artikels ist auch auf meiner Website verfügbar.
fastify-express Plug-In erleichtert die allmähliche Migration von Express zu Fasty, indem die Verwendung von Express Middleware und Routing im Fastify-Framework ermöglicht wird. Wenn Sie mithilfe von Express mit den Anwendungen von Node.js vertraut sind, fragen Sie sich möglicherweise, wie die Vorteile der Migration Ihrer vorhandenen Express -Anwendungen zu Fastying -Anwendungen sind. Hier sind einige wichtige Gründe, um die Migration zu berücksichtigen:
Überprüfung und Anmeldung aus der Box. Diese Funktionen sind normalerweise beim Erstellen von Webanwendungen erforderlich. Bei der Verwendung von Fastify müssen Bibliotheken für diese Aufgaben nicht ausgewählt und integriert werden, da es uns diese Funktionen bietet. Wir werden später in diesem Artikel mehr über diese Funktionen erfahren.
native Unterstützung für asynchrone Code. Fastify nativ verspricht das Versprechen und unterstützt Asynchronisation/wartet. Dies bedeutet, dass die Route für uns ungewöhnliche abgelehnte Versprechen erfasst. Dies ermöglicht es uns, asynchronen Code sicher zu schreiben. Es ermöglicht uns auch, einige präzise Dinge zu erledigen, z.
<code> app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>
<code> app.get("/user/:id", async (request, reply) => {
const name = request.body.name;
reply.send({ user: { name } });
});
</code>
Integrationstests testet die Komponenten der Anwendung auf unterschiedliche Weise als Unit -Tests. Unit testet die Funktionalität der einzelnen Komponenten. Integrationstests ermöglicht es uns, das Verhalten mehrerer Komponenten zu überprüfen, die zusammenarbeiten.
Wenn wir API -Integrationstests für Express -Anwendungen schreiben, möchten wir nach der Migration der Anwendung auf Fasty -Migration denselben Test ausführen können. Beim Schreiben von Integrationstests für APIs müssen die folgenden Punkte berücksichtigt werden:
migrieren Sie mit Fastify-Express von Express zu Fasten
Das Fastify-Express-Plugin fügt Fastify voll ausdrückliche Kompatibilität hinzu. Es bietet eine Verwendung () -Methode (), mit der wir unserem Fastify -Server Express Middleware und Routen hinzufügen können. Dies bietet uns die Möglichkeit, Teile unserer vorhandenen Express -Anwendung nach und nach zu migrieren, um sie zu fasten.
Dies ist ein Beispiel für einen Expressrouter:
<code> app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>Wir können dann Fastify-Express verwenden, um unseren vorhandenen Express-Router zur Fastify-Serverinstanz hinzuzufügen:
<code> app.get("/user/:id", async (request, reply) => {
const name = request.body.name;
reply.send({ user: { name } });
});
</code>Nach einem Moment werden wir die Details all dieser Arbeiten untersuchen, während wir die Anwendung auf Fasten migrieren.
Es ist wichtig zu beachten, dass die Verwendung des Fastify-Express-Plugins keine langfristige Lösung ist. Wenn wir die vollen Vorteile von Fastify erhalten möchten, müssen wir schließlich unseren expressspezifischen Anwendungscode migrieren. Das Fastify-Express-Plugin bietet uns jedoch die Möglichkeit, in Phasen zu migrieren.
Wir erstellen eine Beispiel -Express -Anwendung und migrieren sie dann in die Verwendung des Fastify -Frameworks. Schauen wir uns nun seinen Code an.
Erstellen wir zuerst ein neues Projekt:
<code>// src/routes.js
const router = express.Router();
router.get("/:user_id", function getUser(request, response, next) {
response.json({});
});
export default router;
</code>Wir werden diesen Befehl dann im Terminal ausführen, um die Abhängigkeiten zu installieren, die von unserer Express -Anwendung erforderlich sind:
<code>// src/server.js
import Fastify from "fastify";
import ExpressPlugin from "fastify-express";
import routes from "./routes.js";
const fastify = Fastify();
await fastify.register(ExpressPlugin);
fastify.use("/user", routes);
await fastify.listen(3000);
</code>Öffnen Sie schließlich Paket.json und fügen Sie die folgende Zeile über dem Abschnitt "Skripte" hinzu:
<code>mkdir express-to-fastify-migration cd express-to-fastify-migration npm init -y </code>
Dies ermöglicht es uns, das ES -Modul in unserer Anwendung zu laden.
Wir werden eine Express -Router -Instanz erstellen, mit der wir unsere Routing und Middleware zusammenfassen können. Router in Express können verwendet werden, um uns dabei zu helfen, Anwendungen in diskrete Module zu organisieren. Zum Beispiel haben wir möglicherweise einen Router für /Benutzerrouting und ein anderes für /Adressrouting. Wir werden später sehen, wie dies uns hilft, Express -Anwendungen zum Fasten zu streichen.
Erstellen wir eine Routerinstanz und fügen Sie etwas Middleware hinzu:
<code>npm install express cors </code>
Im obigen Code haben wir zwei Express Middleware -Beispiele konfiguriert:
Diese Middleware -Tools werden gegen alle Anfragen ausgeführt, die von allen Routen gestellt werden, die wir auf diesem Router definieren.
Jetzt, wo wir die Middleware konfiguriert haben, können wir unseren Router den ersten Weg hinzufügen:
<code>"type": "module", </code>
In einer realen Anwendung wird die obige Funktion Routing -Handler die empfangenen Daten überprüfen und dann die Datenbank aufrufen, um einen neuen Benutzerdatensatz zu erstellen. In diesem Beispiel senden wir Daten, die als Antwortkörper empfangen werden.
Jetzt werden wir eine Route hinzufügen, um Benutzer abzurufen:
<code> app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>Wie nach Post -Routing ruft der obige Routing -Handler normalerweise die Datenbank auf, um Benutzerdaten abzurufen. In diesem Beispiel haben wir jedoch ein Objekt für das Senden des Antwortkörpers hartcodiert.
Schließlich werden wir das Router -Objekt so exportieren, damit wir es in ein anderes Modul importieren können:
<code> app.get("/user/:id", async (request, reply) => {
const name = request.body.name;
reply.send({ user: { name } });
});
</code>Jetzt erstellen wir ein App -Modul:
<code>// src/routes.js
const router = express.Router();
router.get("/:user_id", function getUser(request, response, next) {
response.json({});
});
export default router;
</code>In diesem Modul definieren wir eine Funktion, die eine neue Express -Serverinstanz erstellt. Wir fügen dann das Router -Objekt zur Serverinstanz hinzu.
Schließlich erstellen wir ein Servermodul. Dieses Modul verwendet die im App -Modul definierte BuildApp () -Funktion, um eine neue Express -Serverinstanz zu erstellen. Anschließend startet unser Express -Server, indem Sie ihn so konfigurieren, dass Port 3000:
anhören:<code>// src/server.js
import Fastify from "fastify";
import ExpressPlugin from "fastify-express";
import routes from "./routes.js";
const fastify = Fastify();
await fastify.register(ExpressPlugin);
fastify.use("/user", routes);
await fastify.listen(3000);
</code>aus
Wir haben jetzt eine vollständige Runnable Express -Anwendung, die wir im Terminal ausführen können:<code>mkdir express-to-fastify-migration cd express-to-fastify-migration npm init -y </code>
In einem anderen Terminal können wir Curl verwenden, um eine Anfrage an die API zu stellen, um zu bestätigen, ob es funktioniert:
<code>npm install express cors </code>
wir sollten eine Antwort wie folgt erhalten:
<code>"type": "module", </code>
Jetzt haben wir eine vollwertige Express-Anwendung, die wir mit der Verwendung des Fastify-Frameworks migrieren werden.
Wir müssen drei Abhängigkeiten installieren:
Lassen Sie uns diesen Befehl im Terminal ausführen, um sie zu installieren:
<code>// src/routes.js
import express from "express";
import cors from "cors";
const router = express.Router();
router.use(express.json());
router.use(cors({ origin: true }));
</code>Sie können die Unterschiede in diesen Codeänderungen auf GitHub anzeigen.
Jetzt, da wir die Abhängigkeiten installiert haben, müssen wir unser App -Modul neu refactor. Wir werden es ändern in:
<code>// src/routes.js
router.post("/", function createUser(request, response, next) {
const newUser = request.body;
if (!newUser) {
return next(new Error("Error creating user"));
}
response.status(201).json(newUser);
});
</code>
Sie können die Unterschiede in diesen Codeänderungen auf GitHub anzeigen.
Refactor unser Servermodul
<code>// src/routes.js
router.get("/:user_id", function getUser(request, response, next) {
const user = {
id: request.params.user_id,
first_name: "Bobinsky",
last_name: "Oso",
};
response.json(user);
});
</code>
Sie können die Unterschiede in diesen Codeänderungen auf GitHub anzeigen.
Da Fastify nativ das Versprechen unterstützt, können wir im obigen Code auf Warten verwenden und dann die integrierte Protokollierungsfunktion von Fastify verwenden, um Fehler zu erfassen und zu protokollieren.Unsere Bewerbung verwendet nun Fastify, um Anfragen zu streichen und Antworten zu senden. Es ist voll ausgestattet, aber unser Routing verwendet immer noch Express. Um voll auszudrücken, müssen wir unsere Routen auch auf Fastify migrieren.
Routing in Expressanwendungen ist in Expressroutern eingekapselt. Wir haben diesen Router mit einem Fastify -Plugin übertragen. Plug-In ist eine Funktion von Fastify, mit der wir das Routing und alle zugehörigen Funktionen zusammenfassen können.
Wir werden zunächst einige expressspezifische Zeilen entfernen, um unser Routing-Modul (src/routes.js) neu zu gestalten:
<code> app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>Dann müssen wir den Standardmodulexport in eine asynchrone Funktion ändern, die die Fastify -Serverinstanz akzeptiert. Dies ist die Grundlage des Fastify -Plugins. Der Rest des Codes in unserem Routing -Modul wird in diese Plugin -Funktion verschoben:
<code> app.get("/user/:id", async (request, reply) => {
const name = request.body.name;
reply.send({ user: { name } });
});
</code>Damit unsere Middleware und Routing mit Fastify arbeiten müssen, müssen wir uns ändern:
Nach all diesen Änderungen ist unser Routing -Modul jetzt ein Fastify -Plugin mit Fastify -Routing:
<code>// src/routes.js
const router = express.Router();
router.get("/:user_id", function getUser(request, response, next) {
response.json({});
});
export default router;
</code>Jetzt müssen wir unser App -Modul (SRC/app.js) so ändern, dass das von uns exportierte Plugin aus dem Routing -Modul verwendet wird. Dies bedeutet, den Fastify.use () -Anruf mit einem Anruf zu ersetzen.register ():
<code>// src/server.js
import Fastify from "fastify";
import ExpressPlugin from "fastify-express";
import routes from "./routes.js";
const fastify = Fastify();
await fastify.register(ExpressPlugin);
fastify.use("/user", routes);
await fastify.listen(3000);
</code>Sie können die Unterschiede in diesen Codeänderungen auf GitHub anzeigen.
Unser Beispiel für Express -Anwendung hat nur einen Router, sodass wir alle Routen in der Anwendung so migrieren können, dass sie Fastify gleichzeitig verwenden. Wenn wir jedoch eine größere Expressanwendung mit mehreren Routern hätten, könnten wir jeden Router migrieren, um Schritt für Schritt Schritt für Schritt zu schnappen.
Unsere Bewerbung ist in gutem Zustand und wir haben sie fast vollständig von Express zu Fastify migriert. Eine weitere Sache, die migriert werden muss: Unsere Verwendung des CORS Express Middleware -Pakets. Wir haben das Fastify-Cors-Plugin zuvor installiert und müssen es jetzt in unserer Anwendung hinzufügen, um die CORS Middleware zu ersetzen.
In unserem Routing -Modul (SRC/Routes.js) müssen wir den Import der CORS Middleware ersetzen:
<code>mkdir express-to-fastify-migration cd express-to-fastify-migration npm init -y </code>
Dann müssen wir den Aufruf zu Fastyify.use () durch den Anruf an Fastify.register () ersetzen:
<code>npm install express cors </code>
Beachten Sie, dass wir, wenn wir das Plugin mit Fastify registrieren, die Plugin -Funktions- und Optionobjekte als separate Parameter übergeben müssen.
Da wir die vom Fastify-Express-Plugin bereitgestellte Verwendung () nicht mehr verwenden, können wir sie vollständig aus unserer Anwendung entfernen. Lassen Sie uns dazu die folgenden Zeilen aus unserem App -Modul (src/app.js) löschen:
<code> app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>Sie können die Unterschiede in diesen Codeänderungen auf GitHub anzeigen.
Die Migration unserer Anwendung von Express to Fastify wurde abgeschlossen! Wir können nun expressbezogene Abhängigkeiten entfernen, indem wir diesen Befehl im Terminal ausführen:
<code> app.get("/user/:id", async (request, reply) => {
const name = request.body.name;
reply.send({ user: { name } });
});
</code>Sie können die Unterschiede in diesen Codeänderungen auf GitHub anzeigen.
Jetzt, da wir die Anwendung vollständig migriert haben, ist es ein guter Zeitpunkt, um zu überprüfen, ob noch alles wie erwartet funktioniert. Lassen Sie uns den gleichen Befehl ausführen, den wir zuvor ausgeführt haben, als die Anwendung Express verwendete.
Erstens werden wir die Anwendung im Terminal ausführen:
<code>// src/routes.js
const router = express.Router();
router.get("/:user_id", function getUser(request, response, next) {
response.json({});
});
export default router;
</code>Dann werden wir in einem anderen Terminal Curl verwenden, um eine Anfrage an die API zu stellen, um zu bestätigen, dass es wie erwartet funktioniert:
<code>// src/server.js
import Fastify from "fastify";
import ExpressPlugin from "fastify-express";
import routes from "./routes.js";
const fastify = Fastify();
await fastify.register(ExpressPlugin);
fastify.use("/user", routes);
await fastify.listen(3000);
</code>wir sollten eine Antwort wie folgt erhalten:
<code>mkdir express-to-fastify-migration cd express-to-fastify-migration npm init -y </code>
Unser Beispiel für Express-Anwendung verwendet nur einige Middleware-Funktionen, aber unsere reale Express-Anwendung kann mehr verwenden. Wie wir sehen können, ermöglicht das Fastify-Express-Plugin die Verwendung von Express Middleware (falls erforderlich). Auf diese Weise können wir das Umschreiben unserer eigenen benutzerdefinierten Express -Middleware zum Fasty -Plugin verzögern. Aber wie ersetzen wir Express Middleware von Drittanbietern?
Zum Glück bietet Fastify ein gesundes Ökosystem von Plugins. Hier sind einige beliebte Express Middleware -Pakete, die wir durch das Fastify -Plugin ersetzen können:
Einige Fastify -Plugins sind direkte Anschlüsse oder Wrapper für ihre Express -Gegenstücke. Dies bedeutet, dass wir normalerweise nicht die an das Fastify -Plugin übergebenen Konfigurationsoptionen ändern müssen.
Sie finden eine vollständige Liste von Plugins auf der Seite Fastify -Ökosystem.
Jetzt, da wir uns mit Fastify durch Migrieren von Expressanwendungen kennengelernt haben, ist es an der Zeit, sich mit anderen Fastify -Funktionen zu befassen, von denen wir profitieren können.
Fastify bietet Anforderungsüberprüfungsfunktion. Es verwendet AJV (ein weiteres JSON -Schema -Validator) im Hintergrund, mit dem wir Validierungsregeln mithilfe des JSON -Schemas definieren können.
Dies ist ein Beispiel für die Verwendung des JSON -Modus, um die Anforderungsbehörde auf einer Postroute zu überprüfen:
<code>npm install express cors </code>
Überprüfungsfehler werden automatisch formatiert und als JSON -Antwort gesendet:
<code>"type": "module", </code>
Erfahren Sie mehr in der Dokumentation der Fastify -Überprüfung und Serialisierungsdokumentation.
Protokollierung in Node.JS -Anwendungen können die Leistung in Produktionsumgebungen negativ beeinflussen. Dies liegt daran, dass die Serialisierung und Übertragung von Protokolldaten an anderer Stelle (z. B. in Elasticsearch) viele Schritte umfasst. Eine hohe Optimierung in dieser Anwendung ist sehr wichtig.
Protokollierung der Protokollierung ist vollständig in Fastify integriert. Dies bedeutet, dass wir keine Zeit damit verbringen müssen, Holzfäller auszuwählen und zu integrieren. Fastify verwendet Fast und Flexible Logger: Pino. Es generiert Protokolle im JSON -Format:
<code> app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>Wenn wir eine Fastify -Server -Instanz erstellen, können wir die Protokollierung aktivieren und die an Pino übergebenen Optionen anpassen. Fastify gibt dann die oben gezeigte Protokollnachricht automatisch aus. Die Logger -Instanz ist in einer Fastify -Serverinstanz verfügbar (z. B. Fastify.log.info ("...")) und alle Anforderungsobjekte (z. B. Request.log.info ("...")).
Erfahren Sie mehr in der Fastify -Protokollierungsdokumentation.
Fastify bietet eine setErrorHandler () -Methode, mit der wir die Fehlerbehandlungsfunktion explizit angeben können. Dies unterscheidet sich von Express, wobei ein Fehler mit Middleware nur durch die von ihm akzeptierten Parameter unterschieden werden kann (Err, Req, Res, Weiter) und in einer bestimmten Reihenfolge hinzugefügt werden muss.
Für die vollständige Flexibilität können wir verschiedene Fastify -Fehlerhandler in verschiedenen Plugins angeben. Erfahren Sie mehr in der Fastify -Fehlerdokumentation.
Dekoratoren sind eine leistungsstarke Funktion in Fastify, mit der wir Kernfasty -Objekte - wie unsere Fastify -Server -Instanz - sowie Anforderungs- und Antwortobjekte anpassen können. Hier ist ein Beispiel für einen einfachen Dekorateur:
<code> app.get("/user/:id", async (request, reply) => {
const name = request.body.name;
reply.send({ user: { name } });
});
</code>Mit dem Dekorateur können wir Inhalte wie Datenbankverbindungen oder Motoren in der Fastify -Anwendung anzeigen. Erfahren Sie mehr in der Dokumentation des Fastify Decorators.
In diesem Artikel haben wir gelernt, wie man vorhandene Node.js -Anwendungen von Express zu Fasty migriert. Wir haben bereits erfahren, wie das Fastify-Express-Plugin uns dabei helfen kann, vorhandene Anwendungen allmählich zu migrieren. Auf diese Weise können wir von den von Fastify bereitgestellten Funktionen profitieren, auch wenn Teile unserer Anwendung weiterhin Express verwenden.
Folgende Ressourcen finden Sie möglicherweise nützlich, wenn Sie von Express zu Fastify migrieren:
Express und Fastify sind beide Node.js -Web -Frameworks, haben jedoch einige wichtige Unterschiede. Express ist ein minimalistisches Webanwendungs -Framework, das eine einfache Schnittstelle zum Erstellen von Webanwendungen und APIs bietet. Es gibt es schon lange, mit einer riesigen Community und einer reichhaltigen Middleware. Fastify hingegen ist ein neueres Rahmen, das sich darauf konzentriert, das beste Entwicklererlebnis mit minimalem Overhead und einer leistungsstarken Plug-in-Architektur zu bieten. Es ist sehr schnell gestaltet, daher der Name, und Benchmarks zeigen, dass es mehr Anfragen pro Sekunde als Express bearbeiten kann.
Migrieren von Express zu Fastify enthält mehrere Schritte. Zunächst müssen Sie die Express -Instanz in der Anwendung durch eine Fastify -Instanz installieren und ersetzen. Sie müssen dann Express-spezifische Middleware durch Fastify-Plugin oder benutzerdefinierten Code ersetzen. Sie müssen auch Ihre Route aktualisieren, um das Routing -System von Fastify zu verwenden. Schließlich müssen Sie Ihren Fehlerbehandlungscode aktualisieren, um den Fehlerbehandlungsmechanismus von Fastify zu verwenden.
Fastify verfügt über ein eigenes Middleware-System, unterstützt jedoch auch Middleware im Express-Stil über das Plugin "Middie". Die Verwendung von Express Middleware in Fastify kann jedoch die Leistung beeinflussen. Es wird daher empfohlen, Fastify -Plugins oder benutzerdefinierte Code nach Möglichkeit zu verwenden.
Fastify verfügt über einen integrierten Fehlerbehandlungsmechanismus, mit dem Sie Fehler in Ihrer Anwendung behandeln können. Sie können benutzerdefinierte Fehlerhandler für eine bestimmte Route oder für die gesamte Anwendung definieren. Fastify unterstützt auch die Async/Awed -Syntax, wodurch Fehler direkter als Express behandelt wird.
Hook ist eine leistungsstarke Funktion in Fastify, mit der Sie benutzerdefinierten Code in verschiedenen Phasen des Anforderungs-/Antwortlebenszyklus ausführen können. Sie können Hooks verwenden, um Anfragen oder Antworten zu ändern, Authentifizierung, Datensatzanforderungen und mehr auszuführen. Fastify unterstützt mehrere Haken, einschließlich "OnRequest", "Prehandler", "Onsend" und "OnResponse".
Plugin ist eine wichtige Funktion von Fastify, mit der Sie die Funktionalität Ihrer Anwendung erweitern können. Sie können Plugins verwenden, um neue Funktionen hinzuzufügen, in andere Dienste zu integrieren oder die Anwendungslogik zusammenzufassen. Fastify verfügt über ein reichhaltiges Plugin -Ökosystem und Sie können auch eigene Plugins erstellen.
Fastify verfügt über ein leistungsstarkes Routing -System, das Parameter, Abfragestassen, Platzhalter usw. unterstützt. Sie können eine Route mithilfe der "Route" -Methode definieren, die ein Optionsobjekt akzeptiert, das die Methoden, URLs, Handler und andere Optionen der Route angibt.
In Fastify können Sie eine Antwort mit dem an den Routing -Handler übergebenen Objekt "Antwort" senden. Es gibt verschiedene Möglichkeiten, Antworten an das Objekt "Antwort" zu senden, einschließlich "Senden", "Code", "Header" und "Typ". Fastify serialisiert auch automatisch die JSON -Antworten für die Leistung.
Fastify unterstützt die Anforderung und Antwortüberprüfung mithilfe von JSON -Schema. Sie können Muster für Routen definieren, und Fastify überprüft automatisch eingehende Anforderungen und ausgehende Antworten anhand dieser Muster. Dies hilft, Fehler frühzeitig zu erkennen und die Anwendungszuverlässigkeit zu verbessern.
Fastify ist so konzipiert, dass er schnell und effizient ist. Es verwendet eine leichte Architektur, unterstützt HTTP/2 und HTTP/3 und verfügt über ein leistungsstarkes Plug-in-System, das den Overhead minimiert. Fastify serialisiert auch automatisch JSON -Antworten und unterstützt die Anforderung und Antwortüberprüfung, wodurch die Leistung verbessert wird.
Das obige ist der detaillierte Inhalt vonSo migrieren Sie Ihre App von Express zu Fastify. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Der Unterschied zwischen typedef und define
hat eine eigene Grundstücksnutzung
So richten Sie einen sicheren VPS ein
So fangen Sie belästigende Anrufe ab
Verwendung der ppf-Funktion in Python
So lösen Sie das Problem „Warten auf Gerät'.
So führen Sie Python in vscode aus
Persönliche Bitcoin-Handelsplattform
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
