model

think.model.base 继承自 think.base 类。

使用 ES6 的语法继承该类
  1. export default class extends think.model.base {
  2. getList(){
  3. }
  4. }
使用普通方式继承该类
  1. module.exports = think.model({
  2. getList: function(){
  3. }
  4. })

属性

model.pk

数据表主键,默认为 id

model.name

模型名,默认从当前文件名中解析。

当前文件路径为 for/bar/app/home/model/user.js,那么解析的模型名为 user

model.tablePrefix

数据表名称前缀,默认为 think_

model.tableName

数据表名称,不包含前缀。默认等于模型名。

model.schema

数据表字段,关系型数据库默认自动从数据表分析。

model.indexes

数据表索引,关系数据库会自动从数据表分析。

model.config

配置,实例化的时候指定。

model._db

连接数据库句柄。

model._data

操作的数据。

model._options

操作选项。

方法

model.model(name, options, module)

  • name {String} 模型名称
  • options {Object} 配置项
  • module {String} 模块名
  • return {Object}
    获取模型实例,可以跨模块获取。
  1. export default class extends think.model.base {
  2. async getList(){
  3. //获取 user 模型实例
  4. let instance = this.model('user');
  5. let list = await instance.select();
  6. let ids = list.map(item => {
  7. return item.id;
  8. });
  9. let data = await this.where({id: ['IN', ids]}).select();
  10. return data;
  11. }
  12. }

model.getTablePrefix()

  • return {string}
    获取表名前缀。

model.getConfigKey()

  • return {String}
    获取配置对应的 key,缓存 db 句柄时使用。

model.db()

  • return {Object}
    根据当前的配置获取 db 实例,如果已经存在则直接返回。

model.getModelName()

  • return {String} 模型名称
    如果已经配置则直接返回,否则解析当前的文件名。

model.getTableName()

  • return {String} 获取表名,包含表前缀
    获取表名,包含表前缀。

model.cache(key, timeout)

  • key {String} 缓存 key
  • timeout {Number} 缓存有效时间,单位为秒
  • return {this}
    设置缓存选项。
设置缓存 key 和时间
  1. export default class extends think.model.base {
  2. getList(){
  3. return this.cache('getList', 1000).where({id: {'>': 100}}).select();
  4. }
  5. }
只设置缓存时间,缓存 key 自动生成
  1. export default class extends think.model.base {
  2. getList(){
  3. return this.cache(1000).where({id: {'>': 100}}).select();
  4. }
  5. }
设置更多的缓存信息
  1. export default class extends think.model.base {
  2. getList(){
  3. return this.cache({
  4. key: 'getList',
  5. timeout: 1000,
  6. type: 'file' //使用文件方式缓存
  7. }).where({id: {'>': 100}}).select();
  8. }
  9. }

model.limit(offset, length)

  • offset {Number} 设置查询的起始位置
  • length {Number} 设置查询的数据长度
  • return {this}
    设置查询结果的限制条件。
限制数据长度
  1. export default class extends think.model.base {
  2. getList(){
  3. //查询20条数据
  4. return this.limit(20).where({id: {'>': 100}}).select();
  5. }
  6. }
限制数据起始位置和长度
  1. export default class extends think.model.base {
  2. getList(){
  3. //从起始位置100开始查询20调数据
  4. return this.limit(100, 20).where({id: {'>': 100}}).select();
  5. }
  6. }

model.page(page, listRows)

  • page {Number} 当前页,从 1 开始
  • listRows {Number} 每页的条数
  • return {this}
    设置查询分页数据,自动转化为 limit 数据。
  1. export default class extends think.model.base {
  2. getList(){
  3. //查询第 2 页数据,每页 10 条数据
  4. return this.page(2, 10).where({id: {'>': 100}}).select();
  5. }
  6. }

model.where(where)

  • where {String | Object} where 条件
  • return {this}
    设置 where 查询条件。可以通过属性 _logic 设置逻辑,默认为 AND。可以通过属性 _complex 设置复合查询。

:1、以下示例不适合 mongo model,mongo 中设置 where 条件请见 model.mongo 里的 where 条件设定。2、where 条件中的值需要在 Logic 里做数据校验,否则可能会有漏洞。

