Comment migrer votre application d'Express pour accuser

Express était autrefois le cadre le plus populaire pour développer des applications Web à l'aide de node.js. Cependant, le cadre a diminué le développement actif ces dernières années, entraînant un manque de support pour les fonctionnalités JavaScript modernes. Dans le même temps, de nombreux nouveaux cadres qui adoptent différentes approches du développement d'applications Node.js émergent, et Fintify en fait partie.

Cet article explorera pourquoi Fintify est devenu une alternative convaincante au développement d'applications Web de Node.js. Nous apprendrons comment éviter la réécriture des applications express existantes à partir de zéro et nous déplacerons plutôt pour accuser étape par étape. Après avoir étudié cet article, vous pourrez migrer en toute confiance vos applications express existantes et commencer à profiter du framework Fastify.

Les conditions suivantes doivent être remplies lors de la lecture de cet article:

• familiarisé avec la création d'applications Express Basic, la définition du routage et la configuration du middleware.
• familier avec les commandes en cours d'exécution dans le terminal.
• node.js & gt; = v14.13.0 est installé. Cela nous fournit une bonne prise en charge du module ECMAScript (ES) et nous permet d'utiliser un attente de niveau supérieur. Les exemples de code de cet article utilisent la syntaxe du module ES (import / export).

Tout le code de cet article peut être trouvé sur GitHub et vous pouvez parcourir, télécharger et expérimenter.

La version vidéo de cet article est également disponible sur mon site Web.

points clés

• Fastify fournit une vérification et une journalisation intégrées, un support asynchrone natif et une analyse JSON automatique, améliorer l'efficacité de développement et les performances des applications par rapport à Express.
• fastify-express Le plug-in facilite la migration progressive d'Express pour agrandir en permettant l'utilisation de middleware express et le routage dans le framework Fastify.
• Les tests d'intégration doivent être indépendants du cadre pour s'assurer qu'ils restent valides avant et après la migration, simplifiant ainsi le processus de test.
• Le refactorisation consiste à remplacer le code express par des équivalents Fastify, comme l'utilisation des systèmes de routage et de plug-in de Fastify au lieu de routeurs express et de middleware.
• Le processus de migration peut être mis en scène, intégrant d'abord Fintify dans une application Express existante, puis en remplaçant progressivement les composants express.
• Après la migration, assurez-vous de remplacer le middleware express tiers par le plugin Fastify équivalent pour profiter des performances et des capacités de Fastify.

Les avantages de la migration de l'express pour agrandir

Si vous êtes familier avec les applications Node.js de création en utilisant Express, vous vous demandez peut-être quels sont les avantages de la migration de vos applications express existantes pour vous régler. Voici quelques raisons importantes pour considérer la migration:

• Vérification et enregistrement de la boîte. Ces fonctionnalités sont généralement requises lors de la création d'applications Web. Lors de l'utilisation de FASCIFY, il n'est pas nécessaire de sélectionner et d'intégrer des bibliothèques pour ces tâches, car elle nous fournit ces capacités. Nous en apprendrons plus sur ces fonctionnalités plus tard dans cet article.

• Prise en charge native du code asynchrone. Fasnifiez nativement la promesse et prend en charge l'async / attendre. Cela signifie que l'itinéraire capturera pour nous des promesses rejetées non tracées. Cela nous permet d'écrire du code asynchrone en toute sécurité. Il nous permet également de faire des choses concises, comme l'envoi automatique de la valeur de retour de la fonction de gestionnaire de routage comme le corps de réponse:

  <code>  app.get("/user/:id", async (request) => await getUser(request.params.id));
  </code>

• analyser automatiquement et sérialiser JSON. Nous n'avons pas besoin de configurer Fintify pour analyser le corps de la demande JSON, et nous n'avons pas besoin de sérialiser l'objet à JSON pour la réponse. Il gérera automatiquement tout cela pour nous:

  <code>  app.get("/user/:id", async (request, reply) => {
      const name = request.body.name;
  
      reply.send({ user: { name } });
    });
  </code>

