12 NodeJS-Frameworks zur Beschleunigung der Web- und API-Entwicklung

NodeJS ist schon seit einiger Zeit in der Branche tätig. Aufgrund seiner asyncAufgrund seiner chronologischen Natur und der Unterstützung des Chrome-V8-Motors erfreut es sich großer Beliebtheit.

NodeJS bietet eine Reihe von Frameworks, die mit unterschiedlichen Bibliotheken, Tools und Systemen geliefert werdenplatEs soll Entwicklern helfen, Hindernisse beim Erstellen von Apps zu umgehen.

Nodejs ist wahrscheinlich einer der beste JavaScript-Frameworks um eine Full-Stack-Anwendung zu entwickeln. Sobald Sie sich für Nodejs entschieden haben, ist die folgenden Frameworks und Plugins werden bei der Entwicklung von Backend- und API-Diensten nützlich sein.

Express

Express ist eines der beliebtesten Web- und API-Entwicklungsframeworks für NodeJS. Es ist so weit verbreitet, dass fast jedes Webentwicklungsprojekt mit der Integration von Express JS beginnt.

Es gibt eine Reihe von Gründen, ExpressJS als erstes Plugin zu wählen.

• Großes Funktionspaket, das alles unterstützt, was Sie für Ihre Entwicklungsaufgaben benötigen
• Einfache Routing-Funktion zum Weiterleiten Ihrer Webanforderungen an die Funktion
• Bietet eine organisierte platFormular zum Codieren von APIs
• Wird von den meisten anderen unterstützenden Bibliotheken und Plugins unterstützt
• Sicher gesichert und gewartet, um mit den Standards Schritt zu halten
• Großartige Community-Unterstützung

Zusätzlich zu diesen Vorteilen haben die Entwickler des Plugins auch Created ein benutzerfreundlicher Projektgenerator. Dieser Generator kann erstellenate ein templatDas Projekt soll Sie schneller auf die Beine bringen.

Projekt einrichten

Lassen Sie uns ein Projekt einrichten, um die Grundlagen des Express zu lernen. Stellen Sie sicher, dass Sie den Knoten auf Ihrem System installiert haben. Sie können sich darauf beziehen diese definitive Anleitung für die Knoteninstallation process.

1. Create ein Projektordner.
2. Öffnen Sie es im Terminal.
3. Installieren Sie das express, body-parser, cookie-parser, cors und nodemon.
4. Fügen Sie dem Projekt die Datei index.js hinzu.
5. Fügen Sie das Startskript der Anwendung in der packages.json Datei mit nodemon index.js Befehl.

Angebote

• express: Dies ist das Kernpaket unserer Anwendung, das uns bei der Erstellung hilftate APIs.
• Body-Parser: das ist ein Middleware Das analysiert die eingehenden Daten von der API und fügt sie dem hinzu req.body.
• Cookie-Parser: Dies ist eine Middleware, die das Header-Cookie analysiert und es dem hinzufügt req.cookie.
• Kors: Dies ist eine Middleware, die zum Aktivieren von CORS verwendet wird.
• Knotenmon: Dies wird verwendet, um unsere Anwendung auszuführen, die den Server neu startet, wenn sich eine Datei ändert.

Dies sind die Basispakete, die für die Express-Bewerbung benötigt werden, um uns das Leben zu erleichtern. Abhängig von Ihrem Projekt benötigen Sie möglicherweise weitere Pakete. Machen Sie sich jetzt keine Sorgen, das Hinzufügen von Paketen ist nur einen Befehl entfernt.

Express-App

Sehen wir uns die grundlegende Anwendung mit verschiedenen APIs an

const express = require("express");
const bodyParser = require("body-parser");
const cookieParser = require("cookie-parser");
const cors = require("cors");

// initializing the express
const app = express();
const port = 3000;

// adding the middlewares to the app
app.use(bodyParser.json());
app.use(cookieParser());
app.use(cors());

// req: we will use this paramter to get API request details
// res: we will use
app.get("/", (req, res) => {
  return res.send("Hello, World!");
});

app.get("/json", (req, res) => {
  return res.json({ greetings: "Hello, World!" }); // you can also use res.send({})
});

app.get("/path-params/:name", (req, res) => {
  // all the path params will present in req.params object
  const { name } = req.params;
  return res.json({ greetings: `Hello, ${name}!` });
});