普通条件
  1. export default class extends think.model.base {
  2. where1(){
  3. //SELECT * FROM `think_user`
  4. return this.where().select();
  5. }
  6. where2(){
  7. //SELECT * FROM `think_user` WHERE ( `id` = 10 )
  8. return this.where({id: 10}).select();
  9. }
  10. where3(){
  11. //SELECT * FROM `think_user` WHERE ( id = 10 OR id < 2 )
  12. return this.where('id = 10 OR id < 2').select();
  13. }
  14. where4(){
  15. //SELECT * FROM `think_user` WHERE ( `id` != 10 )
  16. return this.where({id: ['!=', 10]}).select();
  17. }
  18. }
null 条件
  1. export default class extends think.model.base {
  2. where1(){
  3. //SELECT * FROM `think_user` where ( title IS NULL );
  4. return this.where({title: null}).select();
  5. }
  6. where2(){
  7. //SELECT * FROM `think_user` where ( title IS NOT NULL );
  8. return this.where({title: ['!=', null]}).select();
  9. }
  10. }
EXP 条件

ThinkJS 默认会对字段和值进行转义,防止安全漏洞。有时候一些特殊的情况不希望被转义,可以使用 EXP 的方式,如:

  1. export default class extends think.model.base {
  2. where1(){
  3. //SELECT * FROM `think_user` WHERE ( (`name` ='name') )
  4. return this.where({name: ['EXP', "=\"name\""]}).select();
  5. }
  6. }
LIKE 条件
  1. export default class extends think.model.base {
  2. where1(){
  3. //SELECT * FROM `think_user` WHERE ( `title` NOT LIKE 'welefen' )
  4. return this.where({title: ['NOTLIKE', 'welefen']}).select();
  5. }
  6. where2(){
  7. //SELECT * FROM `think_user` WHERE ( `title` LIKE '%welefen%' )
  8. return this.where({title: ['like', '%welefen%']}).select();
  9. }
  10. //like 多个值
  11. where3(){
  12. //SELECT * FROM `think_user` WHERE ( (`title` LIKE 'welefen' OR `title` LIKE 'suredy') )
  13. return this.where({title: ['like', ['welefen', 'suredy']]}).select();
  14. }
  15. //多个字段或的关系 like 一个值
  16. where4(){
  17. //SELECT * FROM `think_user` WHERE ( (`title` LIKE '%welefen%') OR (`content` LIKE '%welefen%') )
  18. return this.where({'title|content': ['like', '%welefen%']}).select();
  19. }
  20. //多个字段与的关系 Like 一个值
  21. where5(){
  22. //SELECT * FROM `think_user` WHERE ( (`title` LIKE '%welefen%') AND (`content` LIKE '%welefen%') )
  23. return this.where({'title&content': ['like', '%welefen%']}).select();
  24. }
  25. }
IN 条件
  1. export default class extens think.model.base {
  2. where1(){
  3. //SELECT * FROM `think_user` WHERE ( `id` IN ('10','20') )
  4. return this.where({id: ['IN', '10,20']}).select();
  5. }
  6. where2(){
  7. //SELECT * FROM `think_user` WHERE ( `id` IN (10,20) )
  8. return this.where({id: ['IN', [10, 20]]}).select();
  9. }
  10. where3(){
  11. //SELECT * FROM `think_user` WHERE ( `id` NOT IN (10,20) )
  12. return this.where({id: ['NOTIN', [10, 20]]}).select();
  13. }
  14. }
BETWEEN 查询
  1. export default class extens think.model.base {
  2. where1(){
  3. //SELECT * FROM `think_user` WHERE ( (`id` BETWEEN 1 AND 2) )
  4. return this.where({id: ['BETWEEN', 1, 2]}).select();
  5. }
  6. where2(){
  7. //SELECT * FROM `think_user` WHERE ( (`id` BETWEEN '1' AND '2') )
  8. return this.where({id: ['between', '1,2']}).select();
  9. }
  10. }
