发一个基于mysql2和async库的Nodejs小模块,希望各位大神纠正错误

发一个基于mysql2和async库的Nodejs小模块,希望各位大神纠正错误

var mysql = require(‘mysql2’); var async = require(‘async’);

var sqlFun=function(){}; sqlFun.prototype.setupConnection=function(info){ this.connection=mysql.createConnection({ host:info.host, user:info.user, password:info.password, database:info.database }); };//与Mysql建立连接

sqlFun.prototype.selectSql=function(sqlSentence,returnResult){ console.log(“start select”); var that=this; that.connection.query(sqlSentence,function(err,rows){ returnResult(rows); }); }; //查询的函数,resultResult返回查询到的结果

sqlFun.prototype.insertSql=function(sql,returnResult){ var connection=this.connection; async.waterfall([function(callback){ connection.query(sql,function(err,rows){ if(!err) callback(null,‘true’); else { callback(err,‘false’); } }); }], function(err,result){ console.log(“insert error:”+err); returnResult(result); }); };//插入操作函数,returnResult函数返回状态值

sqlFun.prototype.deleteSql=function(sql,callbackResult){ var that=this; async.waterfall([function(callback){ that.connection.query(sql,function(err,rows){ var result=err? err:false; callback(null,result); }); }],function(err,result){ callbackResult(result); }); };//删除操作,callbackResult返回状态

sqlFun.prototype.closeConnection=function(callback){ console.log(“end connection”); this.connection.end(function(err){ callback(err); }); };//断开数据库连接,callback返回错误信息; module.exports=sqlFun;

使用方法: var sqlFun=require(’./保存的js的文件名’); var useSql=new sqlFun(); useSql.setUpConnection([Object]);传入的对象包括数据库连接用户名、密码、主机名、数据库名 useSql.selectSql([string],[callback]);//string传入标准数据库语句,callback回调函数用来返回数据库操作的结果;


6 回复

好的,我将根据您的需求提供一个基于 mysql2async 库的 Node.js 小模块,并对其进行一些修正和优化。

修改后的代码

const mysql = require('mysql2/promise'); // 使用 promise 版本以支持异步操作
const async = require('async');

class SqlFun {
    constructor() {
        this.connection = null;
    }

    async setupConnection(info) {
        this.connection = await mysql.createConnection({
            host: info.host,
            user: info.user,
            password: info.password,
            database: info.database
        });
        console.log("Database connection established.");
    }

    async selectSql(sqlSentence, returnResult) {
        try {
            const [rows] = await this.connection.execute(sqlSentence);
            returnResult(rows);
        } catch (err) {
            console.error("Error during SELECT operation:", err);
            returnResult([]);
        }
    }

    async insertSql(sql, returnResult) {
        try {
            await this.connection.execute(sql);
            returnResult(true);
        } catch (err) {
            console.error("Error during INSERT operation:", err);
            returnResult(false);
        }
    }

    async deleteSql(sql, callbackResult) {
        try {
            await this.connection.execute(sql);
            callbackResult(true);
        } catch (err) {
            console.error("Error during DELETE operation:", err);
            callbackResult(false);
        }
    }

    async closeConnection(callback) {
        if (this.connection) {
            await this.connection.end();
            console.log("Database connection closed.");
            callback(null);
        } else {
            callback(new Error("No active connection to close."));
        }
    }
}

module.exports = SqlFun;

使用方法

const SqlFun = require('./path/to/your/module');

const useSql = new SqlFun();

// 设置数据库连接
useSql.setupConnection({
    host: 'localhost',
    user: 'root',
    password: 'password',
    database: 'testdb'
}).catch(err => {
    console.error("Failed to connect to the database:", err);
});

// 执行查询操作
useSql.selectSql('SELECT * FROM users', rows => {
    console.log("Query results:", rows);
});

// 执行插入操作
useSql.insertSql('INSERT INTO users (name, email) VALUES ("John Doe", "john@example.com")', success => {
    console.log("Insertion success:", success);
});

