Nie można bezpośrednio stringować instancji Map, ponieważ nie ma ona żadnych właściwości, ale można ją przekonwertować na tablicę krotek:

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

Na odwrót, użyj

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

Nie możesz.

Kluczami mapy może być wszystko, łącznie z obiektami. Ale składnia JSON zezwala tylko na ciągi jako klucze. Więc to niemożliwe w ogólnym przypadku.

Moje klucze są gwarantowane jako ciągi znaków, a moje wartości zawsze będą listami

W tym przypadku można użyć zwykłego obiektu. Będzie miał te zalety:

• będzie można przeciągnąć do JSON.
• będzie działać na starszych przeglądarkach.
Może być szybciej.

Chociaż nie ma jeszcze żadnej metody dostarczonej przez ecmascript, można to zrobić za pomocą JSON.stingify, Jeśli odwzorujesz Map na prymitywny JavaScript. Oto próbka Map, której użyjemy.

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

Przejście do obiektu JavaScript

Można przekonwertować na literalny obiekt JavaScript za pomocą następującej funkcji pomocniczej.

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

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

Przejście do tablicy obiektów JavaScript

Funkcja pomocnicza dla tego byłaby jeszcze bardziej zwarta

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

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

Going to Array of Tablice

Jest to jeszcze łatwiejsze, możesz po prostu użyć

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

Używając spread Sytax mapa może być serializowana w jednej linii:

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

I deserializuj przez:

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

Stringify a Map instancja (obiekty jako klucze są w porządku):

JSON.stringify([...map])

Lub

JSON.stringify(Array.from(map))

Lub

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

Format wyjściowy:

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

Lepsze Rozwiązanie

    // 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);

Wyjście

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

Mam nadzieję, że jest to mniej krzywe niż odpowiedzi powyżej.

Biorąc pod uwagę, że twój przykład jest prostym przypadkiem użycia, w którym klucze będą prostymi typami, myślę, że jest to najprostszy sposób na JSON stringify Mapy.

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

Sposób, w jaki myślę o podstawowej strukturze danych mapy jest tablicą par klucz-wartość (jako same tablice). Coś w tym stylu:

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

Ponieważ ta podstawowa struktura danych jest tym, co znajdujemy w obiekcie.wpisy, możemy wykorzystać natywną metodę JavaScript Object.fromEntries() na mapie tak jak na Tablica:

Object.fromEntries(myMap);

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

I zostaje Ci tylko używanie JSON.stringify () na wynik tego.

Poniżej rozwiązanie działa nawet jeśli masz zagnieżdżone Mapy

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);
}