Node_数据库

信息获取来源Eno Yao

mysql

开启本地的mysql服务
在同一项目文件夹下，输入命令

npm init //创建项目依赖记录json文件
npm install mysql --save//安装node mysql模块，保存到json文件

连接数据库

编写js文件，进行数据库连接
service.js

var mysql = require('mysql');
var connection = mysql.createConnection({
    host: 'localhost',
    user: 'katsuki',
    password: '666',
    port: '3306', // 默认是3306
    database: 'katsuki_db'
});
connection.connect();
console.log("连接数据库")

这里是异步
connection.query('SELECT * FROM tablename', function (error, results, fields) {
    console.log("获取数据")
    if (error) throw error;
    console.log('The solution is: ', results);
});
console.log("关闭数据库")
connection.end();

运行node service得到

由于异步，查询数据时往下执行到关闭，关闭后在回调函数中得到数据，也必须从回调函数拿数据。

pool

由于请求一次就关闭，低效，性能消耗高，所以有了pool，检验一次进行多次操作
pool.js

var mysql = require('mysql');
var pool = mysql.createPool({
    connectionLimit: 10, //连接限制次数
    host: 'localhost',
    user: 'katsuki',
    password: '666',
    port: '3306', // 默认是3306
    database: 'katsuki_db'
});
pool.query('SELECT * FROM tablename', function (error, results, fields) {
    if (error) throw error;
    console.log('The solution is: ', results);
});
pool.query('SELECT * FROM tablename', function (error, results, fields) {
    if (error) throw error;
    console.log('The solution is: ', results);
});

运行node pool得到

由于没达到请求限制次数，不释放连接，达到限制操作次数后会释放连接

数据库封装

项目结构
	katsuki-project
		libs
			config.json
			db.js
		run.js

config.json
{	//写自己对应的用户名密码数据库名称
    "host": "localhost",
    "user": "katsuki",
    "password": "666",
    "port": "3306",
    "database": 'katsuki_db'
}

db.js
var mysql = require('mysql');
var config = require('./config.json');

var pool = mysql.createPool({
    connectionLimit: 10, //连接限制次数
    host: config.host,
    user: config.user,
    password: config.password,
    port: config.port, // 默认是3306
    database: config.database
});

//创建连接
let connect = () => {
    return new Promise((resolve, reject) => {
        pool.getConnection((err, connection) => {
            //判断是否有错误，有执行reject(err)，无执行resolve(connection)
            err ? reject(err) : resolve(connection);
        });
    })
}
由于多个where条件需要and进行连接，下面都只设置where只处理1个条件，传入多个会出错
//查
let find = (table, params) => {
    return new Promise(async (resolve, reject) => {
        let connection = await connect();
        //params?'where ?':'' 判断有无where条件传入
        connection.query(`select * from ${table} ${params ? 'where ?' : ''}`, [{
            //对象解构，这种...的形式只能在对象里面解构
            ...params
        }], function (error, results, fields) {
            //判断是否有错误，有执行reject(error)，无执行reslove(results)
            error ? reject(error) : resolve(results)
            connection.release();
        });
    })
}
下面只是sql语句不同，其他原理一样，
//增
let insert = (table, params) => {
    return new Promise(async (resolve, reject) => {
        let connection = await connect();
        connection.query(`insert into ${table} set ?`, [{
            ...params
        }],  (error, results, fields) => {
            error ? reject(error) : resolve(results)
            connection.release();
        })
    })
}
//删
let del = (table, params) => {
    return new Promise(async (resolve, reject) => {
        let connection = await connect();
        connection.query(`delete from ${table} where ?`, [{
            ...params
        }],  (error, results, fields) => {
            error ? reject(error) : resolve(results)
            connection.release();
        })
    })
}
//改
let update = (table, params1, params2) => {
    return new Promise(async (resolve, reject) => {
        let connection = await connect();
        connection.query(`update ${table} set ? where ?`, [{
            ...params1
        }, {
            ...params2
        }], (error, results, fields) => {
            error ? reject(error) : resolve(results)
            connection.release();
        })
    })
}
//ES5导出方法
module.exports = {
    connect,
    find,
    insert,
    del,
    update
}

run.js
//ES5导入方法
let {
    find,
    insert,
    del,
    update
} = require('./libs/db.js');

表结构 id自增长
id	name 		age
1	katsuki		10

(async ()=>{
    let data = await find('student',{
        id : 1 //查询条件
    });
    console.log(data);
    await insert('student',{
        name: 'kasami',  //插入内容
        age : 10
    });
    await del('student', {
        id: 2 //删除条件
    })
    await update('student', {
        age: 18 //设置值
    }, {
        name: 'katsuki' //更新条件
    })
})()

目录katsuki-project下node run执行即可

mongodb

nosql数据库，不需要sql语句的数据库，里面一切都是类似于JSON文件

mongodb教程

安装

双击安装mongodb.msi文件，按照默认路径安装
找回安装完mongodb文件夹bin的路径

C:\Program Files\MongoDB\Server\4.0\bin

