Es wird empfohlen, 18 wissenswerte Web-Frameworks und Tools in Node.js zu teilen

Dieser Artikel ist ein Artikel über Web-Frameworks und -Tools. In diesem Artikel werde ich 18 meiner am häufigsten empfohlenen Node-Web-Frameworks und -Tools zusammenfassen und teilen.

Node.js ist eine zugrunde liegende Plattform. Um die Arbeit der Entwickler einfach und effizient zu gestalten, hat die Community mehr als Tausende von Bibliotheken erstellt.

Mit der Zeit gibt es viele hervorragende Bibliotheken, aus denen jeder wählen kann. Die folgende Liste ist unvollständig:

• Express: Bietet eine sehr einfache Möglichkeit, einen Webserver zu erstellen, und ist leistungsstark genug . Leicht genug, um sich auf die Kernfunktionen des Servers zu konzentrieren.

  // server.js
  const express = require('express')
  const app = express()
  const port = 3000
  
  app.get('/', (req, res) => {
    res.send('Hello World!')
  })
  
  app.listen(port, () => {
    console.log(`Example app listening on port ${port}`)
  })

• koa: Es wurde vom gleichen Team wie Express erstellt, bietet eine einfachere und kleinere Bibliothek und unterstützt die asynchrone Wait-Syntax von ES NEXT.

  // server.js
  const Koa = require('koa');
  const app = new Koa();
  
  app.use(async ctx => {
    ctx.body = 'Hello World';
  });
  
  app.listen(3000);

• NestJS: Ein progressives Node.js-Framework basierend auf TypeScript zum Erstellen effizienter, zuverlässiger und skalierbarer serverseitiger Anwendungen der Unternehmensklasse.

  // app.controller.ts
  import { Get, Controller, Render } from '@nestjs/common';
  import { AppService } from './app.service';
  
  @Controller()
  export class AppController {
      constructor(private readonly appService: AppService) {}
  
      @Get()
      @Render('index')
      render() {
          const message = this.appService.getHello();
          return { message };
      }
  }

• Egg.js: Erstellen Sie mit Node.js und Koa ein besseres serverseitiges Framework auf Unternehmensebene.

  // app/controller/home.js
  const Controller = require('egg').Controller;
  
  class HomeController extends Controller {
    async index() {
      this.ctx.body = 'Hello world';
    }
  }
  
  module.exports = HomeController;

• Next.js: Das React-Framework bietet eine gute Entwicklungserfahrung und stellt alle Funktionen einer Produktionsumgebung bereit: serverseitiges Rendering, Unterstützung für TypeScript, Routen-Prefetching und mehr.

  // first-post.js
  export default function FirstPost() {
    return <h1>First Post</h1>
  }

• Remix: Remix ist ein Full-Stack-Webframework, das Front-End und Back-End für die sofortige Erstellung moderner Webanwendungen umfasst.

  // index.tsx
  export async function loader({ request }) {
    return getProjects();
  }
  
  export async function action({ request }) {
    const form = await request.formData();
    return createProject({ title: form.get("title") });
  }
  
  export default function Projects() {
    const projects = useLoaderData();
    const { state } = useTransition();
    const busy = state === "submitting";
  
    return (
      <div>
        {projects.map((project) => (
          <Link to={project.slug}>{project.title}</Link>
        ))}
  
        <Form method="post">
          <input name="title" />
          <button type="submit" disabled={busy}>
            {busy ? "Creating..." : "Create New Project"}
          </button>
        </Form>
      </div>
    );
  }

• Gatsby: Ein statischer Site-Generator basierend auf React und GraphQL, mit einem sehr umfangreichen Plug-in und Ökosystem.

  // src/pages/index.js
  import * as React from 'react'
  
  const IndexPage = () => {
    return (
      <main>
        <title>Home Page</title>
        <h1>Welcome to my Gatsby site!</h1>
        <p>I&#39;m making this by following the Gatsby Tutorial.</p>
      </main>
    )
  }
  
  export default IndexPage

• hapi: Ein Framework zum Erstellen von Webanwendungsdiensten, das es Entwicklern ermöglicht, sich auf das Schreiben wiederverwendbarer Anwendungslogik zu konzentrieren, anstatt Zeit mit dem Aufbau der Infrastruktur zu verbringen.

  // index.js
  
  'use strict';
  
  const Hapi = require('@hapi/hapi');
  
  const init = async () => {
  
      const server = Hapi.server({
          port: 3000,
          host: 'localhost'
      });
  
      server.route({
          method: 'GET',
          path: '/',
          handler: (request, h) => {
              return 'Hello World!';
          }
      });
  
      await server.start();
      console.log('Server running on %s', server.info.uri);
  };
  
  process.on('unhandledRejection', (err) => {
      console.log(err);
      process.exit(1);
  });
  
  init();