• Friendly des développeurs. Avec une API claire et expressive et un excellent support pour TypeScript, Fastify est conçu avec l'expérience du développeur à l'esprit.

• vitesse rapide. Nous ne voulons pas que les cadres soient la source des goulots d'étranglement de performances dans nos applications. La bonne nouvelle est que Fastify est construit pour atteindre des performances élevées. La référence Fastify montre comment elle se compare à d'autres frameworks Web Node.js.

• Développement activement. Le framework Fastify est en cours de développement actif. Libérez régulièrement les améliorations et les correctifs de bogue / de sécurité.

comment migrer en toute confiance l'API

Nous voulons être sûrs qu'il fonctionne toujours comme prévu après la migration de l'application. Une chose qui nous aide à repérer les erreurs ou à identifier des changements inattendus est les tests d'intégration de l'API.

Le test d'intégration teste les composants de l'application d'une manière différente des tests unitaires. L'unité teste la fonctionnalité des composants individuels. Les tests d'intégration nous permettent de vérifier le comportement de plusieurs composants travaillant ensemble.

Si nous écrivons des tests d'intégration d'API pour les applications Express, nous voulons pouvoir exécuter le même test après la migration de l'application pour nous régler. Lors de la rédaction de tests d'intégration pour les API, les points suivants doivent être pris en compte:

• Ils ne doivent pas être liés à un cadre spécifique. Nous voulons pouvoir exécuter les mêmes tests avant et après la migration sans modifier les tests ou les bibliothèques que nous utilisons.
• Gardez les choses simples. À tout le moins, les tests d'intégration devraient faire une demande au point final exposé par l'API et vérifier qu'une réponse a été retournée, mais pas souvent plus. Nous pouvons vouloir vérifier les codes d'état HTTP spécifiques ou les en-têtes de réponse, mais nous devons essayer de rendre le test aussi simple que possible.
• Sélectionnez les outils que vous connaissez. Il existe de nombreux outils différents qui peuvent nous aider à créer et à exécuter des tests d'API, mais il est important d'utiliser des outils que nous connaissons. Pour rédiger des tests d'intégration efficaces, nous devons être en mesure d'émettre des demandes HTTP et d'affirmer les réponses de notre API. D'une manière générale, nous n'avons pas besoin de nombreuses bibliothèques ou outils pour y parvenir.

Nous n'entrerons pas dans les détails de la façon d'implémenter les tests d'intégration de l'API dans cet article, mais vous devriez envisager de les écrire avant de faire des migrations de framework.

migrer d'Express pour agrandir en utilisant FASTIFY-EXPRESS

L'idée de migrer les applications express existantes vers un cadre complètement différent peut sembler assez intimidant. Heureusement, l'équipe Fastify a créé un plugin - Fastify-Express - qui peut aider à simplifier les chemins de migration.

Le plugin Fastify-Express ajoute une compatibilité express complète pour acquilibrer. Il fournit une méthode use () que nous pouvons utiliser pour ajouter des middleware et des routes express à notre serveur Fastify. Cela nous donne la possibilité de migrer progressivement des parties de notre application Express existante à exploser.

Ceci est un exemple de routeur express:

<code>  app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>

Nous pouvons ensuite utiliser Fastify-Express pour ajouter notre routeur express existant à l'instance Fastify Server:

<code>  app.get("/user/:id", async (request, reply) => {
    const name = request.body.name;

    reply.send({ user: { name } });
  });
</code>

Après un moment, nous explorerons les détails de tous ces fonctions alors que nous commençons à migrer l'application pour nous régler.

Il est important de noter que l'utilisation du plugin Fastify-Express n'est pas une solution à long terme. Si nous voulons obtenir tous les avantages de Fintify, nous devons éventuellement migrer notre code d'application spécifique à l'express. Cependant, le plugin Fastify-Express nous offre la possibilité de migrer pour agrandir en phases.

Notre exemple de application Express

Nous allons créer un exemple d'application Express, puis la migrerons vers le framework Fastify. Regardons maintenant son code.

