NodeJS ist schon seit einiger Zeit in der Branche tätig. Aufgrund seiner asynchronen Natur und der Unterstützung der Chrome V8-Engine ist es weit verbreitet.
NodeJS bietet eine Reihe von Frameworks, die mit verschiedenen Bibliotheken, Tools und Vorlagen geliefert werden, um Entwicklern zu 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 Plattform 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 einen einfach zu bedienenden Projektgenerator erstellt. Dieser Generator kann ein Vorlagenprojekt erstellen, um Sie schneller auf die Beine zu 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 den Knoteninstallationsprozess.
- Erstellen Sie einen Projektordner.
- Öffnen Sie es im Terminal.
- Installieren Sie das
express,body-parser,cookie-parser,corsundnodemon. - Fügen Sie dem Projekt die Datei index.js hinzu.
- Fügen Sie das Startskript der Anwendung in der
packages.jsonDatei mitnodemon index.jsBefehl.
Angebote
- express: Dies ist das Kernpaket unserer Anwendung, das uns beim Erstellen von APIs hilft.
- Body-Parser: Dies ist eine Middleware, die die eingehenden Daten von der API parst und sie der hinzufügt
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.
Sails
Segel ist ein vollwertiges MVC-Architektur-Framework. Es verwendet ExpressJS und SocketIO im Kern. Sails.js wurde bekannt für seine Unternehmensarchitektur, die eine schnellere Integration in die Datenbank mithilfe von Modellobjekten ermöglichte.
Einige der Vorteile sind:
- Sails.JS wird mit einem Projekt geliefert, um sofort eine Projektvorlage zu generieren
- 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 zur Autorisierung, Authentifizierung und Vorverarbeitung
- Mit integrierter Unterstützung für AWS S3 und GridFS
Projektaufbau
So erstellen Sie ein sailsjs Projekt benötigen wir ein npm-Paket namens sail. Lassen Sie es uns mit dem folgenden Befehl global installieren.
npm install sails -gWechseln Sie in das Verzeichnis, in dem Sie Ihr Projekt erstellen möchten. Führen Sie nun den folgenden Befehl zum Erstellen aus sailsjs App.
sails new basic-appEs erscheint eine Eingabeaufforderung zur Auswahl der Vorlage. 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 Browser, um die Anwendung anzuzeigen.
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
Sehen wir uns an, wie APIs in der sailsjs-App erstellt werden. Überprüfen Sie die folgenden Schritte, um eine API in der sailsjs-App zu erstellen.
- API-Endpunkt zum hinzufügen
config/routes.jsDatei. - Erstellen Sie mithilfe des Befehls eine Aktion für den API-Endpunkt
sails generate action sample --no-actions2. - Fügen Sie Ihren API-Code in die Aktionsdatei ein, die in Schritt 2 generiert wird.
Routen
Die 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 diese Aktionsdateien mit dem im vorherigen Abschnitt erwähnten Befehl generieren. Lassen Sie uns alle Aktionsdateien für die oben genannten Endpunkte generieren.
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 Das Framework wurde ursprünglich entwickelt, um die Nachteile des ExpressJS-Frameworks zu überwinden. Walmart bemerkte diese Nachteile, als sie sich auf ein starkes Verkehrsereignis 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
Lassen Sie uns ein Projekt erstellen, 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 applicationErstellen 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 Datei verschieben, um sie sauber zu machen. Gehen Sie zum Dokumentation um mehr über Hapi zu erfahren.
Total
Gesamt ist eine serverseitige Plattform, die eine gebrauchsfertige Plattform zum Erstellen von Echtzeit-, Chatbot-, IoT-, E-Commerce- und REST-Anwendungen bietet. Es ermöglicht Premium-Benutzern auch, ihre Anwendungen auf der Plattform zu veröffentlichen, damit andere sie verwenden können.
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 in Ihre Anwendung integriert werden können
- 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 in den API-Explorer integriert ist. Der API-Explorer kann mithilfe leicht verfügbarer LoopbackJS-SDKs problemlos mit clientseitigen Anwendungen verbunden werden. Die SDKs sind für Android-, AngularJS-, Angular 2+ - und iOS-Anwendungen verfügbar.
LoopBack wird vertraut von Los Papa, Symantec, Bank of America und viele mehr. Auf ihrer Website finden Sie viele Beispiele zum Erstellen von Backend-APIs, sicheren REST-APIs, persistenten Daten usw. Und ja, es hat einen integrierten API-Explorer.
Projektaufbau
Lassen Sie uns das Loopback-Projekt einrichten und sehen, wie Sie damit grundlegende APIs erstellen.
Führen Sie den folgenden Befehl aus, um die Loopback-CLI zu installieren.
npm install -g @loopback/cliFühren Sie den folgenden Befehl aus, um die Projekteinrichtung zu starten.
lb4 appBeantworten 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 verwenden, um Controller in Loopback zu erstellen.
lb4 controllerSehen 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 APIs erstellt und auf verschiedene Dinge zugreift, die für die Grundlagen von REST-APIs erforderlich sind. Es gibt noch viel mehr im LoopBack-Framework. Ihr Dokumentation ist der richtige Ort, um tief in das Framework einzutauchen.
Meteor
Meteor ist eine komplette Webentwicklungs- und API-Erstellungslösung mit einem unglaublichen Design im Kern. Meteor ist ein Framework, das für die schnelle Erstellung von Anwendungen 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-Template-Frameworks
- Unterstützt Hot-Code-Push, wodurch die Notwendigkeit für die Aktualisierung mobiler Anwendungen entfällt
Restify
Erstellen Sie mit einen produktionsbereiten semantisch korrekten RESTfull-Webdienst 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 ein neues Restify-Projekt zu erstellen.
Bevor Sie fortfahren, stellen Sie sicher, dass Sie Knoten mit Version 11 haben. Restify unterstützt nicht die neuesten Versionen von Knoten.
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 applicationNachdem 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.
Restify-App
Lassen Sie uns einige APIs erstellen, um die Grundlagen zu lernen.
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 nutzt in erster Linie Codegeneratoren, damit Entwickler ihre Entwicklung beschleunigen können. Es enthält verschiedene Middlewares und Plugins, mit denen Sie Sitzungen, Anfragen, Cookies sowie Datentransaktionen verwalten können.
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. Lassen Sie uns darin ein Projekt erstellen und sehen, wie grundlegende APIs geschrieben werden.
Projektaufbau
Führen Sie die folgenden Befehle aus, um das Projekt zu erstellen.
npm i -g @nestjs/cli ## installing nest CLI globally
nest new your_project_name ## creating a project with nest CLINest-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.
Fastify
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 leistungsstark. Es behauptet, dass es basierend auf der Codekomplexität bis zu 30 Anfragen pro Sekunde verarbeiten kann.
- 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 CLIFastify-App
Fasitfy CLI generiertes Projekt für uns. Wir sind derzeit besorgt darüber, 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 docs um mehr über den Rahmen zu erfahren.
tinyhttp
winzighttp 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 changesWir 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 Aussagen statt.
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
- Automatisch generierte Kennungen 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
Fazit
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 🙂
