It is recommended to share 18 web frameworks and tools worth knowing in Node.js

This article is a sharing article about Web frameworks and tools. In this article, I will summarize and share 18 of my most recommended Node Web frameworks and tools. I hope it will be helpful to everyone!

Node.js is an underlying platform. In order to make the work of developers simple and efficient, the community has created more than thousands of libraries.

As time goes by, there are many excellent libraries for everyone to choose from. The following is an incomplete selection list:

• Express: Provides a very simple way to create a Web server, is powerful enough and lightweight enough, focusing on the core functions of the server.

  // 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: It is built by the same team behind Express, provides a simpler and smaller library, and supports ES NEXT async await syntax.

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

• NestJS: A progressive Node.js framework based on TypeScript for building efficient, reliable, and scalable enterprise-grade Server-side application.

  // 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: Build a better enterprise-level server-side framework using Node.js and Koa.

  // 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: React The framework provides a good development experience and provides all the functions of a production environment : Server-side rendering, support for TypeScript, route pre-fetching, etc.

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

• #Remix: Remix is ​​a full-stack web framework that includes both front-end and back-end for building modern web applications out of the box. end.

  // 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: A static site generator based on React and GraphQL, with a very rich plug-in and ecosystem.

  // 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: A framework for building web application services, allowing developers to focus on writing reusable application logic, Instead of spending time building infrastructure.

  // 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: A web framework that is highly focused on providing the best development experience with minimal overhead and a powerful plug-in architecture . Fastify is one of the fastest Node.js web frameworks.

  // 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: A full-featured framework based on TypeScript that pays close attention to developer experience and stability. Adonis is one of the fastest Node.js web frameworks.

  // 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 is a lightweight web framework for creating real-time applications and REST APIs using JavaScript or TypeScript . Build prototypes in minutes and enterprise-grade applications in days.

  // 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: Makes it easier to build modern applications with complex integrations.

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

• Meteor: A very powerful full-stack framework that provides an isomorphic way to build applications using JavaScript, on the client side Share code with the server. Previously offering a full set of ready-made tools, it now integrates with front-end libraries React, Vue and Angular. Can also be used to create mobile applications.

• Micro: It provides a very lightweight server to create asynchronous HTTP microservices.

  // 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 教程！

The above is the detailed content of It is recommended to share 18 web frameworks and tools worth knowing in Node.js. For more information, please follow other related articles on the PHP Chinese website!