MyBatis-Link

# query.js

采用query的传参方式，前端在进行过滤查询的时候，需要拼接一段json字符串，然后再传给后端进行查询操作。

TIP

前端开发人员往往需要不同的查询条件进行删选所需要的数据，这里将会面对几个普遍的问题：

  1. 由于需求的变动，今天需要2个查询条件，明天需要5个查询条件。
  2. 需要根据某个字段，或者某几个字段进行排序。
  3. 需要可以定义灵活定义获取几条数据，或者要不要获取总数。

# query.js

在介绍怎么使用query之前，首先介绍一下 query.js。通过这个js，可以对query查询进行快速拼装，而且不容易出错。

const query = {}

/**
 * w （已经弃用，请使用R）过滤条件
 * r 过滤条件
 * o 排序
 * j 左连接、右连接 ON 后面过滤条件，主要面向后端开发人员
 * p 分页条件
 * s 过滤字段
 */
query.new = () => {
  return {
    'w': [],
    'r': [],
    'o': [],
    'j': [],
    'p': {},
    's': {}
  }
}

/**
 * 数组过滤条件
 * @param {query} q
 * @param {array} arrKv 数组：key/value
 * @param {array} arrKm 数组：key/mode
 */
query.toF = (q, arrKv, arrKm, arrKt) => {
  for (var i in arrKv) {
    // query.toR(q, i, arrKv[i], arrKm[i])
    query.toR(q, i, arrKv[i], arrKm[i], 'and', 0, arrKt[i])
  }
  return q
}

/**
 * 过滤条件
 * @param {query} q
 * @param {key} k
 * @param {value} v
 * @param {mode} m 默认值（LK）非必填
 * @param {type} t1 默认值（and）非必填
 * @param {seq} s 默认值（0）非必填
 * @param {name} n 默认值（a1）非必填
 * @param {type} t 默认值（and）非必填
 */
query.toR = (q, k, v, m, t1, s, n, t) => {
  if (v === '' || typeof v === 'undefined') {
    return q
  }
  if (m === 'IS' || m === 'NIS') {
  } else {
    if (v === null) {
      return q
    }
  }
  if (typeof m === 'undefined' || m === null) {
    m = 'LK'
  }
  if (typeof n === 'undefined' || n === null) {
    n = 'a1'
  }
  if (typeof t === 'undefined' || t === null) {
    t = 'and'
  }
  if (typeof t1 === 'undefined' || t1 === null) {
    t1 = 'and'
  }
  if (typeof s === 'undefined' || s === null) {
    s = 0
  }
  let rObj = null
  q.r.forEach(function (val, i) {
    if (val.n === n) {
      rObj = val
    }
  })
  if (rObj) {
    rObj.w.push({
      'k': k,
      'v': v,
      'm': m,
      't': t1,
      's': s
    })
  } else {
    q.r.push({
      'n': n,
      't': t,
      'w': [{
        'k': k,
        'v': v,
        'm': m,
        't': t1,
        's': s
      }]
    })
  }
  return q
}

/**
 * 过滤条件（已经弃用，请使用toR方法）
 * @param {query} q
 * @param {key} k
 * @param {value} v
 * @param {mode} m 默认值（LK）非必填
 * @param {type} t1 默认值（and）非必填
 * @param {seq} s 默认值（0）非必填
 */
query.toW = (q, k, v, m, t1, s) => {
  if (v === '') {
    return q
  }
  if (m === 'IS' || m === 'NIS') {
  } else {
    if (v === null) {
      return q
    }
  }
  if (typeof m === 'undefined') {
    m = 'LK'
  }
  if (typeof t1 === 'undefined') {
    t1 = 'and'
  }
  if (typeof s === 'undefined') {
    s = 0
  }
  q.w.push({
    'k': k,
    'v': v,
    'm': m,
    't': t1,
    's': s
  })
  return q
}

/**
 * 过滤条件（已经弃用，请使用toR方法）
 * @param {query} q
 * @param {key} k
 */