• Fastify: Ein Web-Framework, das sich stark darauf konzentriert, das beste Entwicklungserlebnis mit minimalem Overhead und einer leistungsstarken Plug-in-Architektur zu bieten. Fastify ist eines der schnellsten Node.js-Webframeworks.

  // server.js
  const fastify = require('fastify')({ logger: true })
  
  // Declare a route
  fastify.get('/', async (request, reply) => {
    return { hello: 'world' }
  })
  
  // Run the server!
  const start = async () => {
    try {
      await fastify.listen(3000)
    } catch (err) {
      fastify.log.error(err)
      process.exit(1)
    }
  }
  start()

• AdonisJS: Ein voll funktionsfähiges Framework auf Basis von TypeScript, das großen Wert auf Entwicklererfahrung und Stabilität legt. Adonis ist eines der schnellsten Node.js-Webframeworks.

  // PostsController.js
  import Post from 'App/Models/Post'
  
  export default class PostsController {
  
    public async index () {
      return Post.all()
    }
  
    public async store ({ request }) {
      return request.body()
    }
  
  }

• FeatherJS: Feathers ist ein leichtes Webframework zum Erstellen von Echtzeitanwendungen und REST-APIs mit JavaScript oder TypeScript. Erstellen Sie Prototypen in wenigen Minuten und Anwendungen für Unternehmen in wenigen Tagen.

  // app.ts
  import feathers from '@feathersjs/feathers';
  
  interface Message {
    id?: number;
    text: string;
  }
  
  
  class MessageService {
    messages: Message[] = [];
  
    async find () {
      return this.messages;
    }
  
    async create (data: Pick<Message, &#39;text&#39;>) {
      const message: Message = {
        id: this.messages.length,
        text: data.text
      }
  
      this.messages.push(message);
  
      return message;
    }
  }
  
  const app = feathers();
  
  app.use(&#39;messages&#39;, new MessageService());
  
  app.service(&#39;messages&#39;).on(&#39;created&#39;, (message: Message) => {
    console.log(&#39;A new message has been created&#39;, message);
  });
  
  const main = async () => {
    await app.service(&#39;messages&#39;).create({
      text: &#39;Hello Feathers&#39;
    });
  
    await app.service(&#39;messages&#39;).create({
      text: &#39;Hello again&#39;
    });
  
    const messages = await app.service(&#39;messages&#39;).find();
  
    console.log(&#39;All messages&#39;, messages);
  };
  
  main();

• Loopback.io: Erleichtert die Erstellung moderner Anwendungen mit komplexen Integrationen.

  // hello.controller.ts
  import {get} from '@loopback/rest';
  export class HelloController {
    @get('/hello')
    hello(): string {
      return 'Hello world!';
    }
  }

• Meteor: Ein sehr leistungsstarkes Full-Stack-Framework, das einen isomorphen Ansatz zum Erstellen von Anwendungen mithilfe von JavaScript bietet und Code auf dem Client und dem Server teilt. Bisher bot es einen vollständigen Satz vorgefertigter Tools und lässt sich jetzt in die Front-End-Bibliotheken React, Vue und Angular integrieren. Kann auch zur Erstellung mobiler Anwendungen verwendet werden.

• Micro: Es stellt einen sehr leichten Server zum Erstellen asynchroner HTTP-Mikrodienste bereit.

  // index.js
  const https = require('https');
  const {run, send} = require('micro');
  
  const {key, cert, passphrase} = require('openssl-self-signed-certificate');
  
  const PORT = process.env.PORT || 3443;
  
  const options = {key, cert, passphrase};
  
  const microHttps = fn => https.createServer(options, (req, res) => run(req, res, fn));
  
  const server = microHttps(async (req, res) => {
      send(res, 200, {encrypted: req.client.encrypted});
  });
  
  server.listen(PORT);
  console.log(`Listening on https://localhost:${PORT}`);

• Nx: 使用NestJS、Express、React、Angular等进行全栈monorepo开发的工具包，Nx有助于将您的开发从一个团队构建一个应用程序扩展到多个团队协作开发多个应用程序！

• Sapper: Sapper是一个用于构建各种规模的Web应用程序框架，具有出色的开发体验和灵活的基于文件系统的路由，提供SSR等等。

• Socket.io: 用于构建实时网络应用程序的WebSocket框架。

  // index.js
  const express = require('express');
  const app = express();
  const http = require('http');
  const server = http.createServer(app);
  const { Server } = require("socket.io");
  const io = new Server(server);
  
  app.get('/', (req, res) => {
    res.sendFile(__dirname + '/index.html');
  });
  
  io.on('connection', (socket) => {
    console.log('a user connected');
  });
  
  server.listen(3000, () => {
    console.log('listening on *:3000');
  });

• Strapi: Strapi是一种灵活的开源无头CMS，它让开发人员可以自由选择自己喜欢的工具和框架，同时允许编辑者轻松管理他们的内容。

以上就是我推荐的Node.js Web框架和工具，如果有更好的推荐欢迎在评论区评论。

更多node相关知识，请访问：nodejs 教程！

Das obige ist der detaillierte Inhalt vonEs wird empfohlen, 18 wissenswerte Web-Frameworks und Tools in Node.js zu teilen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!