Dépendances requises

Tout d'abord, créons un nouveau projet:

<code>// src/routes.js
const router = express.Router();

router.get("/:user_id", function getUser(request, response, next) {
  response.json({});
});

export default router;
</code>

Nous exécuterons ensuite cette commande dans le terminal pour installer les dépendances requises par notre application Express:

<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>

Enfin, ouvrez package.json et ajoutez la ligne suivante au-dessus de la section Scripts:

<code>mkdir express-to-fastify-migration
cd express-to-fastify-migration
npm init -y
</code>

Cela nous permettra de charger le module ES dans notre application.

Module de routage

Nous créerons une instance de routeur express pour nous aider à encapsuler notre routage et notre middleware. Les routeurs dans Express peuvent être utilisés pour nous aider à organiser des applications dans des modules discrets. Par exemple, nous pourrions avoir un routeur pour le routage / utilisateur et un autre pour le routage / adresse. Nous verrons plus tard comment cela nous aide à éliminer les applications express pour nous régler.

Créons une instance de routeur et ajoutons-y du middleware:

<code>npm install express cors
</code>

Dans le code ci-dessus, nous avons configuré deux exemples de middleware express:

• express.json (). Cette fonction middleware est intégrée à Express. Il gère l'analyse du corps de la demande JSON.
• CORS. Ce middleware nous aide à ajouter l'en-tête CORS à notre réponse API. Il permettra à notre API d'être appelée à partir de la page Web.

Ces outils de middleware fonctionneront contre toutes les demandes faites par toutes les itinéraires que nous définissons sur ce routeur.

Maintenant que nous avons configuré le middleware, nous pouvons ajouter la première route à notre routeur:

<code>"type": "module",
</code>

Dans une application réelle, la fonction de gestionnaire de routage ci-dessus vérifiera les données qu'il reçoit, puis appellera la base de données pour créer un nouvel enregistrement utilisateur. Pour cet exemple, nous envoyons des données reçues comme corps de réponse.

Maintenant, nous allons ajouter un itinéraire pour récupérer les utilisateurs:

<code>  app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>

Comme le routage du post, le gestionnaire de routage ci-dessus appelle généralement la base de données pour récupérer les données utilisateur, mais pour cet exemple, nous avons codé en dur un objet à envoyer dans le corps de réponse.

Enfin, nous exporterons l'objet de routeur afin que nous puissions l'importer dans un autre module:

<code>  app.get("/user/:id", async (request, reply) => {
    const name = request.body.name;

    reply.send({ user: { name } });
  });
</code>

module d'application

Maintenant, nous allons créer un module d'applications:

<code>// src/routes.js
const router = express.Router();

router.get("/:user_id", function getUser(request, response, next) {
  response.json({});
});

export default router;
</code>

Dans ce module, nous définissons une fonction qui crée une nouvelle instance de serveur express. Nous ajoutons ensuite l'objet routeur à l'instance de serveur.

Module serveur

Enfin, nous créerons un module de serveur. Ce module utilise la fonction buildApp () que nous avons définie dans le module APP pour créer une nouvelle instance de serveur express. Il démarre ensuite notre serveur express en le configurant pour écouter sur le port 3000:

<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>

Exécutez notre application

Nous avons maintenant une application EXPRESS RANNABLE complète que nous pouvons exécuter dans le terminal:

<code>mkdir express-to-fastify-migration
cd express-to-fastify-migration
npm init -y
</code>

Dans un autre terminal, nous pouvons utiliser Curl pour faire une demande à l'API pour confirmer si cela fonctionne:

<code>npm install express cors
</code>

Nous devrions recevoir une réponse comme suit:

<code>"type": "module",
</code>

Migrez notre application d'Express pour agrandir

Maintenant, nous avons une application Express entièrement tractée que nous allons migrer vers l'utilisation du framework Fastify.

Dépendances requises

Nous devons installer trois dépendances:

• FASCIFIER Framework
• FASTIFY-Express Plugin
• Plugin Fastify-Cors - Il s'agit d'une version portée du middleware express CORS que notre application utilise déjà