app.get("/query-params", (req, res) => {
  // all the query params will present in req.query object
  const { name } = req.query;
  return res.json({ greetings: `Hello, ${name ? name : "Geekflare"}!` });
});

app.post("/post", (req, res) => {
  // data will present in req.body
  const { name } = req.body;
  console.log(req.body);
  return res.json({ greetings: `Hello, ${name ? name : 'Geekflare'}!` });
});

app.listen(port, () => {
  console.log(`App listening on port ${port}`);
});

Starten Sie die Anwendung mit npm start und probieren Sie alle APIs aus, die wir geschrieben haben. Lies das Dokumentation um mehr über jedes Konzept zu erfahren.

Segel

Segel ist ein vollwertiges MVC-Architektur-Framework. Im Kern werden ExpressJS und SocketIO verwendet. Sails.js wurde für sein Unternehmen bekanntriseHochwertige Architektur, die eine schnellere Integration in die Datenbank mithilfe von Modellobjekten ermöglichte.

Einige der Vorteile sind:

• Sails.JS wird sofort mit einem Projekt geliefertately geneate ein Projekttemplate
• Die Ordnerstruktur in Sails.JS ist sehr gut organisiert
• Die Entwicklung und Bereitstellung von Objektmodellen mithilfe des Frontends ist schnell
• Ermöglicht die einfache Integration von Middleware für Autorisierung, Authentifizierung und Vor-processIng.
• Mit integrierter Unterstützung für AWS S3 und GridFS

Projektaufbau

Create a sailsjs Projekt benötigen wir ein npm-Paket namens sail. Lass es uns global installierenally mit dem folgenden Befehl.

npm install sails -g

Gehen Sie in das Verzeichnis, in dem Sie erstellen möchtenate dein Projekt. Führen Sie nun den folgenden Befehl zum Erstellen ausate sailsjs App.

sails new basic-app

Es erscheint eine Aufforderung zur Auswahl des Artikelsplate. Wähle aus leer Möglichkeit. Warten Sie, bis das Projekt erstellt ist.

Öffnen Sie das Projekt in Ihrem bevorzugten Code-Editor. Führen Sie die aus sails lift Befehl zum Ausführen der Anwendung. Offen http://localhost:1337/ URL in Ihrem browsäh, um die Anwendung zu sehen.

Wenn Sie die Anwendung im Code-Editor sehen, finden Sie viele Ordner und Dateien. Eine detaillierte Erklärung zu jedem Ordner und jeder Datei finden Sie auf Segeldokumentation Seite. In diesem Tutorial werden wir einen sehen api/controllers und config/routes.js.

SailsJS-App

Mal sehen, wie man erstelltate APIs in der SailsJS-App. Überprüfen Sie die folgenden Schritte zum Erstellenate eine API in der SailsJS-App.

1. API-Endpunkt zum hinzufügen config/routes.js Datei.
2. Create Aktion für den API-Endpunkt mithilfe des Befehls sails generate action sample --no-actions2.
3. Fügen Sie Ihren API-Code in die Aktionsdatei ein, die geneated in Schritt 2.

Routen

Der routes.js Die Datei sieht ähnlich wie der folgende Code aus, nachdem Sie API-Endpunkte hinzugefügt haben.

module.exports.routes = {
  "GET /": { action: "home" },
  "GET /json": { action: "json" },
  "GET /path-params/:name": { action: "path-params" },
  "GET /query-params": { action: "query-params" },
  "POST /post": { action: "post" },
};

Jeder API-Endpunkt zeigt auf eine Aktion. Wir müssen generierenate diese Aktionsdateien mit dem im S. genannten Befehlrevious Abschnitt. Lasst uns generierenate alle Aktionsdateien für die oben genannten Endpunkte.

Aktionen

Wir haben 5 Endpunkte hinzugefügt. Lassen Sie uns den jeweiligen Code für jeden Endpunkt überprüfen.

home.js

module.exports = async function home(req, res) {
  return res.send("Hello, World!");
};

json.js

module.exports = async function json(req, res) {
  return res.json({ greetings: "Hello, World!" });
};

path-params.js

module.exports = async function pathParams(req, res) {
  const { name } = req.params;
  return res.json({ greetings: `Hello, ${name}!` });
};