多字段查询
  1. export default class extends think.model.base {
  2. where1(){
  3. //SELECT * FROM `think_user` WHERE ( `id` = 10 ) AND ( `title` = 'www' )
  4. return this.where({id: 10, title: "www"}).select();
  5. }
  6. //修改逻辑为 OR
  7. where2(){
  8. //SELECT * FROM `think_user` WHERE ( `id` = 10 ) OR ( `title` = 'www' )
  9. return this.where({id: 10, title: "www", _logic: 'OR'}).select();
  10. }
  11. //修改逻辑为 XOR
  12. where2(){
  13. //SELECT * FROM `think_user` WHERE ( `id` = 10 ) XOR ( `title` = 'www' )
  14. return this.where({id: 10, title: "www", _logic: 'XOR'}).select();
  15. }
  16. }
多条件查询
  1. export default class extends think.model.base {
  2. where1(){
  3. //SELECT * FROM `think_user` WHERE ( `id` > 10 AND `id` < 20 )
  4. return this.where({id: {'>': 10, '<': 20}}).select();
  5. }
  6. //修改逻辑为 OR
  7. where2(){
  8. //SELECT * FROM `think_user` WHERE ( `id` < 10 OR `id` > 20 )
  9. return this.where({id: {'<': 10, '>': 20, _logic: 'OR'}}).select()
  10. }
  11. }
复合查询
  1. export default class extends think.model.base {
  2. where1(){
  3. //SELECT * FROM `think_user` WHERE ( `title` = 'test' ) AND ( ( `id` IN (1,2,3) ) OR ( `content` = 'www' ) )
  4. return this.where({
  5. title: 'test',
  6. _complex: {id: ['IN', [1, 2, 3]],
  7. content: 'www',
  8. _logic: 'or'
  9. }
  10. }).select()
  11. }
  12. }

model.field(field)

  • field {String | Array} 设置要查询的字段,可以是字符串,也可以是数组
  • return {this}
    设置要查询的字段。
字符串方式
  1. export default class extends think.controller.base {
  2. async indexAction(){
  3. let model = this.model('user');
  4. //设置要查询的字符串,字符串方式,多个用逗号隔开
  5. let data = await model.field('name,title').select();
  6. }
  7. }
调用 SQL 函数
  1. export default class extends think.controller.base {
  2. //字段里调用 SQL 函数
  3. async listAction(){
  4. let model = this.model('user');
  5. let data = await model.field('id, INSTR(\'30,35,31,\',id + \',\') as d').select();
  6. }
  7. }
数组方式
  1. export default class extends think.controller.base {
  2. async indexAction(){
  3. let model = this.model('user');
  4. //设置要查询的字符串,数组方式
  5. let data = await model.field(['name','title']).select();
  6. }
  7. }

model.fieldReverse(field)

  • field {String | Array} 反选字段,即查询的时候不包含这些字段
  • return {this}
    设置反选字段,查询的时候会过滤这些字段,支持字符串和数组 2 种方式。

model.table(table, hasPrefix)

  • table {String} 表名
  • hasPrefix {Boolean} 是否已经有了表前缀,如果 table 值含有空格,则不在添加表前缀
  • return {this}
    设置表名,可以将一个 SQL 语句设置为表名。
设置当前表名
  1. export default class extends think.model.base {
  2. getList(){
  3. return this.table('test', true).select();
  4. }
  5. }
SQL 语句作为表名
  1. export default class extends think.model.base {
  2. async getList(){
  3. let sql = await this.model('group').group('name').buildSql();
  4. let data = await this.table(sql).select();
  5. return data;
  6. }
  7. }

model.union(union, all)

  • union {String | Object} 联合查询 SQL 或者表名
  • all {Boolean} 是否是 UNION ALL 方式
  • return {this}
    联合查询。
SQL 联合查询
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM `think_user` UNION (SELECT * FROM think_pic2)
  4. return this.union('SELECT * FROM think_pic2').select();
  5. }
  6. }
表名联合查询
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM `think_user` UNION ALL (SELECT * FROM `think_pic2`)
  4. return this.union({table: 'think_pic2'}, true).select();
  5. }
  6. }

model.join(join)

  • join {String | Object | Array} 要组合的查询语句,默认为 LEFT JOIN
  • return {this}
    组合查询,支持字符串、数组和对象等多种方式。