Exécutons cette commande dans le terminal pour les installer:

<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>

Vous pouvez afficher les différences de ces modifications de code sur GitHub.

Refactor notre module d'application

Maintenant que les dépendances sont installées, nous devons refactorriser notre module d'application. Nous allons le changer en:

• Importer Fintify et Fastify-Express au lieu d'express
• Créez une instance de serveur Fintify au lieu d'une instance de serveur express
• Ajoutez notre objet de routeur express au serveur à l'aide du plugin Fastify-Express

C'est à quoi nous ressemblons après avoir apporté ces modifications:

<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>

Vous pouvez afficher les différences de ces modifications de code sur GitHub.

vous remarquerez dans le code ci-dessus que lorsque nous créons une instance de serveur Fastify, nous passons l'option Logueur. Cela permet à Fastify de la fonction de journalisation intégrée de Fastify. Nous en apprendrons plus à ce sujet plus tard.

Refactor notre module de serveur

Maintenant, nous devons modifier notre module de serveur pour travailler avec l'instance Fastify Server:

<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>

Vous pouvez afficher les différences de ces modifications de code sur GitHub.

Étant donné que Fastify Native prend en charge la promesse, dans le code ci-dessus, nous pouvons utiliser AWAIT, puis utiliser la fonction de journalisation intégrée de Fastify pour capturer et enregistrer toutes les erreurs.

Étape suivante

Notre application utilise désormais Fintify pour acheminer les demandes et envoyer des réponses. Il est complet, mais notre routage utilise toujours Express. Afin de migrer pleinement pour exprimer, nous devons migrer nos itinéraires vers l'utilisation de Fintify également.

Refactor Notre module de routage

Le routage dans les applications express est encapsulé dans les routeurs express. Nous avons refactorisé ce routeur à un plugin Fastify. Le plug-in est une fonctionnalité de FASTIFY qui nous permet d'encapsuler le routage et toutes les fonctionnalités connexes.

Nous allons commencer par supprimer certaines lignes spécifiques expresses pour refacter notre module de routage (src / routes.js):

<code>  app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>

Ensuite, nous devons modifier l'exportation du module par défaut vers une fonction asynchrone qui accepte l'instance Fastify Server. Ceci est le fondement du plugin Fastify. Le reste du code dans notre module de routage sera déplacé dans cette fonction de plugin:

<code>  app.get("/user/:id", async (request, reply) => {
    const name = request.body.name;

    reply.send({ user: { name } });
  });
</code>

Pour que notre middleware et notre routage fonctionnent avec Fintify, nous devons changer:

• Modifier la référence du routeur pour agrandir
• Modifiez la fonction du gestionnaire de routes en une fonction asynchrone
• Modifiez les paramètres de fonction du gestionnaire de routes de (demande, réponse, suivant) à (demande, réponse)
• Modifier la référence de réponse pour répondre
• Modifiez l'appel de réponse.json () à répondre.send ()
• Modifiez l'instance suivante (erreur) pour lancer une erreur

Après avoir apporté toutes ces modifications, notre module de routage est désormais un plugin Fastify avec Routing Fastify:

<code>// src/routes.js
const router = express.Router();

router.get("/:user_id", function getUser(request, response, next) {
  response.json({});
});

export default router;
</code>

Maintenant, nous devons modifier notre module d'application (src / app.js) pour utiliser le plugin que nous avons exporté à partir du module de routage. Cela signifie remplacer l'appel fastiftify.use () par un appel pour exploser.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>

Vous pouvez afficher les différences de ces modifications de code sur GitHub.

Notre exemple de l'application Express n'a qu'un seul routeur, nous pouvons donc migrer tous les itinéraires de l'application pour utiliser Fintify à la fois. Cependant, si nous avions une application express plus grande avec plusieurs routeurs, nous pourrions migrer chaque routeur pour nous régler étape par étape à la fois.

Remplacez le middleware par le plug-in

