NodeJs express 学习视频内含代码

已于 2024-04-22 09:00:33 修改
阅读量86 收藏
点赞数 2
分类专栏： NodeJs 文章标签： node.js
于 2024-04-21 23:34:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36152801/article/details/138049858
版权

nodeJs express 路由 如何使用

// 导入 Express 模块
const express = require('express');

// 创建 Express 应用程序
const app = express();

// 定义路由
// 当访问根目录时，返回 "Hello, World!"
app.get('/', (req, res) => {
  res.send('Hello, World!');
});

// 当访问 /about 路径时，返回关于信息
app.get('/about', (req, res) => {
  res.send('This is the about page.');
});

// 当访问 /contact 路径时，返回联系信息
app.get('/contact', (req, res) => {
  res.send('Contact us at example@example.com');
});

// 监听端口，启动服务器
const port = 3000;
app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

 nodejs express 路由分类和规则

在 Node.js 中使用 Express 框架进行路由分类和规则的设置是非常常见的。通过路由分类，您可以将不同类型的请求分配给不同的处理函数，这样可以更好地组织代码并提高可维护性。以下是一些常见的路由分类和规则：

  1. 基本路由规则：

    • 使用 app.METHOD(PATH, HANDLER) 方法设置路由，其中 METHOD 是 HTTP 请求方法（如 GET、POST、PUT、DELETE 等），PATH 是路由的路径，HANDLER 是请求的处理函数。
    • 可以使用通配符 * 匹配所有路径，或者 /:parameter 定义参数化路径。

模块化路由介绍(父包含子路由)

const express = require('express');
const app = express();

// 引入路由模块
const authRoutes = require('./authRoutes');
const blogRoutes = require('./blogRoutes');

// 使用路由模块
app.use('/auth', authRoutes);
app.use('/blog', blogRoutes);

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

接下来，创建 authRoutes.js 文件：

const express = require('express');
const router = express.Router();

// 认证相关路由
router.get('/login', (req, res) => {
  res.send('Login Page');
});

router.get('/register', (req, res) => {
  res.send('Register Page');
});

module.exports = router;

express 请求参数详解

在Express中，请求参数（request parameters）是通过请求URL的路径部分（path）传递的信息。Express提供了几种方式来访问这些请求参数：

  1. 路由参数（Route Parameters）： 路由参数是通过在路由路径中定义占位符来传递的。这些占位符可以在路由处理函数中通过 req.params 对象访问。例如： 
    // 路由定义
app.get('/users/:id', (req, res) => {
  console.log(req.params.id); // 访问路由参数
});

// 请求示例：GET /users/123
// 输出：123

  2. 查询参数（Query Parameters）： 查询参数是通过URL中的查询字符串（query string）传递的键值对。可以使用 req.query 对象来访问这些查询参数。例如： 
    // 路由定义
app.get('/search', (req, res) => {
  console.log(req.query.q); // 访问查询参数
});

// 请求示例：GET /search?q=nodejs
// 输出：nodejs

  3. 请求体参数（Request Body Parameters）： 请求体参数通常在POST请求中使用，客户端将数据作为请求的正文（body）发送。Express需要使用中间件（如body-parser）来解析请求体。请求体参数可以通过 req.body 对象访问。例如： 
    // 使用body-parser中间件解析请求体
const bodyParser = require('body-parser');
app.use(bodyParser.json()); // 解析JSON格式的请求体

// 路由定义
app.post('/users', (req, res) => {
  console.log(req.body.name); // 访问请求体参数
});

// POST请求示例：POST /users { "name": "John" }
// 输出：John

    这些是Express中常用的请求参数处理方式。根据你的需求，你可以选择其中一种或多种方式来接收和处理请求参数。

使用POST请求来演示如何使用请求体参数

让我们创建一个完整的Express应用，并使用POST请求来演示如何使用请求体参数。我们将创建一个简单的API，用于创建和检索用户。

首先，确保你已经安装了Express和body-parser：

npm install express body-parser

接下来，创建一个名为 app.js 的文件，编写以下代码：

const express = require('express');
const bodyParser = require('body-parser');

const app = express();
const PORT = 3000;

// 使用body-parser中间件解析JSON格式的请求体
app.use(bodyParser.json());

// 模拟用户数据存储
let users = [];

// 创建用户路由
app.post('/users', (req, res) => {
  const newUser = req.body; // 获取请求体参数
  users.push(newUser); // 将新用户添加到用户列表
  res.status(201).json(newUser); // 返回新用户信息
});