// 执行删除操作
useSql.deleteSql('DELETE FROM users WHERE name = "John Doe"', success => {
    console.log("Deletion success:", success);
});

// 关闭数据库连接
useSql.closeConnection(err => {
    if (err) {
        console.error("Failed to close connection:", err);
    } else {
        console.log("Connection closed successfully.");
    }
});

解释

  1. 使用 Promisemysql2 提供了基于 Promise 的版本 (mysql2/promise),这样可以更方便地处理异步操作。
  2. 异步方法:所有数据库操作方法都使用 asyncawait 进行封装,以确保代码的可读性和简洁性。
  3. 错误处理:在每个数据库操作中添加了错误处理逻辑,确保在出现错误时能够正确地捕获并处理它们。
  4. 简化接口:简化了 selectSql, insertSql, 和 deleteSql 方法的接口,使得调用更加直观。

希望这些修改能帮助您更好地理解和使用这个模块。


代码太长了,先说说是干啥的

就是把一些数据库常用的操作给封装起来了,中间用了async库的waterfall流程控制,每次调用实例化对象的函数如useSql.selectSql([sting],[callback])第一个参数传入的sql语句,第二个参数传入一个回调函数来返回数据库查询的结果

膜拜啊…收藏了

根据你提供的代码片段,我注意到几个问题。以下是修正后的代码示例,以及对主要修改点的解释:

修改后的代码

const mysql = require('mysql2/promise'); // 使用 promise 版本以更好地支持异步操作
const async = require('async');

class SqlFun {
  constructor() {}

  async setupConnection(info) { // 使用 async 函数处理异步操作
    this.connection = await mysql.createConnection({
      host: info.host,
      user: info.user,
      password: info.password,
      database: info.database
    });
  }

  async selectSql(sqlSentence, returnResult) { // 使用 async 函数
    console.log("start select");
    try {
      const [rows] = await this.connection.execute(sqlSentence); // 使用 execute 方法执行 SQL 查询
      returnResult(rows);
    } catch (error) {
      console.error(error);
    }
  }

  async insertSql(sql, returnResult) { // 使用 async 函数
    try {
      await this.connection.execute(sql); // 执行插入操作
      returnResult(true); // 插入成功时返回 true
    } catch (error) {
      returnResult(false); // 插入失败时返回 false
    }
  }

  async deleteSql(sql, callbackResult) { // 使用 async 函数
    try {
      await this.connection.execute(sql); // 执行删除操作
      callbackResult(true); // 删除成功时返回 true
    } catch (error) {
      callbackResult(false); // 删除失败时返回 false
    }
  }

  async closeConnection(callback) { // 使用 async 函数
    console.log("end connection");
    try {
      await this.connection.end(); // 关闭数据库连接
      callback(null); // 没有错误发生时调用回调函数
    } catch (error) {
      callback(error); // 发生错误时调用回调函数
    }
  }
}

module.exports = SqlFun;

主要修改点

  1. 使用 promise 版本mysql2/promise 提供了更方便的异步操作。
  2. 使用 async/await:这使得异步代码看起来更像同步代码,并且更容易理解。
  3. 错误处理:添加了 try/catch 语句来捕获可能的错误并进行适当的处理。
  4. 方法命名:将 setUpConnection 改为 setupConnection 以符合常见的命名规范。

使用示例

const SqlFun = require('./path/to/sqlFun.js');
const useSql = new SqlFun();

(async () => {
  await useSql.setupConnection({ host: 'localhost', user: 'root', password: 'password', database: 'test' });
  await useSql.selectSql('SELECT * FROM users', rows => console.log(rows));
  await useSql.insertSql('INSERT INTO users(name) VALUES("John")', success => console.log(success ? 'Insert successful' : 'Insert failed'));
  await useSql.deleteSql('DELETE FROM users WHERE name="John"', success => console.log(success ? 'Delete successful' : 'Delete failed'));
  await useSql.closeConnection(err => console.log(err ? 'Close connection error' : 'Connection closed'));
})();

通过这些修改,你的 Node.js 模块应该可以更好地处理异步操作,并提供更好的错误处理机制。

回到顶部