Notre application est en bon état et nous l'avons presque complètement migrée d'Express à Nusifier. Encore une chose à migrer: notre utilisation du package middleware CORS Express. Nous avons déjà installé le plugin Fastify-Cors, et maintenant nous devons l'ajouter dans notre application pour remplacer le middleware CORS.

Dans notre module de routage (src / routes.js), nous devons remplacer l'importation du middleware COR:

<code>mkdir express-to-fastify-migration
cd express-to-fastify-migration
npm init -y
</code>

Ensuite, nous devons remplacer l'appel pour exploser.use () par l'appel pour exploser.Register ():

<code>npm install express cors
</code>

Notez que lorsque nous enregistrons le plugin avec Fastify, nous devons passer la fonction du plugin et les objets d'option en tant que paramètres séparés.

Puisque nous n'utilisons plus la fonction Use () fournie par le plugin Fastify-Express, nous pouvons le supprimer complètement de notre application. Pour ce faire, supprimons les lignes suivantes de notre module d'application (src / app.js):

<code>  app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>

Vous pouvez afficher les différences de ces modifications de code sur GitHub.

supprimer les dépendances expresses

La migration de notre application d'Express à Fintify a été achevée! Nous pouvons désormais supprimer les dépendances liées aux expressions en exécutant cette commande dans le terminal:

<code>  app.get("/user/:id", async (request, reply) => {
    const name = request.body.name;

    reply.send({ user: { name } });
  });
</code>

Vous pouvez afficher les différences de ces modifications de code sur GitHub.

Exécutez notre application migrée

Maintenant que nous avons complètement migré l'application pour nous régler, c'est le bon moment pour vérifier si tout fonctionne toujours comme prévu. Exécutons la même commande que nous avons exécutée avant lorsque l'application utilisait Express.

Tout d'abord, nous exécuterons l'application dans le terminal:

<code>// src/routes.js
const router = express.Router();

router.get("/:user_id", function getUser(request, response, next) {
  response.json({});
});

export default router;
</code>

Ensuite, dans un autre terminal, nous utiliserons Curl pour faire une demande à l'API pour confirmer qu'il fonctionne comme prévu:

<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>

Nous devrions recevoir une réponse comme suit:

<code>mkdir express-to-fastify-migration
cd express-to-fastify-migration
npm init -y
</code>

Débarrassez-vous du middleware

Notre exemple de l'application Express utilise uniquement certaines fonctions de middleware, mais notre application Express du monde réel peut en utiliser davantage. Comme nous pouvons le voir, le plugin Fastify-Express nous permet de continuer à utiliser le middleware express (si nécessaire). Cela nous permet de retarder la réécriture de notre propre middleware Express personnalisé pour accélérer le plugin. Mais comment remplacer le middleware express tiers?

Heureusement, Fastify fournit un écosystème sain de plugins. Voici quelques packages middleware express populaires que nous pouvons remplacer par le plugin Fastify:

• CORS ➜ FASTIFY-CORS
• Casque ➜ Fastify-helmet
• CSURF ➜ FASTIFY-CSRF
• Express-Session ➜ Fastify-Server-Session
• Express-Jwt ➜ Fastify-Jwt
• Http-Errors ➜ Raspify-sensible
• Serve-statique ➜ Fastify-static
• MULTER ➜ FASTIFY-MULTER

Certains plugins accumulés sont des ports ou des emballages directs pour leurs homologues express. Cela signifie que nous n'avons généralement pas besoin de modifier les options de configuration transmises au plugin Fastify.

Vous pouvez trouver une liste complète des plugins sur la page Ettufy Ecosystème.

Faites un usage complet de Fintify

Maintenant que nous avons commencé à nous familiariser avec Fintify en migrant les applications express, il est temps de commencer à regarder d'autres fonctionnalités de stabilisation dont nous pouvons bénéficier.

Vérification

FASTIFY FOURNIE FOURNIE DE LA FONCTION DE VÉRIFICATION. Il utilise AJV (un autre validateur de schéma JSON) en arrière-plan, qui nous permet de définir des règles de validation à l'aide du schéma JSON.