// 获取所有用户路由
app.get('/users', (req, res) => {
  res.json(users); // 返回所有用户列表
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

现在，我们已经创建了一个简单的Express应用，它包含了两个路由：

  1. POST /users：用于创建新用户。客户端可以通过发送JSON格式的请求体来提供新用户的信息。
  2. GET /users：用于获取所有用户列表。

现在，启动你的应用：

node app.js

现在你的Express应用已经在端口3000上运行了。可以使用任何HTTP客户端（如curl、Postman等）发送POST请求来创建新用户，并使用GET请求来获取所有用户列表。例如，使用curl发送POST请求来创建一个新用户：

curl -X POST -H "Content-Type: application/json" -d '{"name": "Alice", "age": 30}' http://localhost:3000/users

然后，使用curl发送GET请求来获取所有用户列表：

curl http://localhost:3000/users

你应该能够看到新创建的用户信息以JSON格式返回。这就是一个完整的例子，演示了如何在Express应用中使用请求体参数。

express 中间件

Express中间件是一个函数，可以在请求到达路由处理函数之前或之后执行。它可以执行任何任务，如修改请求对象、响应对象，执行其他函数，结束请求-响应循环等。Express中间件在应用程序级别、路由级别或特定请求级别上使用。

下面是一些常见的Express中间件的用法：

  1. 内置中间件：Express内置了一些常用的中间件，例如express.static用于提供静态文件，express.json用于解析JSON格式的请求体，express.urlencoded用于解析URL编码的请求体等。使用方法如下： 
    const express = require('express');
const app = express();

// 使用内置中间件
app.use(express.static('public')); // 提供静态文件
app.use(express.json()); // 解析JSON格式的请求体
app.use(express.urlencoded({ extended: true })); // 解析URL编码的请求体

举一个例子说明app.use(express.json()) 中间件

const express = require('express');
const app = express();

// 使用 express.json() 中间件解析JSON格式的请求体
app.use(express.json());

// POST请求路由，用于接收JSON格式的请求体
app.post('/api/user', (req, res) => {
  // 访问请求体中的JSON数据
  const userData = req.body;

  // 在控制台中打印接收到的JSON数据
  console.log('Received JSON data:', userData);

  // 假设这里有一些逻辑，例如将用户数据存储到数据库中

  // 返回响应
  res.status(200).send('User data received and processed successfully!');
});

// 启动服务器
const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

在上面的示例中，我们创建了一个POST请求路由 /api/user，用于接收JSON格式的请求体，然后我们使用 req.body 访问接收到的JSON数据。当客户端发送POST请求并附带JSON数据时，Express中间件会自动解析请求体，并将解析后的JSON数据附加到 req.body 上。

你可以使用curl或Postman等工具向这个端点发送POST请求，示例请求如下：

curl -X POST -H "Content-Type: application/json" -d '{"username": "john_doe", "email": "john@example.com"}' http://localhost:3000/api/user

服务器将会接收到这个JSON数据，并在控制台中打印出来。这个例子演示了如何使用 express.json() 中间件来处理JSON格式的请求体。

express 访问数据库MongoDb

const express = require('express');
const mongoose = require('mongoose');

const app = express();
const PORT = 3000;

// 连接到MongoDB数据库
mongoose.connect('mongodb://localhost:27017/my_database', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});
const db = mongoose.connection;

// 定义用户模型
const User = mongoose.model('User', {
  name: String,
  email: String,
});

// 创建用户路由
app.post('/users', async (req, res) => {
  try {
    // 创建新用户
    const newUser = new User({
      name: req.body.name,
      email: req.body.email,
    });

    // 将新用户保存到数据库中
    await newUser.save();

    res.status(201).json(newUser); // 返回新用户信息
  } catch (err) {
    console.error('Error creating user:', err);
    res.status(500).send('Error creating user');
  }
});

// 获取所有用户路由
app.get('/users', async (req, res) => {
  try {
    // 查询所有用户
    const users = await User.find();

    res.json(users); // 返回所有用户列表
  } catch (err) {
    console.error('Error fetching users:', err);
    res.status(500).send('Error fetching users');
  }
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

express validator 表达式校验

const express = require('express');
const { body, validationResult } = require('express-validator');

const app = express();

// 添加表单验证中间件
app.use(express.json());
app.use(express.urlencoded({ extended: false }));

// 定义路由来处理表单提交
app.post('/submit-form', [
  // 使用express-validator进行字段验证
  body('username').notEmpty().withMessage('Username is required'),
  body('email').isEmail().withMessage('Email is not valid'),
  body('password').isLength({ min: 6 }).withMessage('Password must be at least 6 characters long')
], (req, res) => {
  // 检查是否有验证错误
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }

  // 如果验证通过，处理表单提交逻辑
  const { username, email, password } = req.body;
  // 在这里执行你的逻辑，例如保存用户到数据库等
  res.send('Form submitted successfully');
});

// 启动服务器
const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

在上面的示例中，我们定义了一个POST路由 /submit-form 来处理表单提交。在路由处理函数中，我们使用express-validator中的 body() 方法来验证请求体中的各个字段。例如，我们使用 body('username').notEmpty().withMessage('Username is required') 来验证用户名字段是否为空，以及使用 body('email').isEmail().withMessage('Email is not valid') 来验证邮箱字段是否为有效的邮箱格式。你可以根据需要添加其他验证规则。

然后，我们检查是否有验证错误，如果有，我们将错误信息作为JSON格式返回给客户端，如果没有验证错误，我们执行表单提交的逻辑。

这就是一个使用express-validator进行表单字段验证的简单示例。

express 模板引擎的使用

const express = require('express');
const app = express();

// 设置模板引擎为EJS
app.set('view engine', 'ejs');

// 指定存放模板文件的目录（默认为 views 目录）
// 如果你的模板文件不在 views 目录下，可以使用 app.set('views', 'your-directory') 来指定
// app.set('views', 'views-directory');

// 路由处理
app.get('/', (req, res) => {
  // 渲染名为 index.ejs 的模板文件
  res.render('index', { title: 'Express App', message: 'Hello, World!' });
});

// 启动服务器
const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

在上面的代码中，我们设置了Express应用的模板引擎为EJS，通过 app.set('view engine', 'ejs') 来实现。然后，我们指定了存放模板文件的目录，这一步是可选的，默认情况下Express会在 views 目录下寻找模板文件。

接下来，我们定义了一个路由处理函数，当用户访问根路由 / 时，会渲染名为 index.ejs 的模板文件，并将一个包含数据的对象传递给模板。在这个例子中，我们传递了 title 和 message 两个变量给模板。

现在，创建一个名为 index.ejs 的EJS模板文件，并将其放置在你的模板文件目录下（默认为 views 目录）：

<!-- index.ejs -->

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title><%= title %></title>
</head>
<body>
  <h1><%= message %></h1>
</body>
</html>

express socket 通信

Socket.io 是一个流行的 Node.js 库，用于实现实时、双向通信的 WebSocket 应用程序。在 Express 中结合 Socket.io 使用可以实现实时通信的功能。下面是一个简单的示例，演示了如何在 Express 应用中使用 Socket.io 实现一个简单的聊天室：

首先，确保你已经安装了 Express 和 Socket.io：

npm install express socket.io

然后，创建一个名为 app.js 的文件，编写以下代码：

const express = require('express');
const http = require('http');
const socketIo = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = socketIo(server);

// 定义一个路由来提供聊天室页面
app.get('/', (req, res) => {
  res.sendFile(__dirname + '/index.html');
});

// 监听客户端的连接事件
io.on('connection', (socket) => {
  console.log('A user connected');

  // 监听客户端发送的消息
  socket.on('chat message', (msg) => {
    console.log('Message from client:', msg);

    // 将消息广播给所有客户端
    io.emit('chat message', msg);
  });

  // 监听客户端断开连接事件
  socket.on('disconnect', () => {
    console.log('A user disconnected');
  });
});

// 启动服务器
const PORT = 3000;
server.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

接下来，创建一个名为 index.html 的文件，用作客户端的界面：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Chat Room</title>
</head>
<body>
  <ul id="messages"></ul>
  <form id="form" action="">
    <input id="input" autocomplete="off" /><button>Send</button>
  </form>

  <script src="/socket.io/socket.io.js"></script>
  <script>
    const socket = io();

    const form = document.querySelector('form');
    const input = document.querySelector('#input');

    form.addEventListener('submit', (e) => {
      e.preventDefault();
      if (input.value) {
        // 发送消息给服务器
        socket.emit('chat message', input.value);
        input.value = '';
      }
    });

    // 监听服务器发送的消息
    socket.on('chat message', (msg) => {
      const item = document.createElement('li');
      item.textContent = msg;
      document.querySelector('#messages').appendChild(item);
    });
  </script>
</body>
</html>

在这个示例中，我们创建了一个 Express 应用，然后使用 Socket.io 将其升级为支持实时通信的应用。我们定义了一个简单的路由来提供聊天室页面。在服务器端，我们使用 io.on('connection') 来监听客户端的连接事件，并在客户端连接时打印一条消息。然后，我们监听客户端发送的消息事件 'chat message'，并在收到消息时打印到控制台，并使用 io.emit() 将消息广播给所有连接的客户端。最后，我们监听客户端断开连接事件，并在客户端断开连接时打印一条消息。

在客户端，我们使用 Socket.io 的客户端库来与服务器建立连接，并监听表单的提交事件，当用户发送消息时，通过 socket.emit() 发送消息给服务器。同时，我们使用 socket.on('chat message') 来监听服务器发送的消息，并将消息添加到页面上。

现在，启动你的应用并访问 http://localhost:3000，你将可以看到一个简单的聊天室页面，可以在多个浏览器窗口中进行实时聊天。

express 文件上传

在Express中处理文件上传通常需要使用一个中间件来解析multipart/form-data格式的请求体，同时还需要一个文件存储库（例如Multer）来处理文件的上传和存储。下面是一个简单的示例，演示了如何使用Multer中间件在Express应用中实现文件上传功能：

首先，确保你已经安装了Express和Multer：

npm install express multer

然后，创建一个名为 app.js 的文件，编写以下代码：

const express = require('express');
const multer  = require('multer');
const path = require('path');

const app = express();
const PORT = 3000;

// 设置文件存储目录和文件名
const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, 'uploads/'); // 文件存储在 uploads 目录中
  },
  filename: function (req, file, cb) {
    cb(null, Date.now() + '-' + file.originalname); // 文件名为时间戳 + 原始文件名
  }
});

