分类 nodejs 下的文章

前端全栈echarts实时制作。node.js写后端api接口。

2024-08-17

前端使用ECharts展示实时数据，后端使用Node.js和Express提供API接口。

后端代码 (Node.js + Express):




const express = require('express');
const app = express();
const port = 3000;
 
// 模拟数据库或数据源
let data = {
  value: 0
};
 
// API路由
app.get('/api/data', (req, res) => {
  // 模拟实时数据更新
  data.value = Math.random() * 100; // 生成一个0到100之间的随机数作为模拟数据
  res.json(data);
});
 
app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

前端代码 (HTML + JavaScript):




<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>ECharts实时数据</title>
  <script src="https://cdn.jsdelivr.net/npm/echarts/dist/echarts.min.js"></script>
</head>
<body>
  <div id="main" style="width: 600px;height:400px;"></div>
  <script>
    var myChart = echarts.init(document.getElementById('main'));
    var option = {
      title: {
        text: '实时数据'
      },
      series: [
        {
          type: 'gauge',
          detail: {formatter: '{value}'}
        }
      ]
    };
    myChart.setOption(option);
 
    // 实时更新数据
    setInterval(function () {
      fetch('/api/data')
        .then(response => response.json())
        .then(data => {
          myChart.setOption({
            series: [{
              data: [data.value]
            }]
          });
        })
        .catch(error => console.error('Error fetching data: ', error));
    }, 1000); // 每秒请求一次后端API
  </script>
</body>
</html>

在这个例子中，前端代码使用ECharts创建了一个仪表盘图表，并通过定时器每秒向后端API发送请求，获取实时数据，并更新图表。后端代码使用Express框架创建了一个API接口，返回一个随机生成的数据点。在实际应用中，你需要将模拟数据源替换为实际的数据库或数据流。

Node.js基础---Express中间件

2024-08-17

在Node.js中，Express是一个非常流行的web开发框架，它提供了许多内置的中间件，例如路由、静态文件服务、模板渲染等。

中间件是一种装配到应用程序中的函数，它可以访问请求对象（req），响应对象（res），以及应用程序的请求-响应循环的下一个中间件函数（next）。

下面是一些使用Express中间件的示例：

创建一个简单的中间件，它将在请求到达路由处理程序之前记录一些信息：




const express = require('express');
const app = express();
 
// 自定义中间件
app.use((req, res, next) => {
    console.log('Some info');
    next();
});
 
app.get('/', (req, res) => {
    res.send('Hello World!');
});
 
app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

使用Express的内置中间件处理静态文件：




const express = require('express');
const app = express();
 
// 静态文件中间件
app.use(express.static('public'));
 
app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

在上述代码中，如果请求的路径对应于public目录中的文件，那么静态文件中间件将提供这些文件。

使用Express的内置中间件处理JSON解析：




const express = require('express');
const app = express();
 
// JSON解析中间件
app.use(express.json());
 
app.post('/', (req, res) => {
    console.log(req.body);
    res.send('Success');
});
 
app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

在上述代码中，JSON解析中间件将req.body属性设置为一个对象，该对象包含解析的请求体中的JSON对象。

使用Express的内置中间件处理URL编码：




const express = require('express');
const app = express();
 
// URL编码中间件
app.use(express.urlencoded({ extended: true }));
 
app.post('/', (req, res) => {
    console.log(req.body);
    res.send('Success');
});
 
app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

在上述代码中，URL编码中间件将req.body属性设置为一个对象，该对象包含解析的请求体中的URL编码的数据。

使用Express的内置中间件处理路由：




const express = require('express');
const app = express();
 
// 路由中间件
app.use('/user', (req, res, next) => {
    console.log('User middleware');
    next();
});
 
app.get('/user', (req, res) => {
    res.send('User info');
});
 
app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

在上述代码中，路由中间件仅在请求路径以/user开头时触发。

错误处理中间件，它可以捕获所有错误：




const express = require('express');
const app = express();
 
