对象修改结构

给出一个深层次嵌套对象, 要求编译成如下格式

let obj_one = {
    name: '张三',
    age: '18',
    address: '山东',
    info: {
      phone: '110',
      sex: '男'
    }
}

// 将此对象，改为 { value: { key: value } }, 结构不变
// let obj_one = {
//   '张三': { name: '张三' },
//   '18': { age: '18' }
//   '山东': { address: '山东' },
//   info: {
//     '110': { phone: '110' },
//     '男': { sex: '男' }
//   }
// }

解答

const changeObjDataFuc = obj => {
  // 定义存储对象
  let saveObj = {}
  // 判断对象内每一项是否为对象，若为对象，递归
  for (const key in obj) {
    if (Object.hasOwnProperty.call(obj, key)) {
      const item = obj[key]
      if (typeof item === 'object' && item !== null) {
        itemValue = changeObjDataFuc(item) // itemValue深层次对象
        saveObj[key] = itemValue;
      } else {
        saveObj = Object.assign(saveObj, reverseObject(key, item)); // 第一次: saveObj: { 张三: { name: "张三" }, ... }
      }
    }
  }
  return saveObj
}
const reverseObject = (key, value) => {
  return {
    [value]: { [key]: value } 
  }
}
console.log(changeObjDataFuc(obj_one))

判断两对象是否全等(只针对对象未做其他类型)

之前写过一次, 别跟我说用 JSON.stringify …

let obj_one = {
  name: '张三',
  age: '18',
  address: '山东',
  info: {
    phone: '110',
    sex: '男'
  }
}

let obj_two = {
  name: '张三',
  age: '18',
  address: '山东',
  info: {
    phone: '110',
    sex: '男'
  }
}
// 判断两个对象键值是否全部相同，若是则返回true，否则返回false

解答

const objectFind = (obj_one, obj_two) => {
  if (Object.keys(obj_one).length !== Object.keys(obj_two).length) {
    // 判断键长度
    return false
  }
  for (const key in obj_one) {
    if (Object.hasOwnProperty.call(obj_one, key)) {
      const element = obj_one[key]
      if (typeof obj_one[key] === 'object' && typeof obj_two[key] === 'object') {
        // 判断每一项与obj_two对应的每一项
        // 递归判断若不等于
        if (!objectFind(obj_one[key], obj_two[key])) return false
      } else if (obj_one[key] !== obj_two[key]) {
        // 判断属性值
        return false
      }
    }
  }
  // 都相等返回true
  return true
}
const findData = objectFind(obj_one, obj_two);
console.log(findData);

复杂结构去重

给出一个复杂结构,要求去重,并且返回数据之后格式不变

let data = [
  {
    name: '小芳',
    age: 1,
    info: [
      {
        address: '北京',
        class: '三年级二班'
      },
      {
        address: '北京',
        class: '三年级二班'
      }
    ],
    obj: {
      objInfo1: [
        {
          objinfo1: 1
        },
        {
          objinfo1: 1
        }
      ],
      objInfo2: 2
    }
  },
  {
    name: '小明',
    age: 1,
    info: [
      {
        address: '北京',
        class: '三年级二班'
      }
    ]
  },
  {
    name: '小方',
    age: 1,
    obj: {
      arr: [
        {
          name: '123',
          age: 1
        },
        {
          name: '123',
          age: 1
        }
      ]
    }
  },
  {
    name: '小芳',
    age: 1,
    info: [
      {
        address: '北京',
        class: '三年级二班'
      }
    ]
  },
  {
    name: '小芳',
    age: 1
  },
  {
    name: '小芳',
    age: 1
  }
]
// 要求data数组去重，并且为深层次递归判断，不能更改数据结构，返回一个没有重复数据的新对象
// 较难

我写的破代码(没用,逻辑,结构都不对)

这是我写的, 逻辑有问题, 结构还不对, 如果有大佬会这个题, 希望可以贴在评论区, 嘤嘤嘤

let keys_data = {} // 定义数据第一次出现列表
// --------------------------------------------------------------------------------------
// 判断对象下data中是否有重复的元素, 此方法为递归
const getData = arr => {
  let newArr = []; // 新建一个数组
  for (let i = 0; i < arr.length; i++) {
    let newObj = getRepeatData(arr[i]);
    // 将处理后的对象添加到新数组
    newArr.push(newObj);
    // 循环里面的子项
    for (const key in arr[i]) {
      if (Array.isArray(arr[i][key])) {
        getData(arr[i][key])
      } else if (typeof arr[i][key] === 'object') {
        getRepeatData(arr[i][key])
      }
    }
  }
  return newArr
}

// 对象重复判断方法
// 思路: 每一项先存储，然后用存储的判断为存储的item, key以及value是否全等, 如果全等, 那么就gg
const getRepeatData = obj => {
  for (const key in obj) {
    if (Object.hasOwnProperty.call(obj, key)) {
      const item = obj[key]
      if (Array.isArray(item)) {
        getData(item)
      }
      if (keys_data[item] === undefined) {
        keys_data[key] = item
      }
    }
  }
  obj = keys_data
  newData = obj
  return obj
}
console.log(getData(obj.data))