// 创建Multer实例并配置文件上传
const upload = multer({ storage: storage });

// 配置静态文件服务，用于提供上传的文件
app.use('/uploads', express.static(path.join(__dirname, 'uploads')));

// 定义文件上传路由
app.post('/upload', upload.single('file'), (req, res) => {
  // 如果有文件上传，则 req.file 将包含上传的文件信息
  // req.body 将包含其他非文件字段的信息
  if (!req.file) {
    return res.status(400).send('No file uploaded.');
  }
  
  res.send('File uploaded successfully.');
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

在上面的代码中，我们使用了Multer中间件来处理文件上传。我们首先设置了文件存储的配置，包括文件存储目录和文件名。然后，我们创建了一个Multer实例，并传入配置对象，用于配置文件上传。接着，我们定义了一个路由 /upload 来处理文件上传，使用 upload.single('file') 中间件来处理单个文件的上传。在路由处理函数中，如果有文件上传，则 req.file 将包含上传的文件信息，我们可以在这里处理上传的文件。最后，我们启动了Express服务器，并监听在端口3000上。

接下来，创建一个HTML文件来创建一个文件上传表单：

<!-- index.html -->

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>File Upload</title>
</head>
<body>
  <h2>Upload a file</h2>
  <form action="/upload" method="post" enctype="multipart/form-data">
    <input type="file" name="file" />
    <button type="submit">Upload</button>
  </form>
</body>
</html>

现在，启动你的应用并访问 http://localhost:3000，你将会看到一个简单的文件上传表单。选择一个文件并点击“上传”按钮，文件将会被上传到服务器的 uploads 目录中。上传完成后，你可以在浏览器中访问 http://localhost:3000/uploads/your-file 来查看上传的文件。

express 文件下载

const express = require('express');
const path = require('path');

const app = express();
const PORT = 3000;

// 配置静态文件服务，用于提供待下载的文件
app.use('/downloads', express.static(path.join(__dirname, 'downloads')));

// 定义文件下载路由
app.get('/download/:filename', (req, res) => {
  const filename = req.params.filename;
  const filePath = path.join(__dirname, 'downloads', filename);

  // 使用 res.download() 方法来发送文件给客户端进行下载
  res.download(filePath, filename, (err) => {
    if (err) {
      console.error('Error downloading file:', err);
      res.status(404).send('File not found');
    } else {
      console.log('File downloaded successfully');
    }
  });
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

在上面的代码中，我们首先使用 express.static() 中间件来指定静态文件服务，以提供待下载的文件。然后，我们定义了一个文件下载路由 /download/:filename，通过动态路由参数 :filename 来指定要下载的文件名。在路由处理函数中，我们使用 res.download() 方法来发送文件给客户端进行下载。该方法接收文件的完整路径和文件名作为参数，并在下载完成后触发回调函数。如果下载过程中出现错误，则会在回调函数中处理并发送适当的错误响应。

现在，将你想要提供下载的文件放置在 downloads 目录中，并命名为你想要的文件名。然后，启动你的应用并访问 http://localhost:3000/download/your-file，浏览器将会下载该文件。

nodejs+ websocket 示例：

WebSocket是一种在单个TCP连接上提供全双工通信的协议，它允许客户端和服务器之间进行实时的双向数据传输。下面我将逐行解释一个简单的WebSocket示例代码。

首先，我们创建一个基于Node.js的WebSocket服务器。假设我们使用ws库来实现WebSocket服务器：

const WebSocket = require('ws');

// 创建WebSocket服务器
const wss = new WebSocket.Server({ port: 8080 });

// 当有新的连接建立时，执行回调函数
wss.on('connection', function connection(ws) {
  console.log('New client connected');

  // 监听客户端发送的消息
  ws.on('message', function incoming(message) {
    console.log('Received message:', message);

    // 原样返回收到的消息
    ws.send(message);
  });

  // 当连接关闭时执行
  ws.on('close', function close() {
    console.log('Client disconnected');
  });
});

现在让我逐行解释上面的代码：

  1. const WebSocket = require('ws');：导入ws库，用于创建WebSocket服务器。

  2. const wss = new WebSocket.Server({ port: 8080 });：创建WebSocket服务器实例，监听在端口8080上。

  3. wss.on('connection', function connection(ws) { ... });：当有新的WebSocket连接建立时，执行回调函数。参数ws是表示连接的WebSocket实例。

  4. ws.on('message', function incoming(message) { ... });：当接收到客户端发送的消息时，执行回调函数。参数message是表示接收到的消息。

  5. ws.send(message);：通过WebSocket连接向客户端发送消息。

  6. ws.on('close', function close() { ... });：当WebSocket连接关闭时，执行回调函数。

接下来，我们可以编写一个简单的客户端代码来连接到WebSocket服务器并发送/接收消息。假设我们使用浏览器作为客户端：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>WebSocket Client</title>
</head>
<body>
  <script>
    const ws = new WebSocket('ws://localhost:8080');

    ws.onopen = function() {
      console.log('WebSocket connection established');
      
      // 发送消息到服务器
      ws.send('Hello, WebSocket Server!');
    };

    ws.onmessage = function(event) {
      console.log('Received message from server:', event.data);
    };

    ws.onclose = function() {
      console.log('WebSocket connection closed');
    };
  </script>
</body>
</html>

现在让我解释客户端代码：

  1. const ws = new WebSocket('ws://localhost:8080');：创建一个WebSocket实例，连接到服务器的WebSocket地址。

  2. ws.onopen = function() { ... };：当WebSocket连接成功建立时，执行回调函数。

  3. ws.send('Hello, WebSocket Server!');：向服务器发送消息。

  4. ws.onmessage = function(event) { ... };：当接收到服务器发送的消息时，执行回调函数。参数event.data表示接收到的消息。

  5. ws.onclose = function() { ... };：当WebSocket连接关闭时，执行回调函数。

以上就是一个简单的WebSocket示例代码，展示了如何使用Node.js和ws库创建WebSocket服务器，并使用浏览器作为客户端与服务器进行通信。

express 分页查询

const express = require('express');
const app = express();

// 模拟的用户数据
const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 3, name: 'Charlie' },
  { id: 4, name: 'David' },
  { id: 5, name: 'Eve' },
  // 添加更多用户...
];

// 分页查询路由
app.get('/users', (req, res) => {
  // 解析客户端请求中的页数和每页条目数，默认为第一页，每页显示5条
  const page = parseInt(req.query.page) || 1;
  const pageSize = parseInt(req.query.pageSize) || 5;

  // 计算起始索引和结束索引
  const startIndex = (page - 1) * pageSize;
  const endIndex = startIndex + pageSize;

  // 从用户数组中获取分页数据
  const paginatedUsers = users.slice(startIndex, endIndex);

  // 返回分页数据给客户端
  res.json({
    page: page,
    pageSize: pageSize,
    totalPages: Math.ceil(users.length / pageSize),
    users: paginatedUsers
  });
});

// 启动服务器
const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

在上面的代码中，我们创建了一个路由 /users 来处理分页查询请求。在路由处理函数中，我们解析了客户端请求中的页数和每页条目数，默认情况下为第一页，每页显示5条数据。然后，我们计算了起始索引和结束索引，并从用户数组中获取分页数据。最后，我们将分页数据以JSON格式返回给客户端。

你可以使用浏览器或者其他HTTP客户端工具发送带有页数和每页条目数的GET请求到 http://localhost:3000/users，服务器将返回相应的分页数据。例如，你可以尝试发送如下请求：

  • http://localhost:3000/users?page=2&pageSize=3 将返回第2页的3条数据。
  • http://localhost:3000/users 将返回默认的第1页的5条数据。

这就是一个简单的Express分页查询的示例。在实际项目中，你可能需要根据数据库的查询语言和方式来实现分页查询。

克里斯蒂亚诺更新
关注
专栏目录
NodeJS学习笔记
C++与Web
10-10 1549
更新：2018.11.07 使用NodeJS创建小型网站，比如公司内部 下载 在官网上下载最新的Windows 64 https://nodejs.org/en/ 默认安装即可，进入CMD，验证安装成功 C:\Users\lenovo&gt;node -v v10.13.0 安装模块Koa 框架和 koa-route 模块 可以和Express框架比较一下，koa或Express...
node.js下用Express搭建服务器（内含多种坑爹报错解决方法）
weixin_30505485的博客
12-05 280
如题 环境：windows 8 64bit\node.js v0.10.33 我觉得有必要说一下，我把node.js没有装在默认目录下，而是自定义路径 E:\Program\nodejs 我觉得我后来遇到的很多问题与此有关。 好，然后我就开心地打开node，在cmd下输入 npm install -g express 它就果不其然地报错了，确切的错误我...
只需几分钟跟小猫学前端（内含视频教程）：nodejs基础之用express、ejs、mongodb建设简单的网站...
weixin_34326558的博客
05-06 71
开门见山视频教程https://v.qq.com/x/page/d0645s79xrq.html前 言：这是小猫的第二篇node教程，第一篇教程是一个简单的试水，小猫的node教程面向对象为没有后端开发经验的但对node有所了解的web前端工程师们，每篇几分钟的视频和博文，由浅入深的学习node。所以跟小猫一起学node吧，小猫期待亲的持续关注。今天将为大家带来的是一个电商展示小网站，使用ex...
只需几分钟跟小猫学前端（内含视频教程）：nodejs基础之用express、ejs、mongdb建设简单的网站...
weixin_30780221的博客
05-06 67
开门见山视频教程 https://v.qq.com/x/page/d0645s79xrq.html 前 言： 这是小猫的第二篇node教程，第一篇教程是一个简单的试水，小猫的node教程面向对象为没有后端开发经验的但对node有所了解的web前端工程师们，每篇几分钟的视频和博文，由浅入深的学习node。所以跟小猫一起学node吧，小猫期待亲的持续关注。 今天将...
初步NodeJS in Windows：从安装到入门
w36680130的博客
09-22 203
上周末开始看NodeJS，一路下来从安装到入门代码都遇到了一些问题，今天总算解决了一点，写下来分享一下： 安装部分： 1. 首先我的系统是windows 8，所以这里只拿node在windows
关于前端学习路线的一些建议（内含自测题）
小生方勤
09-02 180
前言这几个月几乎每天都会有朋友加我微信，而他们问的最多的问题就是 —— 前端技术现在如此繁杂，我到底应该如何学习。这个话题太大了，几句话回答不好；也由于这个问题确实困扰了...
关于前端学习路线的一些建议（内含经典自测题）
weixin_45566319的博客
09-12 590
虽然这篇文章花了很长时间，肯定也有其局限性；希望各位不吝指出。 入题 我们俨然能感受到前端岗位现在已经发展成了最重要的研发岗位之一，所以对我们提出的要求也就越来越高。所以我们需要学的也就不仅仅只是 CSS & HTML & JavaScript 了。但这三大件一直都是前端的根本，这一点从未改变。而这三大件中 JavaScript 又是重中之重。 接下来我会结合我的一点经验，给出前端...
鹅厂前端大佬对于前端学习路线的一些建议（内含自测题）
画漫画的程序员∙苏南
04-30 272
点击上方“IT平头哥联盟”，选择“置顶或者星标”你的关注意义重大！前言这几个月几乎每天都会有朋友加我微信，而他们问的最多的问题就是 —— 前端技术现在如此繁杂，我到底应该如何学习。这个话题...
史上最全前端学习路线一条龙【内含入门到进阶到高级精选资源无套路获取】
qq_39398332的博客
11-03 841
大家好，我是xy，写了好几天，终于在今天完成啦！可以堪称是史上最贴心的前端学习路线了，帮助大家少走弯路，急速超车???? + ???? = ???????? 如果觉得这个超车路线有帮助到你，记得 ⭐️关注⭐️ 我哦，我的公众号：前端开发爱好者。一大波学习资源即将来袭，收藏保存吧???????????? 前言 经常有同学会问我，学到什么程度可以找到一份前端工作，或者会问如何入门前端，学习到什么程度可以胜任业务开发以及前端如何进阶等问题。别急！！！下面我们来把前端学习分为几个阶段，帮助你如何从一个小白成为前端
毕业设计，基于Vue+NodeJS+Express+MongoDb开发的在线考试系统，内含NodeJS完整源代码，数据库脚本
01-21
毕业设计，基于Vue+NodeJS+Express+MongoDb开发的在线考试系统，内含NodeJS完整源代码，数据库脚本 基于Vue+Express+MongoDB在线考试系统设计毕业源码案例设计 开发工具: WebStorm 开发环境：Nodejs + vue + ...
毕业设计，基于NodeJS+Express+MySql开发的前后端分离宠物用品购物网，内含NodeJS完整源代码，数据库脚本
01-25
毕业设计，基于NodeJS+Express+MongoDb开发的前后端分离宠物用品购物网，内含NodeJS完整源代码，数据库脚本 基于NodeJs+Express+Mysql前后端分离宠物用品购物网站设计 开发语言：nodejs 框架：Express 数据库：...
毕业设计，基于Nodejs+Express+WebSocket开发的网络在线聊天室系统，内含NodeJS完整源代码，数据库脚本
01-27
毕业设计，基于Nodejs+Express+WebSocket开发的网络在线聊天室系统，内含NodeJS完整源代码，数据库脚本 基于Nodejs+Express+WebSocket网络在线聊天室系统设计 开发软件：Vscode,mysql 技术栈：nodejs,express,...
毕业设计，基于NodeJs+Express+Mysql开发的学生社团活动管理系统，内含NodeJS完整源代码，数据库脚本
01-27
毕业设计，基于NodeJs+Express+Mysql开发的学生社团活动管理系统，内含NodeJS完整源代码，数据库脚本 基于NodeJs+Express+Mysql学生社团活动管理系统 开发技术：nodejs + express + ElementUI + layui 开发工具...
毕业设计，基于Vue+NodeJS+MongoDb开发的精品课程在线学习网站，内含NodeJS完整源代码，数据库脚本
01-21
毕业设计，基于Vue+NodeJS+MongoDb开发的精品课程在线学习网站，内含NodeJS完整源代码，数据库脚本 基于Vue+NodeJs+MongoDB精品课程在线学习网站设计毕业源码案例设计 开发软件： WebStorm 开发环境：Nodejs + vue...
NVM（node.js版本工具）的使用
liu62615的博客
09-16 685
NVM 是 Node Version Manager 的缩写，它是一个用于管理版本的命令行工具。通过NVM，你可以在同一台机器上安装和切换多个 Node.js 版本，对于开发和测试在不同 Node.js 版本上运行的应用程序非常有用。
【网络安全】Node.js初探+同步异步进程
等风来
09-17 389
Node.js 是运行在服务器端的 JavaScript 环境。它基于 Chrome 的 V8 引擎，拥有高效的执行性能。Node.js 采用事件驱动的 I/O 模型，使得它在处理高并发任务时表现出色。
Node.js官网无法正常访问时安装NodeJS的方法
邓邓子的博客
09-20 241
下载安装包后，双击安装包，按提示一步步操作即可。
5.C-Demo-排序
最新发布
09-20
5.C-Demo-排序_快速排序
写一个完整的nodejs express框架代码
08-04
答：以下是一个完整的nodejs express框架代码：const express = require('express'); const app = express();app.get('/', (req, res) => { res.send('Hello World!'); });app.listen(3000, () => { console.log('...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值