post.js

module.exports = async function post(req, res) {
  const { name } = req.body;
  console.log(req.body);
  return res.json({ greetings: `Hello, ${name ? name : 'Geekflare'}!` });
};

query-params.js

module.exports = async function queryParams(req, res) {
  const { name } = req.query;
  return res.json({ greetins: `Hello, ${name ? name : "Geekflare"}!` });
};

Es gibt eine andere Möglichkeit, Aktionen zu schreiben. Lesen Sie die Dokumentation, um mehr über das Framework zu erfahren.

Hapi

Hapi Rahmen war initially Entwickelt, um die Nachteile des ExpressJS-Frameworks zu überwinden. Walmart erkannte diese Nachteile, als sie sich auf ein Ereignis mit hohem Verkehrsaufkommen vorbereiteten.

Hapi.JS ist ein robustes Framework zum Erstellen von Diensten und APIs. Es ist bekannt für seine Stabilität und Zuverlässigkeit.

Projektaufbau

Lass uns Create ein Projekt, um die Grundlagen zu berühren Hapi.JS. Wir können das Hapi-Projekt ähnlich wie ein normales NodeJS-Projekt einrichten. Führen Sie die folgenden Befehle aus, um das Projekt einzurichten.

cd your_project_floder_path
npm init -y                    ## to init node project
npm install @hapi/hapi         ## installing core package to work with Hapi.JS
npm install nodemon            ## to run our application

Erstellen index.js Datei im Projekt. Fügen Sie das Startskript in der package.json Datei mit nodemon index.js Befehl.

HapiJS-App

Überprüfen Sie unten die grundlegenden APIs in Hapi.

const hapi = require("@hapi/hapi");

const app = async () => {
  // initializing the hapi server
  const server = hapi.server({
    port: 3000,
    host: "localhost",
  });

  server.route({
    method: "GET",
    path: "/",
    handler: (request, h) => {
      return "Hello, World!";
    },
  });

  server.route({
    method: "GET",
    path: "/json",
    handler: (request, h) => {
      return { greetings: "Hello, World!" };
    },
  });

  server.route({
    method: "GET",
    path: "/path-params/{name}",
    handler: (request, h) => {
      const name = request.params.name;
      return { greetings: `Hello, ${name}!` };
    },
  });

  server.route({
    method: "GET",
    path: "/query-params",
    handler: (request, h) => {
      const name = request.query.name;
      return { greetings: `Hello, ${name ? name : "Geekflare"}!` };
    },
  });

  server.route({
    method: "POST",
    path: "/post",
    handler: (request, h) => {
      const data = request.payload;
      console.log(data);
      return { greetings: `Hello, ${data.name ? data.name : "Geekflare"}!` };
    },
  });

  // starting the server
  await server.start();
  console.log(`App is running on ${server.info.uri}`);
};

app();

Wir haben verschiedene APIs hinzugefügt, um die Grundlagen von Hapi zu erlernen. Sie können alle Routen in eine separate verschiebenate Datei, um sie sauber zu machen. Gehe zum Dokumentation um mehr über Hapi zu erfahren.

Gesamt

Gesamt ist serverseitig platFormular, das ein gebrauchsfertiges Formular bereitstellt platFormular zum Erstellen von Echtzeit-, Chatbot-, IoT-, E-Commerce- und REST-Anwendungen. Außerdem können Premium-Benutzer ihre Anwendungen auf der veröffentlichen platFormular zur Nutzung durch andere.

Die Verwendung von Total.JS als Basis für Ihre Entwicklung bietet folgende Vorteile:

• Rapid Prototyping-Fähigkeiten
• Kommt viele vorgefertigte Komponenten, die eine schnellere Entwicklung ermöglichen
• Enthält eine Bibliothek mit Anwendungen, die einfach abgerufen und integriert werden könnenated in Ihre Bewerbung ein
• Modulbasiertes Framework, das die Vereinfachung der Arbeitsverteilung in einem großen Projekt ermöglicht
• Community-Chat
• Konsequent gepflegt ein Speicher von Anwendungen, die einsatzbereit sind

LoopBack