query.toWNull = (q, k) => {
  q.w.push({
    'k': k,
    'v': null,
    'm': 'IS'
  })
  return q
}

/**
 * 左连接、右连接 ON 后面过滤条件
 * @param {query} q
 * @param {key} k
 * @param {value} v
 * @param {mode} m 默认值（LK）非必填
 * @param {name} n 设置联表查询时，ON的参数名
 * @param {type} t1 默认值（and）非必填
 * @param {seq} s 默认值（0）非必填
 */
query.toJ = (q, k, v, m, n, t1, s) => {
  if (v === null || v === '') {
    return q
  }
  if (typeof m === 'undefined') {
    m = 'LK'
  }
  if (typeof t1 === 'undefined') {
    t1 = 'and'
  }
  if (typeof s === 'undefined') {
    s = 0
  }
  let rObj = null
  q.j.forEach(function (val, i) {
    if (val.n === n) {
      rObj = val
    }
  })
  console.log(rObj)
  if (rObj) {
    rObj.r[0].w.push({
      'k': k,
      'v': v,
      'm': m,
      't': t1,
      's': s
    })
  } else {
    q.j.push({
      'n': n,
      'r': [{
        't': 'and',
        'w': [{
          'k': k,
          'v': v,
          'm': m,
          't': t1,
          's': s
        }]
      }]
    })
  }
  return q
}

/**
 * 排序
 * @param {query} q
 * @param {key} k 排序字段
 * @param {type} t 升序还是降序 asc or desc
 */
query.toO = (q, k, t) => {
  if (typeof k === 'undefined' || k === '') {
    return q
  }
  if (typeof t === 'undefined') {
    t = 'desc'
  }
  q.o.push({
    'k': k,
    't': t
  })
  return q
}

/**
 * 分页条件
 * @param {query} q
 * @param {pageNo} n 第几页
 * @param {pageSize} s 每页条数
 * @param {count} c 是否查询总数，非必填，如果设置为1，则不会查询总数
 */
query.toP = (q, n, s, c) => {
  if (typeof c === 'undefined' || c === '') {
    c = 0
  }
  q.p = {
    'n': n,
    's': s,
    'c': c
  }
  return q
}

/**
 * 过滤字段
 * @param {query} q
 * @param {value} v 过滤字段，支持String类型多个字段(",")逗号隔开
 * 如："username,mob"，或者进行数组赋值，如：["username", "mob"]
 */
query.toS = (q, v) => {
  q.s = {
    'v': v
  }
  return q
}

/**
 * query对象转string
 */
query.toJsonStr = (q) => {
  return JSON.stringify(q)
}

/**
 * 查询条件url编码
 */
query.toEncode = (q) => {
  return encodeURIComponent(JSON.stringify(q))
}

/**
 * 查询条件频接
 */
query.toQ = (q) => {
  return '?query=' + encodeURIComponent(JSON.stringify(q))
}

export default query

重要方法说明

  • toR，就是加在SQL中WHERE后的查询条件。
  • toW，就是加在SQL中WHERE后的查询条件，现在已经弃用，用toR代替。
  • toP，分页查询，设置第几页，每页几行的数据。
  • toO，数据排序。
  • toS，过滤查询字段。
  • toJ，左连接或者右连接查询，加在SQL中ON后的查询条件。

# 过滤模式

前端可以控制使用什么类型的查询方式，等于，模糊等

EQ(" = ", "等于"), 
NE(" <> ", "不等于"), 
LK(" like ", "包含"), 
LLK(" like ", "左包含"), 
RLK(" like ", "右包含"), 
NLK(" not like ", "不包含"), 
IN(" in ", "在..中"), 
NIN(" not in ", "不在..中"),
LT(" < ", "小于"), 
LE(" <= ", "小于等于"), 
GT(" > ", "大于"), 
GE(" >= ", "大于等于"), 
BT(" between ", "位于..和..之间"),
IS(" is ", "是"),
NIS(" is not ", "不是"),
ASC(" asc ", "升序"),
DESC(" desc ", "降序"),
AND("and", "and"),
OR("or", "or"),

← query查询 →

赞助商