没有废话,直接上干货

食用步骤

开通微信小程序云开发

如果已经拥有微信小程序,则直接在微信开发者工具中点击工具栏的云开发,按照指引即可开通,
否则前往微信公众平台注册微信小程序后,执行上述步骤。

新建微信小程序

新建微信小程序时,记得勾选后端服务栏的云开发,否则无法享受微信云开发服务。

新建云函数

  1. 在项目文件目录的cloudfunctions目录右击,选择新建Node.js云函数,名字自己输入,然后系统会自动生成对应的云函数目录。
  2. 打开刚才建立的云函数目录里面的index.js文件,然后就是-------复制粘贴:
// 云函数入口文件
const cloud = require('wx-server-sdk')
cloud.init();
const db = cloud.database();
const _ = db.command;
String.prototype.replaceAll = function (s1, s2) {
  return this.replace(new RegExp(s1, "gm"), s2);
}

// 云函数入口函数
async function dbAdd(value, collection) {
  let result = {
    success: false,
    data: null,
    message: null
  };
  await db.collection(collection).add({
    // 要插入的数据
    data: value
  }).then(res => {
    result = {
      success: true,
      data: res,
      message: "添加记录成功"
    }
  }).catch(err => {
    // 插入数据失败
    result = {
      success: false,
      data: null,
      err,
      message: "添加记录失败,详情查看后台日志"
    }
    console.log(err)
  });
  return result;
}

function genFielId(fielIds) {
  let fielId = {};
  fielIds.forEach((item) => {
    fielId[item] = true;
  });
  return fielId;
}

function genWhere(where) {
  let result = {};
  Object.keys(where).forEach((key) => {
    if (typeof (where[key]) == "string") {
      if (where[key].split(":")[0] == "regexp") {
        result[key] = genRegExp(where[key].split(":")[1], 'i')
      } else {
        result[key] = genCompare(where[key]);
      }
    } else {
      result[key] = where[key];
    }
  })
  return result;
}

function genRegExp(str, rule) {
  return db.RegExp({
    regexp: str,
    options: rule,
  })
}

function genCompare(str) {
  if (str.indexOf(">") != -1) {
    if (str.slice(1).indexOf("'") != -1) {
      str.replaceAll("'", "");
    } else {
      return _.gt(Number(str.slice(1)));
    }
    return _.gt(str.slice(1));
  }
  if (str.indexOf("<") != -1) {
    if (str.slice(1).indexOf("'") != -1) {
      str.replaceAll("'", "");
    } else {
      return _.lt(Number(str.slice(1)));
    }
    return _.lt(str.slice(1));
  }
  if (str.indexOf(">=") != -1) {
    if (str.slice(2).indexOf("'") != -1) {
      str.replaceAll("'", "");
    } else {
      return _.gte(Number(str.slice(2)));
    }
    return _.gte(str.slice(2));
  }
  if (str.indexOf("<=") != -1) {
    if (str.slice(2).indexOf("'") != -1) {
      str.replaceAll("'", "");
    } else {
      return _.lte(Number(str.slice(2)));
    }
    return _.lte(str.slice(2));
  }
  if (str.indexOf("not in") != -1) {
    let tem = str.split(" in ")[1];
    let temArr = [];
    if (tem.indexOf("'") != -1) {
      tem.replaceAll("'", "");
      temArr = tem.split(",");
    } else {
      let strArr = tem.split(",");
      strArr.forEach((item) => {
        temArr.push(Number(item));
      })
    }
    return _.nin(temArr)
  }
  if (str.indexOf("!=") != -1) {
    if (str.slice(2).indexOf("'") != -1) {
      str.replaceAll("'", "");
    } else {
      return _.lte(Number(str.slice(2)));
    }
    return _.neq(str.slice(2));
  }
  if (str.indexOf("in") != -1) {
    let tem = str.split(" ")[1];
    let temArr = [];
    if (tem.indexOf("'") != -1) {
      tem.replaceAll("'", "");
      temArr = tem.split(",");
    } else {
      let strArr = tem.split(",");
      strArr.forEach((item) => {
        temArr.push(Number(item));
      })
    }
    return _.in(temArr)
  }
  return str;
}