LoopBack ist ein API-Entwicklungsframework, das integriert istated mit API-Explorer. Der API-Explorer kann über leicht verfügbare LoopbackJS-SDKs problemlos mit clientseitigen Anwendungen verbunden werden. Die SDKs sind für Android, AngularJS, Angular 2+ sowie iOS-Anwendungen verfügbar.

LoopBack wird vertraut von GoDaddy, Symantec, Bank of America und viele mehr. Auf ihrer Website finden Sie viele Beispiele zum Erstellenate Backend-API, sichere REST-API, persistente Daten usw. Und ja, es verfügt über einen integrierten API-Explorer.

Projektaufbau

Lassen Sie uns das Loopback-Projekt einrichten und sehen, wie es erstellt wirdate grundlegende APIs damit.

Führen Sie den folgenden Befehl aus, um die Loopback-CLI zu installieren.

npm install -g @loopback/cli

Führen Sie den folgenden Befehl aus, um die Projekteinrichtung zu starten.

lb4 app

Beantworten Sie alle Fragen im Terminal. Sie können die Fragen nach Ihren Wünschen beantworten.

Öffnen Sie die App in Ihrem bevorzugten Code-Editor und führen Sie sie mit aus npm Befehl starten. Gehe zu http://localhost/ um die Loopback-App zu überprüfen.

LoopBack-App

Wenn Sie nach innen schauen src Ordner, es wird eine controllers. An dieser Stelle fügen wir Controller hinzu, die unsere APIs enthalten.

Wir müssen den folgenden Befehl zum Erstellen verwendenate Controller im Loopback.

lb4 controller

Sehen Sie sich unten die verschiedenen APIs an. Wir haben dem Controller mehrere APIs hinzugefügt.

import {get, param, post, requestBody} from '@loopback/rest';

interface Response {
  greetings: string;
}

export class GeekflareController {
  @get('/hello')
  home(): string {
    return 'Hello, World!';
  }

  @get('/json')
  json(): Response {
    return {greetings: 'Hello, World!'};
  }

  // accessing path param using @param decorator
  @get('/path-params/{name}')
  pathParams(@param.path.string('name') name: string): Response {
    return {greetings: `Hello, ${name}!`};
  }

  @get('/query-params')
  queryParams(@param.query.string('name') name: string): Response {
    return {greetings: `Hello, ${name ? name : "Geekflare"}!`};
  }

  // accessing path param using @requestBody decorator
  @post('/post')
  postMethod(@requestBody() data: any): Response {
    console.log(data);
    const {name} = data;
    return {greetings: `Hello, ${name ? name : 'Geekflare'}!`};
  }
}

Wir haben gesehen, wie man erstelltate APIs und Zugriff auf verschiedene Dinge, die für die Grundlagen von REST-APIs erforderlich sind. Das LoopBack-Framework bietet noch viel mehr. Ihre Dokumentation ist der richtige Ort, um tief in das Framework einzutauchen.

Meteor

Meteor ist eine vollständige Webentwicklung und API creatioEine Lösung mit einem unglaublichen Design im Kern. Meteor ist ein Framework, das für die schnelle Anwendungserstellung verwendet wird. Mit der Meteor-Architektur können Sie Code sowohl im Frontend als auch im Backend ausführen, ohne den Code neu schreiben zu müssen.

Dies verbessert die Entwicklungsgeschwindigkeit erheblich. Wesentliche Vorteile der Verwendung von Meteor sind:

• Framework für die Entwicklung hybrider Anwendungen
• Mit einer einzigen Codebasis können Sie eine Desktop-App, eine Web-App sowie eine mobile Anwendung erstellen
• Es wird mit einem eng gekoppelten Frontend geliefert, mit dem Sie Ihren Code-Footprint reduzieren können
• Sehr erweiterbar mit einer Reihe von Plugins
• Unterstützt verschiedene Frontend-Systemeplating-Frameworks
• Unterstützt Hot-Code-Push, wodurch die Notwendigkeit für die Aktualisierung mobiler Anwendungen entfällt

Restifizieren

Erstellen Sie eine produktionsreife Semantikally Korrekter RESTfull-Webdienst mit Restifizieren.

Es werden nur relevante Express JS-Module verwendet, die die Codebasis im Vergleich zu anderen Frameworks leichter machen. Vertrauen Sie Netflix, Pinterest, Joyent usw. - Sie werden nichts falsch machen, wenn Sie sie auswählen.