里面有多个exe文件
在bin该目录下，打开cmd命令行，执行以下命令，该目录有数据连接此数据库，该目录没库就是创建数据库成功，

mongod --dbpath [文件夹的路径]

安装robo3t的可视化软件来管理mongodb数据库，没有表的概念，只有集合(类似于mysql的表))
配合node来使用mongodb数据库,在项目目录下用cmd安装

npm install mongodb

方法的原型可在npm网站搜索mongodb第一篇文章可找到，下面连接插入即为复制修改内容

创建mongod.js，运行node mongod，显示Connected successfully to server成功

mongod.js
const {
    MongoClient
} = require('mongodb');
// 连接url 不需更改
const url = 'mongodb://localhost:27017';
//数据库名称
const dbName = 'katsuki';
//连接
MongoClient.connect(url, (err, client) => {
  console.log("Connected successfully to server");
  const db = client.db(dbName);
  //关闭
  client.close();
});

插入 在上面的基础上增加
const {
    MongoClient
} = require('mongodb');
// 连接url 不需更改
const url = 'mongodb://localhost:27017';
//数据库名称
const dbName = 'katsuki';
//连接
MongoClient.connect(url, (err, client) => {
  console.log("Connected successfully to server");
  const db = client.db(dbName);
  //操作的数据库里的表名
  const collection = db.collection('tablename');
  collection.insertMany([
  	//{表列名:对应值} 里面的_id自动设置
    {ka : 1}, {ka : 2}, {ki : 3}
  ], function(err, result) {
    console.log("Inserted 3 documents into the collection");
  });
  //关闭
  client.close();
});

插入执行后结果

数据库封装

mongod.js
const {
    MongoClient,
    //拿到mongodb里的_id
    ObjectId
} = require('mongodb');

// 连接url 不需更改
const url = 'mongodb://localhost:27017';

//数据库名称
const dbName = 'katsuki';

//创建连接，注意不能创建了就关闭，执行完毕再关闭，所以导出client
let connect = () => {
    return new Promise((resolve, reject) => {
        MongoClient.connect(url, (err, client) => {
            if (err) {
                reject(err);
            } else {
                console.log("Connected successfully to server");
                const db = client.db(dbName);
                resolve({
                    db,
                    client
                })
            }
        });
    })
}

//插入，col为表名，arr为数组对象，是插入内容
let insert = (col, arr) => {
    return new Promise(async (resolve, reject) => {
        //首先要拿到连接导出对象才能进行操作,由于异步,需要先等待完成
        let {
            db,
            client
        } = await connect();
        //操作的表
        const collection = db.collection(col);
        collection.insertMany(arr, (err, result) => {
            if (err) {
                reject(err);
            } else {
                resolve(result);
                client.close();
            }
        });
    })
}

//查找，col为表名，obj为查找条件对象，传入空对象即为查找全部
let find = (col, obj) => {
    return new Promise(async (resolve, reject) => {
        let {
            db,
            client
        } = await connect();
        //操作的表
        const collection = db.collection(col);
        collection.find({
            ...obj
        }).toArray(function (err, docs) {
            if (err) {
                reject(arr);
            } else {
                resolve(docs);
                client.close();
            }
        });
    })
}

//删除，col为表名，obj为删除条件对象
let del = (col, obj) => {
    return new Promise(async (resolve, reject) => {
        let {
            db,
            client
        } = await connect();
        //操作的表
        const collection = db.collection(col);
        // 删除条件描述格式 哪里的 name 为 katsuki
        // obj{name : katsuki}
        collection.deleteOne({
            ...obj
        }, (err, result) => {
            if (err) {
                reject(err);
            } else {
                resolve(result);
                client.close();
            }
        });
    })
}

//改，col为表名，obj1为更新条件,obj2为更新的值，这个方法只更改第一个满足条件数据
let updateOne = (col, obj1, obj2) => {
    return new Promise(async (resolve, reject) => {
        let {
            db,
            client
        } = await connect();
        //操作的表
        const collection = db.collection(col);
        // 改条件描述格式 哪里的 age 为 18, 设置 name 为 katsuki
        // obj1{age : 18} obj2{name : katsuki}
        collection.updateOne({
            ...obj1
        }, {
                $set: {
                    ...obj2
                }
            }, (err, result) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(result);
                    client.close();
                }
            });
    })
}

module.exports = {
    insert,
    find,
    del,
    updateOne,
    ObjectId
}

操作的user表结构

运行node run进行测试

run.js
let{
    insert,
    find,
    del,
    update,
    ObjectId
} = require("./mongod.js");

(async ()=>{
	//插入，使用数组存对象的形式，传入多个对象就是插入多个数据
    insert("user",[{
        name: "kasami",
        age: 28
    }])
    //查全部
    let data = await find("user",{});
    console.log(data);
    //根据id查询，少用
    let data = await find("user",{
		_id: ObjectId("5c32acea747479154098004b")
	});
    console.log(data);
    //删
    del("user",{
        name : 'kasami'
    });
    //改，第一条符合条件
    updateOne("user",{
        age:18
    },{
        name:"kasami"
    });
})()