function genLogic(arr, link) {
  if (link == "nor") {
    return _.nor(arr);
  } else if (link == "or") {
    return _.or(arr);
  } else if (link == "not") {
    return _.not(arr);
  } else {
    return _.and(arr);
  }
}
async function dbGet(fielIds, collection, condition, link, orderBy, limit, skip) {
  let con = db.collection(collection);
  let result = {
    success: false,
    message: "get failed"
  };
  if (fielIds.length > 0) {
    con = con.field(genFielId(fielIds));
  }
  if (Array.isArray(condition)) {
    let whereResult = [];
    condition.forEach((item) => {
      whereResult.push(genWhere(item));
    });
    condition = genLogic(whereResult, link);
  } else {
    condition = genWhere(condition);
  }
  con = con.where(condition);
  if (limit > 0) {
    con = con.limit(limit);
  }
  if (skip != 0) {
    con = con.skip(skip);
  }
  Object.keys(orderBy).forEach((key) => {
    con = con.orderBy(key, orderBy[key]);
  })
  await con.get().then(res => {
    result = {
      data: res.data,
      success: true,
      code: 200
    };
  })
  return result;
}
async function dbUpdate(collection, value, condition, link) {
  let con = db.collection(collection);
  let result = {
    success: false,
    message: "update failed"
  };
  if (Array.isArray(condition)) {
    let whereResult = [];
    condition.forEach((item) => {
      whereResult.push(genWhere(item));
    });
    condition = genLogic(whereResult, link);
  } else {
    condition = genWhere(condition);
  }
  try {
    await con.where(condition).update({
      data:value
    }).then(res => {
      result = {
        updated:res.stats.updated,
        success: true,
      };
    })
  } catch (e) {
    result.err=e;
  }
  return result;
}
async function dbRemove(collection, condition, link) {
  let con = db.collection(collection);
  let result = {
    success: false,
    message: "remove failed"
  };
  if (Array.isArray(condition)) {
    let whereResult = [];
    condition.forEach((item) => {
      whereResult.push(genWhere(item));
    });
    condition = genLogic(whereResult, link);
  } else {
    condition = genWhere(condition);
  }
  await con.where(condition).remove().then(res => {
    result = {
      deleted:res.stats.removed,
      success: true,
    };
  })
  return result;
}
async function dbCount(collection, condition, link) {
  let con = db.collection(collection);
  let result = {
    success: false,
    message: "remove failed"
  };
  if (Array.isArray(condition)) {
    let whereResult = [];
    condition.forEach((item) => {
      whereResult.push(genWhere(item));
    });
    condition = genLogic(whereResult, link);
  } else {
    condition = genWhere(condition);
  }
  await con.where(condition).count().then(res => {
    result = {
      total:res.total,
      success: true,
    };
  })
  return result;
}
exports.main = async (event, context) => {
  if (event.method == "add") {
    if (event.collection) {
      return await dbAdd(event.value, event.collection);
    } else {
      return {
        success: false,
        message: "need collection parmas",
        data: null
      }
    }
  }
  if (event.method == "get") {
    if (event.collection) {
      return await dbGet(event.fielIds || [], event.collection, event.where || {}, event.link || "and", event.orderBy || {}, event.limit || 1000, event.skip || 0);
    } else {
      return {
        success: false,
        message: "need collection parmas",
        data: null
      }
    }
  }
  if (event.method == "update") {
    if (event.collection) {
      return await dbUpdate(event.collection, event.value, event.where || {}, event.link || "and");
    } else {
      return {
        success: false,
        message: "need collection parmas",
        data: null
      }
    }
  }
  if (event.method == "delete") {
    if (event.collection) {
      return await dbRemove(event.collection, event.where || {}, event.link || "and");
    } else {
      return {
        success: false,
        message: "need collection parmas",
        data: null
      }
    }
  }
  if (event.method == "count") {
    if (event.collection) {
      return await dbCount(event.collection, event.where || {}, event.link || "and");
    } else {
      return {
        success: false,
        message: "need collection parmas",
        data: null
      }
    }
  }
  return {
    success: false,
    message: "Illegal operation"
  };
}