Il s'agit d'un exemple d'utilisation du mode JSON pour vérifier le corps de la demande sur une route post:

<code>npm install express cors
</code>

Les erreurs de vérification sont automatiquement formatées et envoyées sous forme de réponse JSON:

<code>"type": "module",
</code>

En savoir plus dans la documentation de vérification et de sérialisation de la rapidité.

Enregistrement du journal

La journalisation du journal dans les applications Node.js peut affecter négativement les performances dans les environnements de production. En effet, le sérialisation et le transfert de données de journal ailleurs (par exemple, à Elasticsearch) impliquent de nombreuses étapes. Une optimisation élevée dans cette application est très importante.

La journalisation du journal est entièrement intégrée dans Fumptify, ce qui signifie que nous n'avons pas besoin de passer du temps à sélectionner et à intégrer les enregistreurs. Fastify utilise un enregistreur rapide et flexible: Pino. Il génère des journaux au format JSON:

<code>  app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>

Lorsque nous créons une instance de serveur Fastify, nous pouvons activer la journalisation et personnaliser les options transmises à Pino. Fastify sera ensuite automatiquement publié le message de journal comme indiqué ci-dessus. L'instance Logger est disponible sur une instance Fastify Server (par exemple, Fastify.log.info ("...")) et tous les objets de demande (par exemple, request.log.info ("...")).

En savoir plus dans la documentation de journalisation Fintify.

Gestion des erreurs

Fastify fournit une méthode SetErrorHandler () qui nous permet de spécifier explicitement la fonction de gestion des erreurs. Ceci est différent d'Express, où une erreur de gestion des middleware ne peut être distinguée que par les paramètres qu'il accepte (err, req, res, ensuite) et doit être ajouté dans un ordre spécifique.

Pour une flexibilité complète, nous pouvons spécifier différents gestionnaires d'erreurs Fascify dans différents plugins. En savoir plus dans la documentation d'erreur FASCIFY.

décorateurs

Les décorateurs sont une fonctionnalité puissante pour agrandir qui nous permette de personnaliser les objets de passion Core, tels que notre instance de serveur Emplacez, ainsi que les objets de demande et de réponse. Voici un exemple de décorateur de base:

<code>  app.get("/user/:id", async (request, reply) => {
    const name = request.body.name;

    reply.send({ user: { name } });
  });
</code>

Le décorateur nous permet d'utiliser du contenu comme des connexions de base de données ou des moteurs à afficher tout au long de l'application Fastify. En savoir plus dans la documentation Fastify Decorator.

Conclusion

Dans cet article, nous avons appris à migrer les applications Node.js existantes d'Express à Fintifier. Nous avons déjà appris comment le plugin Fastify-Express peut nous aider à migrer progressivement les applications existantes. Cela nous permet de commencer à bénéficier des fonctionnalités fournies par Fastify, même si des parties de notre application utilisent toujours Express.

Voici quelques ressources que vous pourriez trouver utiles lors de la migration d'Express pour agrandir:

• l'exemple de code de cet article. Explorez le code et exécutez l'application que nous avons construite dans cet article.
• FASCIFIER LA DOCUMENTATION. Documentation complète pour le framework Fastify.
• Attualisez l'écosystème. Attualisez le répertoire du plugin. Plugins faciles à trouver pour remplacer le middleware express.
• Attualisez l'exemple d'application. Exemple d'application créée par l'un des principaux maintenseurs de Fastify. Il démontre des concepts de mise à pied de base, des meilleures pratiques et des suggestions.
• Attachez le serveur de discorde communautaire. Un endroit idéal pour obtenir de l'aide et des conseils sur le développement d'applications avec Fintify.

FAQS pour la migration d'Exprand pour agrandir

Quelle est la principale différence entre l'express et le stabilisation?

