es6 获取动态json 里的key值和value

在ES6中，获取动态JSON对象中的键值对可以使用`Object.keys()`和`Object.values()`方法，或者直接通过点运算符(`.`)或方括号运算符(`[]`)访问对象属性。假设我们有一个动态的JSON对象：

let dynamicJson = {
  "name": "John",
  "age": 30,
  "city": "New York"
};

你可以这样获取键值：

1. 键名和对应的值：

   let key = Object.keys(dynamicJson)[0]; // "name" 或者 "age" 或 "city"
   let value = dynamicJson[key]; // "John", 30, 或 "New York"

2. 使用方括号语法获取值：

   let key = "name";
   let value = dynamicJson[key]; // "John"

如果JSON对象的结构复杂，比如嵌套了其他对象，你可以递归地遍历它。对于动态路径，可以使用`get()`函数或者`eval()`（注意安全性问题），但通常不推荐后者。

相关问题

es6 json转字符串

在ES6中，可以使用JSON.stringify()方法将JSON对象转换为字符串。例如：

const myJson = { name: "John", age: 30 };
const jsonString = JSON.stringify(myJson);
console.log(jsonString); // 输出: {"name":"John","age":30}

注意，如果JSON对象中有函数或Symbol类型的属性，则在转换为字符串时会被忽略。如果需要保留这些属性，可以传入一个函数作为第二个参数，该函数可以自定义转换过程。例如：

const myJson = { 
  name: "John", 
  age: 30, 
  sayHello: function() { console.log("Hello!"); },
  [Symbol("id")]: "123"
};

const jsonString = JSON.stringify(myJson, (key, value) => {
  if (typeof value === "function" || typeof value === "symbol") {
    return value.toString();
  }
  return value;
});

console.log(jsonString); // 输出: {"name":"John","age":30,"sayHello":"function() { console.log(\"Hello!\"); }","Symbol(id)":"123"}

只有两个数组对象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 对象默认使用的是对象的引用地址进行比较，而不是对象的属性值。因此，需要将对象转换成字符串后再进行比较。