js 遍历对象取key放入数组

以下是两种JavaScript遍历对象取key放入数组的方法：

1.使用Object.keys()方法

let obj = { name: '小明', age: '20' };
let keys = Object.keys(obj);
console.log(keys); // 输出：['name', 'age']

2.使用Reflect.ownKeys()方法

let obj = { name: '小明', age: '20' };
let keys = Reflect.ownKeys(obj);
console.log(keys); // 输出：['name', 'age']

相关问题

只有两个数组对象A和B对象只有两个key值oid和typeiid，AB两个数组对进行比较，如果对象中的oid和typeiid相同就将这个对象放入arr1数组中，如果A有B没有就将这个对象放入arr2中，如果B有A没有就将这个对象放入arr3中 用ES6语法

可以使用 ES6 中的 Set 和 Map 对象来实现这个功能。具体步骤如下：

// 定义两个数组 A 和 B，存放对象
const A = [{oid: 1, typeiid: 2, name: 'obj1'}, {oid: 2, typeiid: 1, name: 'obj2'}];
const B = [{oid: 1, typeiid: 2, name: 'obj3'}, {oid: 3, typeiid: 2, name: 'obj4'}];

// 定义三个 Set 对象，用于存放 A、B、AB 共有的对象
const setA = new Set(A);
const setB = new Set(B);
const setAB = new Set();

// 定义三个 Map 对象，用于存放 A 有 B 没有的对象（arr2）、B 有 A 没有的对象（arr3）以及 AB 共有的对象（arr1）
const map2 = new Map();
const map3 = new Map();
const map1 = new Map();

// 遍历 A 数组，将 A 和 B 共有的对象存入 setAB 中
A.forEach(objA => {
  B.forEach(objB => {
    if (objA.oid === objB.oid && objA.typeiid === objB.typeiid) {
      setAB.add(objA);
    }
  })
});

// 遍历 setAB，将其中的对象存入 map1 中
setAB.forEach(obj => {
  map1.set(JSON.stringify(obj), obj);
});

// 遍历 A 数组，将 A 有 B 没有的对象存入 map2 中
A.forEach(objA => {
  if (!setB.has(objA)) {
    map2.set(JSON.stringify(objA), objA);
  }
});

// 遍历 B 数组，将 B 有 A 没有的对象存入 map3 中
B.forEach(objB => {
  if (!setA.has(objB)) {
    map3.set(JSON.stringify(objB), objB);
  }
});

// 将 map1、map2、map3 转换成对应的数组 arr1、arr2、arr3
const arr1 = Array.from(map1.values());
const arr2 = Array.from(map2.values());
const arr3 = Array.from(map3.values());

解释一下代码的思路：

1. 首先使用 Set 对象将 A 和 B 数组中的对象去重，并分别存放到 setA 和 setB 中；
2. 使用 Set 对象 setAB 存放 A 和 B 共有的对象；
3. 使用 Map 对象 map1 存放 AB 共有的对象，其 key 值为对象的 JSON 字符串，value 值为对象本身；
4. 使用 Map 对象 map2 存放 A 有 B 没有的对象，其 key 值为对象的 JSON 字符串，value 值为对象本身；
5. 使用 Map 对象 map3 存放 B 有 A 没有的对象，其 key 值为对象的 JSON 字符串，value 值为对象本身；
6. 最后将 map1、map2、map3 转换成对应的数组 arr1、arr2、arr3 即可。

需要注意的是，上述代码中使用了 JSON.stringify 将对象转换成字符串，这是因为 Set 对象和 Map 对象默认使用的是对象的引用地址进行比较，而不是对象的属性值。因此，需要将对象转换成字符串后再进行比较。

只有两个数组对象A和B对象只有两个参数值oid和typeiid，AB两个数组对进行比较，如果对象中的oid和typeiid相同就将这个对象放入arr1数组中，如果A有B没有就将这个对象放入arr2中，如果B有A没有就将这个对象放入arr3中 用ES6语法

可以使用 ES6 中的 Set 和 Map 对象来实现这个功能。具体步骤如下：

// 定义两个数组 A 和 B，存放对象
const A = [{oid: 1, typeiid: 2}, {oid: 2, typeiid: 1}];
const B = [{oid: 1, typeiid: 2}, {oid: 3, typeiid: 2}];

// 定义三个 Set 对象，用于存放 A、B、AB 共有的对象
const setA = new Set(A.map(obj => JSON.stringify(obj)));
const setB = new Set(B.map(obj => JSON.stringify(obj)));
const setAB = new Set();

// 定义三个 Map 对象，用于存放 A 有 B 没有的对象（arr2）、B 有 A 没有的对象（arr3）以及 AB 共有的对象（arr1）
const map2 = new Map();
const map3 = new Map();
const map1 = new Map();

// 遍历 A 数组，将 A 和 B 共有的对象存入 setAB 中
setA.forEach(strA => {
  if (setB.has(strA)) {
    setAB.add(strA);
  }
});

// 遍历 setAB，将其中的对象存入 map1 中
setAB.forEach(strAB => {
  map1.set(strAB, JSON.parse(strAB));
});

// 遍历 A 数组，将 A 有 B 没有的对象存入 map2 中
setA.forEach(strA => {
  if (!setB.has(strA)) {
    map2.set(strA, JSON.parse(strA));
  }
});

// 遍历 B 数组，将 B 有 A 没有的对象存入 map3 中
setB.forEach(strB => {
  if (!setA.has(strB)) {
    map3.set(strB, JSON.parse(strB));
  }
});

// 将 map1、map2、map3 转换成对应的数组 arr1、arr2、arr3
const arr1 = Array.from(map1.values());
const arr2 = Array.from(map2.values());
const arr3 = Array.from(map3.values());

解释一下代码的思路：

1. 首先使用 Array.map 方法将 A 和 B 数组中的对象转换成 JSON 字符串，并分别存放到 setA 和 setB 中；
2. 使用 Set 对象 setAB 存放 A 和 B 共有的对象的 JSON 字符串；
3. 使用 Map 对象 map1 存放 AB 共有的对象，其 key 值为对象的 JSON 字符串，value 值为对象本身；
4. 使用 Map 对象 map2 存放 A 有 B 没有的对象，其 key 值为对象的 JSON 字符串，value 值为对象本身；
5. 使用 Map 对象 map3 存放 B 有 A 没有的对象，其 key 值为对象的 JSON 字符串，value 值为对象本身；
6. 最后将 map1、map2、map3 转换成对应的数组 arr1、arr2、arr3 即可。

需要注意的是，上述代码中使用了 JSON.stringify 将对象转换成字符串，并且使用了 Set 对象的 has 方法进行比较，这是因为 Set 对象默认使用的是对象的引用地址进行比较，而不是对象的属性值。因此，需要将对象转换成字符串后再进行比较。在存放到 Map 对象中后，需要使用 JSON.parse 将字符串转换成对象。