归类函数、扁平化数组

发表于 | 分类于
  • 归类函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/**
 * 
 * @param {Array} sort 
 * @param {Array} data 
 * @param {String} foreign_key 分类key
 * @param {String} sortType single | multi  
 * @returns 
 */
export function sortData(sort, data) {
  var cache = {}

  return function (foreign_key, sortType) {
    if (sortType !== 'single' && sortType !== 'multi') {
      console.log(new Error('Invalid sort type.[Only "single" and "multi" are valid values]'));
      return
    }
    sort.forEach(function (sort) {
      var _id = sort.id
      cache[_id] = []
      data.forEach(function (elem) {
        var foreign_val = elem[foreign_key]
        switch (sortType) {
          case "single":
            if (foreign_val == _id) {
              cache[_id].push(elem)
            }
            break;
          case 'multi':
            var _arr = foreign_val.split(',')
            _arr.forEach(function (val) {
              if (val == _id) {
                cache[_id].push(elem)
              }
            })
            break;
          default:
            break;
        }
      })
    })
    return cache
  }
}
  • 扁平化数组
    • 四种方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 function flatten1(arr) {
  var _arr = arr || [],
    fArr = [],
    len = _arr.length,
    item;
  for (var i = 0; i < len; i++) {
    item = _arr[i]
    if (_isArr(item)) {
      fArr = fArr.concat(flatten(item))
    } else {
      fArr.push(item)
    }
  }
  return fArr
  function _isArr(obj) {
    return Object.prototype.toString.call(obj) === '[Object Array]'
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
function flatten2(arr) {
  var _arr = arr || [],
    toStr = {}.toString,
    fArr = [];

  _arr.forEach(function (elem) {
    toStr.call(elem) === '[Object Array]'
      ? fArr = fArr.concat(flatten2())
      : fArr.push(elem)
  })
  return fArr
}
1
2
3
4
5
6
7
8
9
10
11
function flatten3(arr) {
  var _arr = arr || [],
    toStr = {}.toString,
    fArr = [];

  return _arr.reduce(function (prev, elem) {
    return prev.concat = toStr.call(elem) === '[Object Array]'
      ? flatten3(elem)
      : elem
  })
}
1
2
3
4
5
6
const flatten4 = arr =>
  arr.reduce((prev, elem) => prev.concat(
    {}.toString().call(elem) === '[Object Array]'
      ? flatten4(elem)
      : elem
  ), [])