调用方式介绍


  // 新增数据
  onAddData() {
    wx.cloud.callFunction({
      name:"cloudDb",
      data:{
        method:"add",
        value:{
          username:"凉皮",
          userpass:"7378",
          age:18,
          telephone:"10086"
        },
        collection:"test"
      }
    }).then(res=>{
      console.log(res);
    })
  },


  // 删除操作
  onDelete() {
    wx.cloud.callFunction({
      name:"cloudDb",
      data:{
        method:"delete",
        where:[{
          username:"regexp:凉"
        }],
        collection:"test",
      }
    }).then(res=>{
      console.log(res);
    })
  },


  //修改操作
  onUpdate() {
    wx.cloud.callFunction({
      name:"cloudDb",
      data:{
        method:"update",
        where:[{
          age:18
        }],
        collection:"test",
        value:{
          age:12
        }
      }
    }).then(res=>{
      console.log(res);
    })
  },


  // 查询操作
  onQuery() {
    wx.cloud.callFunction({
      name:"cloudDb",
      data:{
        method:"get",
        where:[{
          age:"in 12,18"
        }],
        orderBy:{
          age:"desc"
        },
        collection:"test"
      }
    }).then(res=>{
      console.log(res);
    })
  },

参数讲解

参数名默认值描述是否必须
methodadd调用的云端函数名是,不可修改
value{}添加的记录值,类型为对象否,无任何值时插入无效
collection""插入到哪个集合中是,不传会报错

参数名默认值描述是否必须
methoddelete调用的云端函数名是,不可修改
where{}删除的记录需要满足的条件,具体操作见查询条件介绍是,微信不允许
collection""插入到哪个集合中是,不传会报错

参数名默认值描述是否必须
methodupdate调用的云端函数名是,不可修改
where{}删除的记录需要满足的条件,具体操作见查询条件介绍是,微信不允许
collection""插入到哪个集合中是,不传会报错
value{}添加的记录值,类型为对象否,无任何值时插入无效

参数名默认值描述是否必须
methodget调用的云端函数名是,不可修改
where{}删除的记录需要满足的条件,具体操作见查询条件介绍是,微信不允许
collection""插入到哪个集合中是,不传会报错
orderBy{}排序规则,具体见排序规则介绍
limit1000限制查询输出的行数
skip0查询跳过多少行,多用于配合limit实现分页
fielIds[]指定查询返回的字段列表否,默认返回所有字段
link"and"指定查询条件为多个时,彼此之间的关系

fielIds提示

fielIds仅支持数组,数组元素则为需要返回的记录字段值,如
["username","age","telephone"]

查询条件介绍

查询条件可为对象,如:
例1

method:"get",
collection:"user",
where:{
    username:"regexp:凉",
    telphpone:"10086",
}

则代表查询用户数据集中username包含telephone等于10086的记录,默认为与查询,如需或查询,则需要配合参数link使用,如:
例2

method:"get",
collection:"user",
where:{
    username:"regexp:凉",
    telphpone:"10086",
},
link:"or"

则代表查询户数据集中username包含telephone等于10086的记录。


查询条件也可为包含查询条件兑现的数组,如:
例3

method:"get",
collection:"user",
where:[{
    telphpone:"10086",
},{
    username:"regexp:凉",
}],

实现的功能同例1,只是不同的写法。或查询同理添加link:"or"即可。

模糊查询

如果功能需要某个字段使用模糊查询匹配时,则可通过regexp:关键词的形式进行模糊匹配该字段,多用于搜索,使用方法例1有讲到

数值型大小判断查询

如果仅需返回指定字段大于某值时,可直接在字段上加入>符号即可,如:
例4

method:"get",
collection:"user",
where:[{
    age:">15"
},{
    username:"regexp:凉",
}],

则代表查询user数据集中age大于15username包含的记录。小于(<)、大于等于(>=)、、小于等于(<=)同理。


如果需要返回包含某一个指定数值数组的记录时,可使用in关键字连接,如:
例5

method:"get",
collection:"user",
where:[{
    age:"in 15,16,17,18"
},{
    username:"regexp:凉",
}],

则代表user数据集中age15、16、17、18中的某一个且username包含的记录。不包含指定数组,则使用not in,此处不做介绍。

link支持的逻辑方式

非(not)、与(and)、或(or),异或(nor)。

orderBy排序解释

传入排序规则,对象键名则为排序字段名,键值则为按哪种方式排序,如:
例6


orderBy:{
    age:"desc"
},

则代表按年龄降序排序,升序为asc。支持多个字段不同排序规则,同时写进orderBy里即可。


这都还不会用,别学开发了吧。

Last modification:May 13th, 2020 at 10:17 pm
如果觉得我的文章对你有用,请随意赞赏