数组对象工作里遇到的处理数据的方法

数组对象找指定index

_.findIndex（）

var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true }
];
 
_.findIndex(users, function(o) { return o.user == 'barney'; });
// => 0
 
// The `_.matches` iteratee shorthand.
_.findIndex(users, { 'user': 'fred', 'active': false });
// => 1
 
// The `_.matchesProperty` iteratee shorthand.
_.findIndex(users, ['active', false]);
// => 0
 
// The `_.property` iteratee shorthand.
_.findIndex(users, 'active');
// => 2

数组对象，删除指定元素

_.remove（）

var array = [1, 2, 3, 4];
var evens = _.remove(array, function(n) {
  return n % 2 == 0;
});
 
console.log(array);
// => [1, 3]
 
console.log(evens);
// => [2, 4]

数组对象排序

// 数组排序
sortData (a, b) {
  return a.w - b.w
}

数组交集

let res = this.devicePerch.filter(v => resDrop.includes(v))

数组对象变成新的数组对象

let arr = _.clone(this.deviceList)
let tempArr = []
let newArr = []
for (let i = 0; i < arr.length; i++) {
    if (tempArr.indexOf(arr[i].ip) === -1) {
      newArr.push({
        ip: arr[i].ip,
        list: [arr[i]]
      })
      tempArr.push(arr[i].ip)
    } else {
      for (let j = 0; j < newArr.length; j++) {
        if (newArr[j].ip === arr[i].ip) {
          newArr[j].list.push(arr[i])
        }
      }
    }
}
this.deviceShow = _.clone(newArr)

数组,新创建一些数组列根据后面的条数

// 初始化导出时jsondata的信息，把device拿出来
for (let [index, item] of this.json_data.entries()) {
    if (item.devices && item.devices.length > 0) {
      let obj = {}
      obj = _.cloneDeep(item)
      obj.devices = undefined
      for (let iDevcie = 1; iDevcie < item.devices.length; iDevcie++) {
        await this.json_data.splice(index + 1, 0, obj)
      }
    }
}
let res = []
for (let [index, item] of this.json_data.entries()) {
    if (item.devices !== undefined && item.devices.length > 0) {
      for (let [itemIndex, itemDevice] of item.devices.entries()) {
        res[itemIndex + index] = itemDevice
      }
    }
}
// 合并到json_data
for (let [index, item] of res.entries()) {
    let newObj = {}
    this.json_data[index] = Object.assign(newObj, this.json_data[index], item)
}

map结构

this.deviceFixSelected = _.clone(this.deteleObject(this.deviceListSelected))
let keyValue = new Map()
this.deviceFixed.map((item, key) => {
  this.deviceFixSelected.map((itemSelected, keySelected) => {
      let deviceBo = _.findIndex(item.list, itemSelected)
      if (deviceBo > -1) {
        if (keyValue.has(itemSelected.ip)) {
          keyValue.set(itemSelected.ip, keyValue.get(itemSelected.ip) + 1)
        } else {
          keyValue.set(itemSelected.ip, 1)
        }
      }
  })
})
this.checkGroupAll = []
for (let [key, value] of keyValue) {
  let index = _.findIndex(this.deviceFixed, ['ip', key])
  if (this.deviceFixed[index].list.length === value) {
      if (this.checkGroupAll.indexOf(key) < 0) {
        this.checkGroupAll.push(key)
      }
  } else {
      let num = this.checkGroupAll.indexOf(key)
      if (num > -1) {
        this.checkGroupAll.splice(num, 1)
      }
  }
}

对象排序

// 对象顺序排序
objectOrder (obj) { // 排序的函数
  var newkey = Object.keys(obj).sort() // 先用Object内置类的keys方法获取要排序对象的属性名，再利用Array原型上的sort方法对获取的属性名进行排序，newkey是一个数组
  var newObj = {} // 创建一个新的对象，用于存放排好序的键值对
  for (var i = 0; i < newkey.length; i++) { // 遍历newkey数组
    newObj[newkey[i]] = obj[newkey[i]] // 向新创建的对象中按照排好的顺序依次增加键值对
  }
  return newObj // 返回排好序的新对象
}