Projektaufbau

Lassen Sie uns das Restify-Projekt einrichten und sehen, wie grundlegende APIs geschrieben werden. Führen Sie die folgenden Befehle aus, um zu erstellenate ein neues Restify-Projekt.

Bevor Sie fortfahren, stellen Sie sicher, dass Sie einen Knoten mit Version 11 haben. Restify unterstützt das l nichtatest-Versionen von node.

cd your_project_folder
npm init -y             ## initializing node project
npm i restify           ## installing core package
npm i restify-plugins   ## to add some parsing middlewares to our application
npm i nodemon           ## to run our application

Nachdem Sie alle Pakete installiert haben, fügen Sie das Startskript in die package.json Datei mit nodemon index.js Befehl. Vergessen Sie nicht hinzuzufügen index.js Datei zum Projekt hinzufügen.

Restify-App

Lass uns Create einige APIs, um die Grundlagen zu erlernen.

const restify = require("restify");
const restifyPlugins = require("restify-plugins");

function home(req, res, next) {
  res.send("Hello, World!");
  next();
}

function json(req, res, next) {
  res.json({ greetings: "Hello, World!" }); // you can also use req.send(JSONData)
  next();
}

function pathParams(req, res, next) {
  const { name } = req.params;
  res.json({ greetings: `Hello, ${name}!` });
  next();
}

function queryParams(req, res, next) {
  const { name } = req.query;
  res.json({ greetings: `Hello, ${name ? name : "Geekflare"}!` });
  next();
}

function post(req, res, next) {
  const data = req.body;
  console.log(data);
  res.json({ greetings: `Hello, ${data.name ? data.name : "Geekflare"}!` });
  next();
}

// creating restify server
const server = restify.createServer();

// adding parsing middlewares
server.use(restifyPlugins.jsonBodyParser({ mapParams: true }));
server.use(restifyPlugins.queryParser({ mapParams: true }));

// adding routes
server.get("/", home);
server.get("/json", json);
server.get("/path-params/:name", pathParams);
server.get("/query-params", queryParams);
server.post("/post", post);

// starting the app
server.listen(3000, function () {
  console.log(`App is running at ${server.url}`);
});

Schauen Sie sich die restify an Dokumentation um mehr über den Rahmen zu erfahren.

Koa

Koa in erster Linie leverAltert Codegeneratoren, damit Entwickler ihre Entwicklung beschleunigen können. Es wird mit verschiedenen Middlewares und Plugins geliefert, die Sie bei der Verwaltung von Sitzungen, Anfragen, Cookies und Datentransaktionen unterstützen.

Das gleiche Team hinter Express entwirft Koa. Es funktioniert mit Nodejs 7.6+ und hat viel Beispiele damit Sie anfangen können.

Projektaufbau

Lassen Sie uns das koa-Projekt mit den folgenden Befehlen einrichten

cd your_project_folder
npm init -y            ## initializing the node project
npm i koa              ## core koa package
npm i koa-route        ## route package for handling API routes
npm i koa-bodyparser   ## parser package to parse the request body
npm i nodemon          ## to run 

Koa-App

Das Erstellen von APIs mit Koa ist unkompliziert, ähnlich wie bei anderen Frameworks, die wir zuvor gesehen haben. Schauen wir uns den Code an.

const koa = require("koa");
const route = require("koa-route");
const bodyParser = require("koa-bodyparser");

const app = new koa();

const home = async (ctx) => {
  ctx.body = "Hello, World!";
};

const json = async (ctx) => {
  ctx.body = { greetings: "Hello, World!" };
};

// all path parameters will will pased to the function with the same name that's provided in the route
const pathParams = async (ctx, name) => {
  ctx.body = { greetings: `Hello, ${name}!` };
};

const queryParams = async (ctx) => {
  const name = ctx.query.name;
  ctx.body = { greetings: `Hello, ${name ? name : "Geekflare"}!` };
};

const post = async (ctx) => {
  const {
    body: { name },
  } = ctx.request;
  ctx.body = { greetings: `Hello, ${name ? name : "Geekflare"}!` };
};

app.use(bodyParser());

app.use(route.get("/", home));
app.use(route.get("/json", json));
app.use(route.get("/path-params/:name", pathParams));
app.use(route.get("/query-params", queryParams));
app.use(route.post("/post", post));