// 错误处理中间件
app.use((err, req, res, next) => {
    console.error

Node.js 连接 MySQL

2024-08-17

在Node.js中，你可以使用mysql模块来连接MySQL数据库。以下是一个简单的例子：

首先，确保你已经安装了mysql模块。如果没有安装，可以使用npm来安装它：




npm install mysql

然后，你可以使用以下代码来连接MySQL数据库：




const mysql = require('mysql');
 
// 设置数据库连接参数
const connection = mysql.createConnection({
  host     : 'localhost', // 数据库地址
  user     : 'yourusername', // 数据库用户
  password : 'yourpassword', // 数据库密码
  database : 'mydatabase' // 数据库名
});
 
// 开启数据库连接
connection.connect(function(error) {
  if (error) throw error;
  console.log('Successfully connected to the database.');
});
 
// 当你完成数据库操作后，可以关闭连接
// connection.end();

在这个例子中，你需要替换yourusername、yourpassword和mydatabase为你的MySQL数据库的实际用户名、密码和数据库名。

连接成功后，你可以使用connection对象来执行SQL查询，例如查询数据或者插入数据。这里是一个查询数据的例子：




// 执行SQL查询
connection.query('SELECT * FROM yourtable', function (error, results, fields) {
  if (error) throw error;
  // 处理查询结果
  console.log(results);
});

在这个例子中，你需要替换yourtable为你的数据表名。记得在完成数据库操作后关闭连接，以免产生不必要的资源占用。

java/php/node.js/python火车订票系统【2024年毕设】

2024-08-17

火车订票系统的开发涉及到的技术栈包括但不限于Java、PHP、Node.js和Python。以下是一个简单的火车订票系统的功能模块示例，使用Python语言和Flask框架实现。




from flask import Flask, request, jsonify
 
app = Flask(__name__)
 
# 假设的火车票数据结构
tickets = [
    {"from": "北京", "to": "上海", "departure_time": "2024-01-01T12:00:00", "price": 200},
    # 更多票数据...
]
 
# 添加火车票API
@app.route('/api/tickets', methods=['POST'])
def add_ticket():
    new_ticket = {
        "from": request.json.get('from'),
        "to": request.json.get('to'),
        "departure_time": request.json.get('departure_time'),
        "price": request.json.get('price')
    }
    tickets.append(new_ticket)
    return jsonify({"message": "Ticket added successfully!"})
 
# 查询火车票API
@app.route('/api/tickets', methods=['GET'])
def get_tickets():
    return jsonify(tickets)
 
# 订票API（假设的逻辑）
@app.route('/api/book_ticket', methods=['POST'])
def book_ticket():
    # 订票逻辑...
    return jsonify({"message": "Ticket booked successfully!"})
 
if __name__ == '__main__':
    app.run(debug=True)

这个简易的火车订票系统示例包含了添加票、查询票和订票的基本功能。在实际的系统中，需要完善数据库设计、用户验证、支付集成等多个方面的功能。由于篇幅限制，这里只提供了一个非常简化的示例。

解决 “npm ERR! Node.js v20.11.0“ 错误的完整指南

2024-08-17

这个错误信息表明你正在尝试使用的npm（Node包管理器）版本与Node.js运行时的版本不兼容。具体来说，npm试图运行在Node.js v20.11.0版本上，但是这个版本可能不支持当前npm所需的特性或者存在已知的bug。

解决这个问题的方法通常有以下几种：

升级Node.js到一个与npm兼容的版本。你可以访问Node.js的官网下载最新稳定版本。
如果你不想或不能升级Node.js，可以尝试降级npm到一个与当前Node.js版本兼容的版本。你可以使用以下命令来降级npm：
```
npm install -g npm@<compatible_version>
```
其中<compatible_version>需要你去查找与你的Node.js v20.11.0兼容的npm版本。
如果问题依旧存在，可能是因为npm的缓存出了问题。你可以尝试清除npm缓存：
```
npm cache clean --force
```
确保你的npm是最新版本，可以通过以下命令更新npm到最新版本：
```
npm install -g npm@latest
```
如果以上方法都不能解决问题，可能需要重新安装Node.js和npm。你可以从Node.js的官网下载安装包进行重新安装。

在操作时，请确保你有适当的权限，如果需要，使用sudo来提升权限（在Unix-like系统中）。如果你在Windows系统上遇到这个问题，可能需要使用管理员权限打开命令提示符或PowerShell。

2024-08-17

在Node.js中，我们可以使用内置的fs模块来进行文件操作，使用path模块来处理路径。我们也将学习如何将代码模块化，遵循CommonJS标准，并且了解包的概念。

文件操作

引入fs模块




const fs = require('fs');

读取文件




fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

写入文件




fs.writeFile('example.txt', 'Hello Node.js', (err) => {
  if (err) throw err;
  console.log('The file has been saved!');
});

路径处理

引入path模块




const path = require('path');

路径拼接




const dir = path.join('/foo', 'bar', 'baz/asdf', 'quux', '..');
console.log(dir); // 输出: '/foo/bar/baz/asdf'

模块化

在Node.js中，我们可以通过module.exports和require来实现模块化。

创建一个模块




// math.js
function add(a, b) {
  return a + b;
}
 
module.exports = { add };

引入并使用模块




// main.js
const math = require('./math.js');
 
console.log(math.add(1, 2)); // 输出: 3

CommonJS标准

Node.js遵循CommonJS标准，它允许你通过require来加载模块，并通过module.exports来导出模块。

ECMAScript标准

Node.js遵循ECMAScript标准，为JavaScript提供了一个运行环境。

包

在Node.js中，包是一个目录，它包含了package.json文件，这个文件定义了包的属性和依赖。

通过npm（Node.js的包管理器），我们可以轻松地安装和管理包。

安装包




npm install express

使用包




const express = require('express');
const app = express();
 
app.get('/', (req, res) => {
  res.send('Hello World!');
});
 
app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

以上是Node.js学习的基础部分，包括文件操作、路径处理、模块化、CommonJS和ECMAScript标准以及包的概念。在后续的学习中，我们将会接触到更多高级特性和工具，如非阻塞I/O、事件循环、异步编程等。

后端项目搭建(node.js+express+mysql)

2024-08-17

为了创建一个使用Node.js, Express, 和 MySQL 的后端项目，你需要执行以下步骤：

初始化Node.js项目：




npm init -y

安装Express框架：




npm install express --save

安装MySQL连接器（例如mysql或mysql2）：




npm install mysql --save

创建一个简单的Express服务器并连接到MySQL数据库：

server.js:




const express = require('express');
const mysql = require('mysql');
 
// 设置数据库连接
const connection = mysql.createConnection({
  host     : 'localhost',
  user     : 'your_username',
  password : 'your_password',
  database : 'your_database'
});
 
// 启动数据库连接
connection.connect();
 
// 创建Express应用
const app = express();
const port = 3000;
 
// 定义API路由
app.get('/api/data', (req, res) => {
  connection.query('SELECT * FROM your_table', (error, results, fields) => {
    if (error) throw error;
    res.json(results);
  });
});
 
// 启动服务器
app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

确保替换your_username, your_password, your_database, 和 your_table为你的MySQL数据库的实际登录凭据和你希望查询的表名。

运行服务器：




node server.js

这个简单的服务器将会监听3000端口上的HTTP请求，并对/api/data路径的GET请求返回从MySQL数据库的your_table表中检索出的数据。

使用ExcelJS快速处理Node.js爬虫数据

2024-08-17




const ExcelJS = require('exceljs');
 
// 假设我们已经有了一些从Node.js爬虫中抓取的数据
const data = [
    {
        name: 'John Doe',
        age: 30,
        email: 'john.doe@example.com'
    },
    // ...更多数据
];
 
async function createExcelFile(data) {
    // 创建一个新的工作簿
    let workbook = new ExcelJS.Workbook();
    // 添加一个工作表
    let worksheet = workbook.addWorksheet('My Sheet');
 
    // 添加标题行
    worksheet.addRow(['Name', 'Age', 'Email']);
    // 添加数据行
    data.forEach(row => worksheet.addRow([row.name, row.age, row.email]));
 
    // 定义表格的宽度
    worksheet.columns.forEach(column => {
        column.width = column.header.length < 12 ? 12 : column.header.length // 最小宽度12
    });
 
    // 定义一个输出流
    let outputStream = new ExcelJS.stream.xlsx.WorkbookWriter(workbook);
 
    // 写入文件到输出流
    outputStream.pipe(fs.createWriteStream('output.xlsx'));
 
    // 数据处理完毕后关闭输出流
    outputStream.on('finished', () => console.log('Excel file created!'));
 
    // 处理数据和写入文件发生错误时的回调
    outputStream.on('error', err => console.error('An error occurred during Excel file creation:', err));
 
    // 数据处理完成后关闭输出流
    outputStream.on('finished', () => outputStream.end());
}
 
// 使用示例
createExcelFile(data);

这段代码展示了如何使用ExcelJS库在Node.js环境中创建Excel文件。首先，我们创建了一个工作簿和工作表，然后添加了标题行和数据行。我们还设置了列宽，并将结果通过管道输出到文件流中。这个过程是异步的，因此我们使用了async/await。

Node.js express框架大文件断点续传、大文件多并发上传

2024-08-17

在Node.js的Express框架中实现大文件的断点续传和大文件多并发上传，可以使用multer中间件来处理上传的文件，并结合数据库来保存上传进度。

以下是一个简化的例子：

安装必要的包：




npm install express multer mongoose

使用Express和Multer设置上传路由：




const express = require('express');
const multer = require('multer');
const mongoose = require('mongoose');
const app = express();
 
// 连接MongoDB数据库
mongoose.connect('mongodb://localhost:27017/uploads', { useNewUrlParser: true });
 
// 创建Mongoose模型来保存上传进度
const Upload = mongoose.model('Upload', new mongoose.Schema({
  filename: String,
  path: String,
  mime: String,
  size: Number,
  uploaded: Number,
  fieldname: String
}));
 
// 配置multer
const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, 'uploads/')
  },
  filename: function (req, file, cb) {
    cb(null, file.fieldname + '-' + file.originalname)
  }
})
const upload = multer({ storage: storage })
 
app.post('/upload', upload.single('file'), async (req, res) => {
  const { file } = req;
  const { filename, mimetype, size } = file;
 
  // 从数据库中查询上传进度
  let uploadDoc = await Upload.findOne({ filename });
  if (!uploadDoc) {
    uploadDoc = new Upload({
      filename,
      path: file.path,
      mime: mimetype,
      size,
      uploaded: 0,
      fieldname: file.fieldname[0]
    });
    await uploadDoc.save();
  }
 
  // 更新上传进度
  uploadDoc.uploaded += file.size;
  await uploadDoc.save();
 
  res.json({ message: 'File uploaded successfully', uploaded: uploadDoc.uploaded });
});
 
app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

在这个例子中，我们使用了MongoDB来保存上传进度。每次文件块被上传，服务器更新MongoDB中的记录。这样，即使服务器重启，上传进度也不会丢失。

注意：这只是一个简化的例子，实际应用中需要考虑更多安全性和性能因素，例如使用HTTP断点续传头部、文件分块、错误处理等。