Me gustaría comenzar a usar ES6 Map en lugar de objetos JS, pero me están reteniendo porque no puedo averiguar cómo JSON.stringify () un mapa. Se garantiza que mis claves serán cadenas y mis valores siempre estarán listados. ¿Realmente tengo que escribir un método contenedor para serializar?

No puedes.

Las claves de un mapa pueden ser cualquier cosa, incluidos los objetos. Pero la sintaxis JSON solo permite cadenas como claves. Entonces es imposible en un caso general.

Se garantiza que mis claves serán cadenas y mis valores siempre serán listas

En este caso, puede utilizar un objeto simple. Tendrá estas ventajas:

• Se podrá encadenar a JSON.
• Funcionará en navegadores más antiguos.
• Puede que sea más rápido.

No puede secuenciar directamente la Mapinstancia ya que no tiene ninguna propiedad, pero puede convertirla en una matriz de tuplas:

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

Para el reverso, use

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

Ambos JSON.stringifyy JSON.parseapoyan un segundo argumento. replacery reviverrespectivamente. Con el reemplazo y el reviver a continuación, es posible agregar soporte para el objeto Map nativo, incluidos los valores profundamente anidados

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

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

Uso :

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

Anidación profunda con combinación de matrices, objetos y mapas

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

Si bien ecmascript aún no proporciona un método, esto aún se puede hacer usando JSON.stingifysi asigna el Mapa una primitiva de JavaScript. Aquí está la muestra Mapque usaremos.

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

Ir a un objeto JavaScript

Puede convertir a JavaScript Object literal con la siguiente función auxiliar.

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

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

Ir a una matriz de objetos de JavaScript

La función de ayuda para este sería aún más compacta

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

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

Ir a Matriz de matrices

Esto es aún más fácil, solo puede usar

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

El uso de spread sytax Map se puede serializar en una línea:

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

y deserializarlo con:

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

Cadena de una Mapinstancia (los objetos como claves están bien) :

JSON.stringify([...map])

o

JSON.stringify(Array.from(map))

o

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

formato de salida:

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

Una mejor solucion

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

Salida

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

Espero que sea menos vergonzoso que las respuestas anteriores.

La siguiente solución funciona incluso si tiene mapas anidados

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