app.listen(3000);

Sie können mit der Erkundung beginnen Koa-Dokumente . Kontaktieren Sie uns jetzt!

Nest

Nest ist ein Framework zum Erstellen serverseitiger Knotenanwendungen. Es verwendet Express unter der Haube für den HTTP-Server. Und wir können es auch mit Fastify konfigurieren.

Es unterstützt TypeScript und basiert auf OOP-Konzepten, funktionaler Programmierung und funktionaler reaktiver Programmierung. Lass uns Create ein Projekt darin und sehen Sie, wie man grundlegende APIs schreibt.

Projektaufbau

Führen Sie die folgenden Befehle aus, um zu erstellenate Projekt.

npm i -g @nestjs/cli                ## installing nest CLI globally
nest new your_project_name          ## creating a project with nest CLI

Nest-App

Im Anwendungs-src-Ordner befinden sich einige Dateien. Das app.controller.ts ist die Datei, in die wir jetzt APIs einbinden werden. Denken Sie daran, dass wir nur sehen werden, wie grundlegende Anwendungen geschrieben werden.

Werfen wir einen Blick auf verschiedene grundlegende APIs, die unterschiedliche Konzepte von APIs zeigen.

import { Body, Controller, Get, Param, Post, Query } from '@nestjs/common';
import { AppService } from './app.service';

export interface IResponse {
  greetings: string;
}

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get('/')
  home(): string {
    return 'Hello, World!';
  }

  @Get('/json')
  json(): IResponse {
    return { greetings: 'Hello, World!' };
  }

  @Get('/path-params/:name')
  pathParams(@Param() params): IResponse {
    const { name } = params;
    return { greetings: `Hello, ${name}!` };
  }

  @Get('/query-params')
  queryParams(@Query() params): IResponse {
    const { name } = params;
    return { greetings: `Hello, ${name ? name : 'Geekflare'}!` };
  }

  @Post('/post')
  post(@Body() body): IResponse {
    const { name } = body;
    return { greetings: `Hello, ${name ? name : 'Geekflare'}!` };
  }
}

Führen Sie die Anwendung aus und überprüfen Sie alle APIs. Sie können diese APIs auch in die Dienstschicht schreiben und im Controller darauf zugreifen.

Gehen Sie zum Dokumente des Nestes um mehr zu lernen und das Framework zu verstehen.

Fasten

Fasten ist ein weiteres Framework in der NodeJS-Framework-Familie. Wie der Name schon sagt, behauptet es, eines der schnellsten NodeJS-Frameworks auf dem Markt zu sein. Lassen Sie uns einen Teil des Kerns des Frameworks sehen.

• Schnell und hochleistungsfähig. Es behauptet, dass es das kann process Bis zu 30 Anfragen pro Sekunde, basierend auf der Codekomplexität.
• TypeScript-freundlich.
• Entwicklerfreundlich mit ausdrucksstarker API für schnelle Entwicklung.
• Es kommt mit einem eingebauten Logger. Es verwendet Pino (NodeJS-Logger).

Projektaufbau

Lassen Sie uns das Fastify-Projekt einrichten, um die Grundlagen der API-Entwicklung zu lernen. Wenn Sie die folgenden Befehle ausführen, wird ein neues Fastify-Projekt für Sie eingerichtet.

npm install --global fastify-cli   ## installing fastify CLI
fastify generate project_name      ## creating project with fastify CLI

Fastify-App

Fasitfy CLI-Generierungated Projekt für uns. Wir machen uns derzeit Sorgen, nur APIs zu schreiben. Um neue APIs zu schreiben, öffnen Sie routes/root.js Datei. Fügen Sie der Datei die folgenden APIs hinzu.

module.exports = async function (fastify, opts) {
  fastify.get("/", async function (request, reply) {
    return "Hello, World!";
  });

  fastify.get("/json", async function (request, reply) {
    return { greetings: "Hello, World!" };
  });

  fastify.get("/path-params/:name", async function (request, reply) {
    const { name } = request.params;
    return { greetings: `Hello, ${name}!` };
  });

  fastify.get("/query-params", async function (request, reply) {
    const { name } = request.query;
    return { greetings: `Hello, ${name ? name : "Geekflare"}!` };
  });

  fastify.post("/post", async function (request, reply) {
    const { name } = request.body;
    return { greetings: `Hello, ${name ? name : "Geekflare"}!` };
  });
};