字符串
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM `think_user` LEFT JOIN think_cate ON think_group.cate_id=think_cate.id
  4. return this.join('think_cate ON think_group.cate_id=think_cate.id').select();
  5. }
  6. }
数组
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM `think_user` LEFT JOIN think_cate ON think_group.cate_id=think_cate.id RIGHT JOIN think_tag ON think_group.tag_id=think_tag.id
  4. return this.join([
  5. 'think_cate ON think_group.cate_id=think_cate.id',
  6. 'RIGHT JOIN think_tag ON think_group.tag_id=think_tag.id'
  7. ]).select();
  8. }
  9. }
对象:单个表
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM `think_user` INNER JOIN `think_cate` AS c ON think_user.`cate_id`=c.`id`
  4. return this.join({
  5. table: 'cate',
  6. join: 'inner', //join 方式,有 left, right, inner 3 种方式
  7. as: 'c', // 表别名
  8. on: ['cate_id', 'id'] //ON 条件
  9. }).select();
  10. }
  11. }
对象:多次 JOIN
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM think_user AS a LEFT JOIN `think_cate` AS c ON a.`cate_id`=c.`id` LEFT JOIN `think_group_tag` AS d ON a.`id`=d.`group_id`
  4. return this.alias('a').join({
  5. table: 'cate',
  6. join: 'left',
  7. as: 'c',
  8. on: ['cate_id', 'id']
  9. }).join({
  10. table: 'group_tag',
  11. join: 'left',
  12. as: 'd',
  13. on: ['id', 'group_id']
  14. }).select()
  15. }
  16. }
对象:多个表
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM `think_user` LEFT JOIN `think_cate` ON think_user.`id`=think_cate.`id` LEFT JOIN `think_group_tag` ON think_user.`id`=think_group_tag.`group_id`
  4. return this.join({
  5. cate: {
  6. on: ['id', 'id']
  7. },
  8. group_tag: {
  9. on: ['id', 'group_id']
  10. }
  11. }).select();
  12. }
  13. }
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM think_user AS a LEFT JOIN `think_cate` AS c ON a.`id`=c.`id` LEFT JOIN `think_group_tag` AS d ON a.`id`=d.`group_id`
  4. return this.alias('a').join({
  5. cate: {
  6. join: 'left', // 有 left,right,inner 3 个值
  7. as: 'c',
  8. on: ['id', 'id']
  9. },
  10. group_tag: {
  11. join: 'left',
  12. as: 'd',
  13. on: ['id', 'group_id']
  14. }
  15. }).select()
  16. }
  17. }
对象:ON 条件含有多个字段
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM `think_user` LEFT JOIN `think_cate` ON think_user.`id`=think_cate.`id` LEFT JOIN `think_group_tag` ON think_user.`id`=think_group_tag.`group_id` LEFT JOIN `think_tag` ON (think_user.`id`=think_tag.`id` AND think_user.`title`=think_tag.`name`)
  4. return this.join({
  5. cate: {on: 'id, id'},
  6. group_tag: {on: ['id', 'group_id']},
  7. tag: {
  8. on: { // 多个字段的 ON
  9. id: 'id',
  10. title: 'name'
  11. }
  12. }
  13. }).select()
  14. }
  15. }
对象:table 值为 SQL 语句
  1. export default class extends think.model.base {
  2. async getList(){
  3. let sql = await this.model('group').buildSql();
  4. //SELECT * FROM `think_user` LEFT JOIN ( SELECT * FROM `think_group` ) ON think_user.`gid`=( SELECT * FROM `think_group` ).`id`
  5. return this.join({
  6. table: sql,
  7. on: ['gid', 'id']
  8. }).select();
  9. }
  10. }

model.order(order)

  • order {String | Array | Object} 排序方式
  • return {this}
    设置排序方式。
字符串
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM `think_user` ORDER BY id DESC, name ASC
  4. return this.order('id DESC, name ASC').select();
  5. }
  6. getList1(){
  7. //SELECT * FROM `think_user` ORDER BY count(num) DESC
  8. return this.order('count(num) DESC').select();
  9. }
  10. }
数组
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM `think_user` ORDER BY id DESC,name ASC
  4. return this.order(['id DESC', 'name ASC']).select();
  5. }
  6. }
