你如何 JSON.stringify ES6 Map？

Question

我想开始使用 ES6 Map 而不是 JS 对象，但我被阻止了，因为我不知道如何使用 JSON.stringify() 和 Map。我的键保证是字符串，我的值将始终被列出。我真的要写一个包装方法来序列化吗？

Answer 1

你不能。

地图的键可以是任何东西，包括对象。但是 JSON 语法只允许字符串作为键。所以一般情况下是不可能的。

我的键保证是字符串，我的值总是列表

在这种情况下，您可以使用普通对象。它将具有以下优点：

• 它将能够被字符串化为 JSON。
• 它适用于旧版浏览器。
• 可能会更快。

Answer 2

您不能直接对 Map 实例进行字符串化，因为它没有任何属性，但您可以将其转换为元组数组：

jsonText = JSON.stringify(Array.from(map.entries()));

反之，使用

map = new Map(JSON.parse(jsonText));

Answer 3

虽然 ecmascript 还没有提供方法，但如果您将 Map 映射到 JavaScript 原语，这仍然可以使用 JSON.stingify 完成。这是我们将使用的示例Map。

const map = new Map();
map.set('foo', 'bar');
map.set('baz', 'quz');

转到一个 JavaScript 对象

您可以使用以下辅助函数将其转换为 JavaScript 对象字面量。

const mapToObj = m => {
  return Array.from(m).reduce((obj, [key, value]) => {
    obj[key] = value;
    return obj;
  }, {});
};

JSON.stringify(mapToObj(map)); // '{"foo":"bar","baz":"quz"}'

转到 JavaScript 对象数组

这个的辅助函数会更紧凑

const mapToAoO = m => {
  return Array.from(m).map( ([k,v]) => {return {[k]:v}} );
};

JSON.stringify(mapToAoO(map)); // '[{"foo":"bar"},{"baz":"quz"}]'

转到数组数组

这更简单，你可以使用

JSON.stringify( Array.from(map) ); // '[["foo","bar"],["baz","quz"]]'

Answer 4

JSON.stringify 和 JSON.parse 都支持第二个参数。 replacer 和 reviver 分别。使用下面的替换器和恢复器，可以添加对原生 Map 对象的支持，包括深度嵌套的值

function replacer(key, value) {
  if(value instanceof Map) {
    return {
      dataType: 'Map',
      value: Array.from(value.entries()), // or with spread: value: [...value]
    };
  } else {
    return value;
  }
}

function reviver(key, value) {
  if(typeof value === 'object' && value !== null) {
    if (value.dataType === 'Map') {
      return new Map(value.value);
    }
  }
  return value;
}

用法：

const originalValue = new Map([['a', 1]]);
const str = JSON.stringify(originalValue, replacer);
const newValue = JSON.parse(str, reviver);
console.log(originalValue, newValue);

结合数组、对象和映射的深度嵌套

const originalValue = [
  new Map([['a', {
    b: {
      c: new Map([['d', 'text']])
    }
  }]])
];
const str = JSON.stringify(originalValue, replacer);
const newValue = JSON.parse(str, reviver);
console.log(originalValue, newValue);

Answer 5

即使您有嵌套地图，以下解决方案也可以使用

function stringifyMap(myMap) {
    function selfIterator(map) {
        return Array.from(map).reduce((acc, [key, value]) => {
            if (value instanceof Map) {
                acc[key] = selfIterator(value);
            } else {
                acc[key] = value;
            }

            return acc;
        }, {})
    }

    const res = selfIterator(myMap)
    return JSON.stringify(res);
}

Answer 6

使用spread sytax Map 可以在一行内序列化：

JSON.stringify([...new Map()]);

并反序列化它：

let map = new Map(JSON.parse(map));

Answer 7

更好的解决方案

    // somewhere...
    class Klass extends Map {

        toJSON() {
            var object = { };
            for (let [key, value] of this) object[key] = value;
            return object;
        }

    }

    // somewhere else...
    import { Klass as Map } from '@core/utilities/ds/map';  // <--wherever "somewhere" is

    var map = new Map();
    map.set('a', 1);
    map.set('b', { datum: true });
    map.set('c', [ 1,2,3 ]);
    map.set( 'd', new Map([ ['e', true] ]) );

    var json = JSON.stringify(map, null, '\t');
    console.log('>', json);

输出

    > {
        "a": 1,
        "b": {
            "datum": true
        },
        "c": [
            1,
            2,
            3
        ],
        "d": {
            "e": true
        }
    }

希望这比上面的答案不那么令人生畏。

Answer 8

Stringify 一个Map 实例（对象作为键是可以的）：

JSON.stringify([...map])

或

JSON.stringify(Array.from(map))

或

JSON.stringify(Array.from(map.entries()))

输出格式：

// [["key1","value1"],["key2","value2"]]

Answer 9

鉴于您的示例是一个简单的用例，其中键将是简单类型，我认为这是 JSON 字符串化 Map 的最简单方法。

JSON.stringify(Object.fromEntries(map));

我认为 Map 的底层数据结构的方式是作为键值对数组（作为数组本身）。所以，是这样的：

const myMap = new Map([
     ["key1", "value1"],
     ["key2", "value2"],
     ["key3", "value3"]
]);

因为我们在 Object.entries 中找到了底层数据结构，所以我们可以像在数组上一样在 Map 上使用 Object.fromEntries() 的原生 JavaScript 方法：

Object.fromEntries(myMap);

/*
{
     key1: "value1",
     key2: "value2",
     key3: "value3"
}
*/

然后你剩下的就是在结果上使用 JSON.stringify()。

Answer 10

只想分享我的 Map 和 Set JSON.stringify 版本。 我正在整理它们，对调试很有用...

function replacer(key, value) {
    if (value instanceof Map) {
        const reducer = (obj, mapKey) => {
            obj[mapKey] = value.get(mapKey);
            return obj;
        };
        return [...value.keys()].sort().reduce(reducer, {});
    } else if (value instanceof Set) {
        return [...value].sort();
    }
    return value;
}

用法：

const map = new Map();
const numbers= new Set()
numbers.add(3);
numbers.add(2);
numbers.add(3);
numbers.add(1);
const chars= new Set()
chars.add('b')
chars.add('a')
chars.add('a')
map.set("numbers",numbers)
map.set("chars",chars)

console.log(JSON.stringify(map, replacer, 2));

结果：

{
  "chars": [
    "a",
    "b"
  ],
  "numbers": [
    1,
    2,
    3
  ]
}

Answer 11

虽然在某些情况下，如果您是地图的创建者，您会在单独的“src”文件中编写代码并将副本另存为 .txt 文件，如果编写得足够简洁，则可以轻松阅读输入、解密并添加到服务器端。

然后，新文件将保存为 .js 并从服务器发回对它的引用。一旦作为 JS 读回，该文件就会完美地重建自身。美妙之处在于重构不需要 hacky 迭代或解析。

Answer 12

非常简单的方法。

  const map = new Map();
  map.set('Key1', "Value1");
  map.set('Key2', "Value2");
  console.log(Object.fromEntries(map));

` 输出：-

{"Key1": "Value1","Key2": "Value2"}