fix: 重写Utils.sortByOrder()的实现，解决order负数排序异常的问题 (#488)

* fix: 修复路由“order”字段 数字 无法重复的bug

* fix: 重写Utils.sortByOrder()的实现，解决order负数排序异常的问题

Author: LeeSamFong

src/lin/util/util.js

@@ -92,43 +92,31 @@ function getTypeOf(obj) {
   return map[toString.call(obj)]
 }
 
-function insertItem(item, arr) {
-  const { order } = item
-  if (!arr[order]) {
-    arr[order] = item
-    return
-  }
-  let moveBegin
-  let moveEnd
-  let pos
-  let i = order + 1
-
-  while (arr[i]) {
-    if (arr[i].order > order) {
-      if (!moveBegin) {
-        moveBegin = i
-        pos = i
-      }
+function groupByOrder(source) {
+  // 有order的放这里
+  const map = {}
+  // 没有order放这里
+  const noOrderList = []
+
+  source.forEach(s => {
+    const { order } = s
+    if (typeof order !== 'number') {
+      noOrderList.push(s)
+      return
     }
-    i += 1
-  }
 
-  if (moveBegin) {
-    moveEnd = i
-  } else {
-    pos = i
-  }
-
-  if (!moveEnd) {
-    arr[pos] = item
-    return
-  }
+    const list = map[order]
+    if (list) {
+      list.push(s)
+    } else {
+      map[order] = [s]
+    }
+  })
 
-  // 需要移动
-  for (let i = moveEnd; i >= moveBegin; i -= 1) {
-    arr[i + 1] = arr[i]
+  return {
+    orderMap: map,
+    noOrderList,
   }
-  arr[pos] = item
 }
 
 /**
@@ -137,47 +125,53 @@ function insertItem(item, arr) {
  */
 Utils.sortByOrder = (source = []) => {
   if (!Array.isArray(source)) {
-    console.error('sortByOrder 传入参数不符合要求, 应为数组', source)
+    const message = 'sortByOrder 传入参数不符合要求, 应为数组'
+    console.error(message)
+    throw new Error(message)
+  }
+
+  if (!source.length) {
     return source
   }
-  const tmp = []
-  let target = []
 
-  // 将带排序的子项添加进临时数组 tmp
-  for (let i = 0; i < source.length; i += 1) {
-    if (typeof source[i].order !== 'number') {
-      continue
-    }
-    let { order } = source[i]
-    // 支持设置倒数顺序
-    if (order < 0) {
-      order = source.length + order
-      if (order < 0) {
-        order = 0
-      }
-    }
+  // 1.根据order对数据进行分组
+  const { orderMap, noOrderList } = groupByOrder(source)
+
+  // 2.获取已存在的order
+  const orders = Object.keys(orderMap).map(o => Number(o))
+
+  // 对order进行排序
+  orders.sort((a, b) => a - b)
+
+  // 小于0的order
+  const ltZeroOrders = orders.filter(o => o < 0)
+
+  // 大于等于0的order
+  const gteZeroOrders = orders.filter(o => o >= 0)
 
-    // 确保整数
-    source[i].order = Math.floor(order)
+  const finallyArr = []
+  const gteZeroItemList = gteZeroOrders.map(o => orderMap[o]).flat()
 
-    // 插入临时数组
-    insertItem(source[i], tmp)
+  finallyArr.push(...gteZeroItemList)
+  finallyArr.push(...noOrderList)
+
+  // 如果没有小于0的order，则直接拼接
+  if (!ltZeroOrders.length) {
+    return finallyArr
   }
 
-  // 合并临时数组和原数组
-  for (let i = 0, j = 0; i < source.length; i += 1) {
-    if (typeof source[i].order === 'number') {
-      continue
-    }
-    // 找需要填的坑
-    while (tmp[j]) {
-      j += 1
+  // 将小于0的order的item插入到数组中
+  ltZeroOrders.reverse().forEach(o => {
+    let index = finallyArr.length + o + 1
+    if (index < 0) {
+      index = 0
     }
-    tmp[j] = source[i]
-  }
-  // 筛除空隙
-  target = tmp.filter(item => !!item)
-  return target
+
+    const arr = orderMap[o]
+    finallyArr.splice(index, 0, ...arr)
+  })
+
+  return finallyArr
 }
 
 /**