对象
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM `think_user` ORDER BY `id` DESC,`name` ASC
  4. return this.order({
  5. id: 'DESC',
  6. name: 'ASC'
  7. }).select();
  8. }
  9. }

model.alias(tableAlias)

  • tableAlias {String} 表别名
  • return {this}
    设置表别名。
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM think_user AS a;
  4. return this.alias('a').select();
  5. }
  6. }

model.having(having)

  • having {String} having 查询的字符串
  • return {this}
    设置 having 查询。
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM `think_user` HAVING view_nums > 1000 AND view_nums < 2000
  4. return this.having('view_nums > 1000 AND view_nums < 2000').select();
  5. }
  6. }

model.group(group)

  • group {String} 分组查询的字段
  • return {this}
    设定分组查询。
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT * FROM `think_user` GROUP BY `name`
  4. return this.group('name').select();
  5. }
  6. }

model.distinct(distinct)

  • distinct {String} 去重的字段
  • return {this}
    去重查询。
  1. export default class extends think.model.base {
  2. getList(){
  3. //SELECT DISTINCT `name` FROM `think_user`
  4. return this.distinct('name').select();
  5. }
  6. }

model.explain(explain)

  • explain {Boolean} 是否添加 explain 执行
  • return {this}
    是否在 SQL 之前添加 explain 执行,用来查看 SQL 的性能。

model.optionsFilter(options)

操作选项过滤。

model.dataFilter(data)

  • data {Object | Array} 要操作的数据
    数据过滤。

model.beforeAdd(data)

  • data {Object} 要添加的数据
    添加前置操作。

model.afterAdd(data)

  • data {Object} 要添加的数据
    添加后置操作。

model.afterDelete(data)

删除后置操作。

model.beforeUpdate(data)

  • data {Object} 要更新的数据
    更新前置操作。

model.afterUpdate(data)

  • data {Object} 要更新的数据
    更新后置操作。

model.afterFind(data)

  • data {Object} 查询的单条数据
  • return {Object | Promise}
    find 查询后置操作。

model.afterSelect(data)

  • data [Array] 查询的数据数据
  • return {Array | Promise}
    select 查询后置操作。

model.data(data)

  • data {Object}
    添加和更新操作时设置操作的数据。

model.options(options)

  • options {Object}
    设置操作选项。如:
  1. export default class extends think.model.base {
  2. getList(){
  3. return this.options({
  4. where: 'id = 1',
  5. limit: [10, 1]
  6. }).select();
  7. }
  8. }

model.close()

关闭数据库连接,一般情况下不要直接调用。

model.getSchema(table)

  • table {String} 表名
  • return {Promise}
    获取表的字段信息,自动从数据库中读取。

model.getTableFields(table)

已废弃,使用 model.getSchema 方法替代。

model.getLastSql()

  • return {String}
    获取最后执行的 SQL 语句。

model.buildSql()

  • return {Promise}
    将当前的查询条件生成一个 SQL 语句。

model.parseOptions(oriOpts, extraOptions)

  • oriOpts {Object}
  • extraOptions {Object}
  • return {Promise}
    根据已经设定的一些条件解析当前的操作选项。

model.getPk()

  • return {Promise}
    返回 pk 的值,返回一个 Promise。

model.parseType(field, value)

  • field {String} 数据表中的字段名称
  • value {Mixed}
  • return {Mixed}
    根据数据表中的字段类型解析 value。

model.parseData(data)

  • data {Object} 要解析的数据
  • return {Object}
    调用 parseType 方法解析数据。

model.add(data, options, replace)

  • data {Object} 要添加的数据
  • options {Object} 操作选项
  • replace {Boolean} 是否是替换操作
  • return {Promise} 返回插入的 ID
    添加一条数据。

model.thenAdd(data, where)

  • data {Object} 要添加的数据
  • where {Object} where 条件
  • return {Promise}
    当 where 条件未命中到任何数据时才添加数据。

model.addMany(dataList, options, replace)

  • dataList {Array} 要添加的数据列表
  • options {Object} 操作选项
  • replace {Boolean} 是否是替换操作
  • return {Promise} 返回插入的 ID
    一次添加多条数据。

