数据格式间相互转化（持续更新）

1.Set 结构-》数组

1. const items = new Set([1, 2, 3, 4, 5]);
2. const array = Array.from(items);

2. map 结构-》数组

1.Map 结构转为数组结构，比较快速的方法是使用扩展运算符（...）

1. const map = new Map([
2. [1, 'one'],
3. [2, 'two'],
4. [3, 'three'],
5. ]);
7. [...map.keys()]
8. // [1, 2, 3]
10. [...map.values()]
11. // ['one', 'two', 'three']
13. [...map.entries()]
14. // [[1,'one'], [2, 'two'], [3, 'three']]
16. [...map]
17. // [[1,'one'], [2, 'two'], [3, 'three']]

3.数组 转为 Map(将数组传入 Map 构造函数，就可以转为 Map)

4.数组 转为Set(将数组传入Set构造函数，就可以转为Set)

5.Map 转为对象(如果所有 Map 的键都是字符串，它可以无损地转为对象。)

1. function strMapToObj(strMap) {
2. let obj = Object.create(null);
3. for (let [k,v] of strMap) {
4. obj[k] = v;
5. }
6. return obj;
7. }
9. const myMap = new Map()
10. .set('yes', true)
11. .set('no', false);
12. strMapToObj(myMap)
13. // { yes: true, no: false }

6.对象转为 Map

1)对象转为 Map 可以通过Object.entries()

2)也可以自己实现一个转换函数。

     //对象转为 Map 可以通过Object.entries()

1. let obj = {"a":1, "b":2};
2. let map = new Map(Object.entries(obj));

    //自己实现一个转换函数

    

1. function objToStrMap(obj) {
2. let strMap = new Map();
3. for (let k of Object.keys(obj)) {
4. strMap.set(k, obj[k]);
5. }
6. return strMap;
7. }
9. objToStrMap({yes: true, no: false})
10. // Map {"yes" => true, "no" => false}

7.map转为对象：Object.fromEntries()

    //键值对转为对象

1. Object.fromEntries([
2. ['foo', 'bar'],
3. ['baz', 42]
4. ])
5. // { foo: "bar", baz: 42 }

    //map转为对象

1. const entries = new Map([
2. ['foo', 'bar'],
3. ['baz', 42]
4. ]);
6. Object.fromEntries(entries)
7. // { foo: "bar", baz: 42 }

8.将查询字符串转为对象

1. Object.fromEntries(new URLSearchParams('foo=bar&baz=qux'))

9.Map 转为 JSON

1)Map 的键名都是字符串，这时可以选择转为对象 JSON

1. function strMapToJson(strMap) {
2. return JSON.stringify(strMapToObj(strMap));
3. }
5. let myMap = new Map().set('yes', true).set('no', false);
6. strMapToJson(myMap)
7. // '{"yes":true,"no":false}'

2)Map 的键名有非字符串，这时可以选择转为数组 JSON。

1. function mapToArrayJson(map) {
2. return JSON.stringify([...map]);
3. }
5. let myMap = new Map().set(true, 7).set({foo: 3}, ['abc']);
6. mapToArrayJson(myMap)
7. // '[[true,7],[{"foo":3},["abc"]]]'

10.JSON 转为 Map

1)所有键名都是字符串

1. function jsonToStrMap(jsonStr) {
2. return objToStrMap(JSON.parse(jsonStr));
3. }
5. jsonToStrMap('{"yes": true, "no": false}')
6. // Map {'yes' => true, 'no' => false}

2)整个 JSON 就是一个数组，且每个数组成员本身，又是一个有两个成员的数组。这时，它可以一一对应地转为 Map。这往往是 Map 转为数组 JSON 的逆操作。

1. function jsonToMap(jsonStr) {
2. return new Map(JSON.parse(jsonStr));
3. }
5. jsonToMap('[[true,7],[{"foo":3},["abc"]]]')
6. // Map {true => 7, Object {foo: 3} => ['abc']}

11.对象转为数组：Object.keys

1. for (var key of Object.keys(someObject)) {
2. console.log(key + ': ' + someObject[key]);
3. }

12.数组转字符串：arr.join()

 

1. var arr=[1,2,3,4];

2. console.log(arr.join()); //1,2,3,4

3. console.log(arr.join(":")); //1:2:3:4

4. console.log(arr); //[1,2,3,4],原数组不变