Starten Sie die Anwendung und testen Sie alle APIs. Dies sind die Grundlagen zum Schreiben der APIs. Gehen Sie zum Fastify-Dokumente um mehr über den Rahmen zu erfahren.

tinyhttp

tinyhttp ist ein leichtes und Express-ähnliches JS-Framework. Es wird mit einem integrierten Logger, JWT und CORS-Middleware geliefert. Lassen Sie uns ein kleines Projekt einrichten und die Grundlagen lernen.

Projektaufbau

Führen Sie die folgenden Befehle aus, um das tinyhttp-Projekt einzurichten.

cd you_project_folder
npm init -y
npm i @tinyhttp/app     ## core tinyhttp package
npm i milliparsec       ## to parse the request data and add it to request object to body key
npm i nodemon           ## to run our application which will restart automatically whenever files changes

Wir müssen noch etwas tun. Hinzufügen type Schlüssel mit Wert module zu den package.json Datei. Wir fügen es hinzu, weil tinyhttp es nicht unterstützt requiremüssen wir verwenden import statestatt.

tinyhttp-App

Die API von tinyhttp sieht der Express-App fast ähnlich. Lassen Sie uns die verschiedenen APIs darin überprüfen.

import { App } from "@tinyhttp/app";
import { json } from "milliparsec";

const port = 3000;
const app = new App();

app.use(json());

// req: we will use this paramter to get API request details
// res: we will use
app.get("/", (req, res) => {
  res.send("Hello, World!");
});

app.get("/json", (req, res) => {
  res.json({ greetings: "Hello, World!" }); // you can also use res.send({})
});

app.get("/path-params/:name", (req, res) => {
  // all the path params will present in req.params object
  const { name } = req.params;
  res.json({ greetings: `Hello, ${name}!` });
});

app.get("/query-params", (req, res) => {
  // all the query params will present in req.query object
  const { name } = req.query;
  res.json({ greetings: `Hello, ${name ? name : "Geekflare"}!` });
});

app.post("/post", (req, res) => {
  // data will present in req.body
  const { name } = req.body;
  res.json({ greetings: `Hello, ${name ? name : "Geekflare"}!` });
});

app.listen(port, () => {
  console.log(`App running on port ${port}`);
});

Sie können mehr über das Framework in ihrer erfahren winzige Dokumente.

SocketIO

SocketIO ist ein Web-Socket-Framework, das für mehrere Programmiersprachen verfügbar ist.

In NodeJS ermöglicht SocketIO das Erstellen von Web-Socket-Anwendungen wie Chatbots, Score-Tickern, Dashboard-APIs und anderen. SocketIO hat erhebliche Vorteile gegenüber der herkömmlichen NodeJS-Web-Socket-Bibliothek.

• Unterstützung für benutzerdefiniertes URL-Routing für Web-Sockets
• Automatische Generierungated Bezeichner für jeden Socket
• Einfache Verwaltung von Socket-Räumen zur Übertragung von Daten
• Einfachere Integration mit Express JS
• Unterstützt Clustering mit Redis
• Unterstützung für die Socket-Authentifizierung mit einem zusätzlichen Plugin - socketio-auth
• Eingebautes Fallback-HTTP-Protokoll-basiertes Handling für einen Server, der HTTP 1.1 nicht unterstützt

Schlussfolgerung

Die Leute verwenden NodeJS in großem Umfang in ihren Projekten. Daher haben wir verschiedene Frameworks zur Auswahl. Wenn Sie die Frameworks sehen, haben die meisten ähnliche APIs. Wenn Sie also über gute Kenntnisse von NodeJS und einem beliebigen Framework verfügen, ist das mehr als genug, um mit einem anderen NodeJS-Framework zu beginnen.

Die Entwicklung von Anwendungen ist aufgrund dieser Frameworks nicht einfach. Nutzen Sie die Frameworks, die Ihnen gefallen, und erkunden Sie weiterhin andere.

Sie können auch einige erkunden Node.js-Pakete um ihren Code effizient zu debuggen, zu schreiben und zu verwalten.

Viel Spaß beim Codieren 🙂