model.delete(options)

  • options {Object} 操作选项
  • return {Promise} 返回影响的行数
    删除数据。

删除 id 为 7 的数据。

  1. model.delete({
  2. where: {id: 7}
  3. });

model.update(data, options)

  • data {Object} 要更新的数据
  • options {Object} 操作选项
  • return {Promise} 返回影响的行数
    更新数据。

updateMany(dataList, options)

  • dataList {Array} 要更新的数据列表
  • options {Object} 操作选项
  • return {Promise}
    更新多条数据,dataList 里必须包含主键的值,会自动设置为更新条件。

model.increment(field, step)

  • field {String} 字段名
  • step {Number} 增加的值,默认为 1
  • return {Promise}
    字段值增加。

model.decrement(field, step)

  • field {String} 字段名
  • step {Number} 增加的值,默认为 1
  • return {Promise}
    字段值减少。

model.find(options)

  • options {Object} 操作选项
  • return {Promise} 返回单条数据
    查询单条数据,返回的数据类型为对象。如果未查询到相关数据,返回值为 {}

model.select(options)

  • options {Object} 操作选项
  • return {Promise} 返回多条数据
    查询多条数据,返回的数据类型为数组。如果未查询到相关数据,返回值为 []

model.countSelect(options, pageFlag)

  • options {Object} 操作选项
  • pageFlag {Boolean} 当页数不合法时处理,true 为修正到第一页,false 为修正到最后一页,默认不修正
  • return {Promise}
    分页查询,一般需要结合 page 方法一起使用。如:
  1. export default class extends think.controller.base {
  2. async listAction(){
  3. let model = this.model('user');
  4. let data = await model.page(this.get('page')).countSelect();
  5. }
  6. }

返回值数据结构如下:

  1. {
  2. numsPerPage: 10, //每页显示的条数
  3. currentPage: 1, //当前页
  4. count: 100, //总条数
  5. totalPages: 10, //总页数
  6. data: [{ //当前页下的数据列表
  7. name: "thinkjs",
  8. email: "admin@thinkjs.org"
  9. }, ...]
  10. }

model.getField(field, one)

  • field {String} 字段名,多个字段用逗号隔开
  • one {Boolean | Number} 获取的条数
  • return {Promise}
    获取特定字段的值。

model.count(field)

  • field {String} 字段名
  • return {Promise} 返回总条数
    获取总条数。

model.sum(field)

  • field {String} 字段名
  • return {Promise}
    对字段值进行求和。

model.min(field)

  • field {String} 字段名
  • return {Promise}
    求字段的最小值。

model.max(field)

  • field {String} 字段名
  • return {Promise}
    求字段的最大值。

model.avg(field)

  • field {String} 字段名
  • return {Promise}
    求字段的平均值。

model.query(…args)

  • return {Promise}
    指定 SQL 语句执行查询。

model.execute(…args)

  • return {Promise}
    执行 SQL 语句。

model.parseSql(sql, …args)

  • sql {String} 要解析的 SQL 语句
  • return {String}
    解析 SQL 语句,调用 util.format 方法解析 SQL 语句,并将 SQL 语句中的 TABLENAME 解析为对应的表名。
  1. export default class extends think.model.base {
  2. getSql(){
  3. let sql = 'SELECT * FROM __GROUP__ WHERE id=%d';
  4. sql = this.parseSql(sql, 10);
  5. //sql is SELECT * FROM think_group WHERE id=10
  6. }
  7. }

model.startTrans()

  • return {Promise}
    开启事务。

model.commit()

  • return {Promise}
    提交事务。

model.rollback()

  • return {Promise}
    回滚事务。

model.transaction(fn)

  • fn {Function} 要执行的函数
  • return {Promise}
    使用事务来执行传递的函数,函数要返回 Promise。
  1. export default class extends think.model.base {
  2. updateData(data){
  3. return this.transaction(async () => {
  4. let insertId = await this.add(data);
  5. let result = await this.model('user_cate').add({user_id: insertId, cate_id: 100});
  6. return result;
  7. })
  8. }
  9. }

原文: https://thinkjs.org/zh-cn/doc/2.1/api_model.html