Express et Fintify sont tous deux des frameworks Web Node.js, mais ils ont des différences clés. Express est un cadre d'application Web minimaliste qui fournit une interface simple pour créer des applications Web et des API. Il existe depuis longtemps, avec une énorme communauté et des middleware riches. Fintify, en revanche, est un cadre plus récent axé sur la fourniture de la meilleure expérience de développeur avec un minimum de frais généraux et une puissante architecture de plug-in. Il est conçu très rapidement, donc le nom et les repères montrent qu'il peut gérer plus de demandes par seconde qu'Express.

Comment migrer mon application express pour nous régler?

La migration d'Express à Fintify comprend plusieurs étapes. Tout d'abord, vous devez installer Fastify et remplacer l'instance express dans l'application par une instance Fastify. Vous devez ensuite remplacer le middleware spécifique express par Fastify Plugin ou Custom Code. Vous devez également mettre à jour votre itinéraire pour utiliser le système de routage de Fastify. Enfin, vous devez mettre à jour votre code de gestion des erreurs pour utiliser le mécanisme de gestion des erreurs de FASTIFY.

Puis-je utiliser Express Middleware dans Fintify?

Fastify a son propre système de middleware, mais il prend également en charge le middleware de style express via le plugin "Middie". Cependant, l'utilisation de middleware express dans Fastify peut affecter les performances, il est donc recommandé d'utiliser des plugins Fastify ou du code personnalisé dans la mesure du possible.

Comment gérer les erreurs pour acquérir?

Fastify a un mécanisme de gestion des erreurs intégré que vous pouvez utiliser pour gérer les erreurs dans votre application. Vous pouvez définir les gestionnaires d'erreurs personnalisés pour un itinéraire spécifique ou pour l'ensemble de l'application. Fastify prend également en charge la syntaxe asynchronisée / attendre, ce qui rend la gestion des erreurs plus directe que Express.

Comment utiliser les crochets dans Fintify?

Hook est une fonctionnalité puissante de Fintify qui vous permet d'exécuter du code personnalisé à différentes étapes du cycle de vie de la demande / réponse. Vous pouvez utiliser des crochets pour modifier les demandes ou les réponses, effectuer l'authentification, les demandes d'enregistrement, etc. Fastify prend en charge plusieurs crochets, notamment "OnRequest", "Preandler", "Onend" et "OnResponse".

Comment utiliser les plugins pour accuser?

Le plugin

est une caractéristique clé de Fintify qui vous permet d'étendre les fonctionnalités de votre application. Vous pouvez utiliser des plugins pour ajouter de nouvelles fonctionnalités, vous intégrer à d'autres services ou encapsuler la logique d'application. Fastify a un écosystème de plugin riche, et vous pouvez également créer vos propres plugins.

Comment définir un itinéraire pour accumuler?

FASTIFY a un puissant système de routage qui prend en charge les paramètres, les chaînes de requête, les caractères génériques, etc. Vous pouvez définir un itinéraire à l'aide de la méthode "route", qui accepte un objet d'option qui spécifie les méthodes, les URL, les gestionnaires et autres options de l'itinéraire.

Comment envoyer une réponse dans Fintify?

Dans Fintify, vous pouvez envoyer une réponse à l'aide de l'objet "Répondre" transmis au gestionnaire de routage. Il existe plusieurs façons d'envoyer des réponses à l'objet "Répondre", y compris "Send", "Code", "En-tête" et "Type". Fastify Sérialise également automatiquement les réponses JSON pour les performances.

Comment effectuer la vérification dans Fusttifify?

FASCIFITIONS Soutient la vérification de la demande et de la réponse à l'aide du schéma JSON. Vous pouvez définir des modèles pour les itinéraires et vous exploseront automatiquement les demandes entrantes et les réponses sortantes en fonction de ces modèles. Cela aide à détecter les erreurs tôt et à améliorer la fiabilité des applications.

Comment agrandir les performances améliore-t-elle?

FASTIFY est conçu pour être rapide et efficace. Il utilise une architecture légère, prend en charge HTTP / 2 et HTTP / 3 et possède un puissant système de plug-in qui minimise les frais généraux. Fastify Sérialise également automatiquement les réponses JSON et prend en charge la vérification des demandes et de la réponse, ce qui aide à améliorer les performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!