Introduction à Koa.js : un framework léger pour les API et les applications Web

Koa est un framework middleware moderne et léger développé par l'équipe Express.js qui nous permet d'utiliser des fonctions middleware asynchrones.

Exemple d'application

<code class="language-javascript">const Koa = require('koa');
const app = new Koa();

app.use(async function(ctx) {
  ctx.body = 'Hello';
});

app.listen(3000);</code>

Ici, nous créons une instance Koa et mettons en place un middleware pour renvoyer "Bonjour" à chaque requête.

Caractéristiques

• Grammaire moderne
• Prend en charge le middleware asynchrone/attente.
• Léger, seulement environ 570 lignes de code.
  • Zéro middleware fourni.
• Objet Contexte (ctx), au lieu de (req, res)
  • La signature middleware est middleware(ctx, next)
• Meilleure gestion des erreurs

Qu'est-ce qu'un middleware ?

Le middleware est une fonction qui reçoit une requête HTTP et peut répondre à la requête pendant le cycle requête/réponse. Il peut également appeler le middleware suivant dans la liste. Voici un exemple.

<code class="language-javascript">async function exampleMiddleware(ctx, next) {
  // 从 ctx（上下文）读取请求数据
  // 更多逻辑
  // 设置 ctx.body 作为响应

  // 调用下一个中间件
  await next();

  // 在调用 next 之后，由于使用了 await 语法，我们可以做更多的事情。
  // 例如记录所花费的时间
}

// 设置中间件
app.use(exampleMiddleware);</code>

Le framework Middleware nous permet de définir plusieurs fonctions middleware et de les exécuter dans l'ordre de définition. Vous avez peut-être remarqué le paramètre suivant dans l'exemple ci-dessus. C'est une fonction qui, lorsqu'elle est appelée, passe le contrôle au middleware suivant.

L'utilisation de fonctions asynchrones nous permet d'utiliser wait pour effectuer certaines opérations de manière stack après l'exécution du middleware.

Si aucune autre exécution n'est requise, il n'est pas nécessaire d'appeler ensuite. Par exemple, considérons un middleware d’authentification. Si l'utilisateur est connecté, next est appelé, sinon la page de connexion s'affiche.

<code class="language-javascript">// 身份验证中间件
app.use(async (ctx, next) => {
  if(user){
    // 调用列表中的下一个中间件
    await next();
  } else {
    // 显示登录页面
  }
});

// Hello 中间件
app.use(async (ctx) => {
  ctx.body = 'Hello';
});</code>

Comme vous pouvez le constater, l'ordre des middlewares est également important.

Contexte Koa (ctx)

Chaque middleware reçoit deux paramètres. Le premier est le contexte (en abrégé ctx) et le suivant.

ctx contient les attributs de la requête. De plus, il contient des setters qui peuvent répondre aux demandes.

Ce qui suit est une liste d'attributs communs. Vous pouvez trouver la liste complète ici.

名称	描述
ctx.method	当前请求方法
ctx.path	当前请求路径
ctx.query	查询字符串
ctx.body	设置响应正文的设置器

comment effectuer des tâches communes --------------------------

Ajout de parties moyennes

Utilisez App.use -Document. Veuillez noter que l'ordre du middleware est important.

<code class="language-javascript">const Koa = require('koa');
const app = new Koa();

app.use(async function(ctx) {
  ctx.body = 'Hello';
});

app.listen(3000);</code>

Démarrez le serveur

Utilisez App.Listen -Document.

<code class="language-javascript">async function exampleMiddleware(ctx, next) {
  // 从 ctx（上下文）读取请求数据
  // 更多逻辑
  // 设置 ctx.body 作为响应

  // 调用下一个中间件
  await next();

  // 在调用 next 之后，由于使用了 await 语法，我们可以做更多的事情。
  // 例如记录所花费的时间
}

// 设置中间件
app.use(exampleMiddleware);</code>

Définissez le texte de réponse

Utilisez ctx.body seter -Document.

<code class="language-javascript">// 身份验证中间件
app.use(async (ctx, next) => {
  if(user){
    // 调用列表中的下一个中间件
    await next();
  } else {
    // 显示登录页面
  }
});

// Hello 中间件
app.use(async (ctx) => {
  ctx.body = 'Hello';
});</code>

réinitialiser vers

Utilisez ctx.redirect -Document.

<code class="language-javascript">app.use(middlewareFunction1);
app.use(middlewareFunction2);
app.use(middlewareFunction3);</code>

Traitement d'erreur

ctx.throw -Document.

Comment créer une application complète

<code class="language-javascript">app.listen(3000);</code>

KOA fournit le middleware framework et CTX qui peuvent être utilisés dans la partie médiane. Il ne contient aucun middleware groupé.

Pour créer une application complète, nous devons utiliser le middleware fourni par la communauté KOA. Ce qui suit est une liste des middleware communs.

routeur

L'analyseur principal
enregistreur de journal
EJS Rendre le dispositif
• Vous pouvez parcourir KOA Github pour obtenir plus de middleware disponibles.

Conclusion

KOA est un excellent cadre Web moderne léger pour la création d'API et d'applications Web. Vous pouvez lire plus de documents sur le site Web de KOA.

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!