Vorrei iniziare a utilizzare ES6 Map invece degli oggetti JS, ma sono trattenuto perché non riesco a capire come JSON.stringify () una mappa. Le mie chiavi sono garantite come stringhe e i miei valori saranno sempre elencati. Devo davvero scrivere un metodo wrapper per serializzare?

Non puoi.

Le chiavi di una mappa possono essere qualsiasi cosa, inclusi gli oggetti. Ma la sintassi JSON consente solo le stringhe come chiavi. Quindi è impossibile in un caso generale.

Le mie chiavi sono garantite come stringhe e i miei valori saranno sempre elenchi

In questo caso, puoi usare un oggetto semplice. Avrà questi vantaggi:

• Potrà essere associato a JSON.
• Funzionerà su browser meno recenti.
• Potrebbe essere più veloce.

Non puoi stringere direttamente l' Mapistanza poiché non ha proprietà, ma puoi convertirla in un array di tuple:

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

Per il contrario, usa

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

Entrambi JSON.stringifye JSON.parsesupportano un secondo argomento. replacere reviverrispettivamente. Con replacer e reviver di seguito è possibile aggiungere il supporto per l'oggetto Map nativo, inclusi valori profondamente nidificati

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

Utilizzo :

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

Annidamento profondo con combinazione di array, oggetti e mappe

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

Anche se non esiste ancora un metodo fornito da ecmascript, questo può ancora essere fatto utilizzando JSON.stingifyse si associa Mapa una primitiva JavaScript. Ecco il campione Mapche useremo.

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

Andare a un oggetto JavaScript

È possibile convertire in valore letterale oggetto JavaScript con la seguente funzione di supporto.

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

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

Andare a una matrice di oggetti JavaScript

La funzione di supporto per questo sarebbe ancora più compatta

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

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

Andando a Array of Arrays

Questo è ancora più semplice, puoi semplicemente usare

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

Utilizzando spread sytax Map può essere serializzato in una riga:

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

e deserializzalo con:

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

Stringa Mapun'istanza (gli oggetti come chiavi sono OK) :

JSON.stringify([...map])

o

JSON.stringify(Array.from(map))

o

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

formato di output:

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

Una soluzione migliore

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

Produzione

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

Spero che sia meno imbarazzante delle risposte sopra.

La soluzione di seguito funziona anche se hai Maps nidificato

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