Comment dois-je persister un ES6 Carte dans localstorage (ou ailleurs)?

En supposant que les deux vos clés et vos valeurs sont serialisable,

localStorage.myMap = JSON.stringify(Array.from(map.entries()));

devrait fonctionner. Pour l'inverse, l'utilisation

map = new Map(JSON.parse(localStorage.myMap));

Construction de Oriol est réponse, nous pouvons faire un peu mieux. On peut encore utiliser des références d'objet pour les clés tant que l'on est racine primitive ou l'entrée dans la carte, et chaque objet clé peut être transitivement trouvés à partir de la racine de la clé.

Modifiant Oriol l'exemple de l'utilisation de Douglas Crockford de JSON.decycle et JSON.retrocycle nous pouvons créer une carte qui gère ce cas:

var key = {},
    map1 = new Map([ [1, key], [key, 3] ]),
    map2 = new Map(JSON.parse(JSON.stringify([...map1.entries()]))),
    map3 = new Map(JSON.retrocycle(JSON.parse(JSON.stringify(JSON.decycle([...map1.entries()])))));
map1.get(1); //key
map2.get(1); //key
map3.get(1); //key
map1.get(map1.get(1)); //3 :)
map2.get(map2.get(1)); //undefined :(
map3.get(map3.get(1)); //3 :)

Decycle et retrocycle faire il possible d'encoder cyclique des structures et des dags en JSON. Ceci est utile si nous voulons établir des relations entre des objets, sans créer de nouvelles propriétés sur les objets eux-mêmes, ou que vous voulez de façon interchangeable concernent des primitives pour les objets et vice-versa, à l'aide d'un ES6 Carte.

L'un écueil, c'est que nous ne peut pas utiliser la clé d'origine de l'objet pour la nouvelle carte (map3.get(key); serait de retour indéfini). Toutefois, le maintien de la clé d'origine de référence, mais une nouvelle analysé JSON carte semble être un cas très improbable à jamais.

La accepté de répondre échoue lorsque vous avez des multiples dimensions des Cartes. On devrait toujours garder à l'esprit que, une Carte objet peut prendre une autre Carte de l'objet comme une clé ou une valeur.

Donc une meilleure et plus sûre de la manipulation de ce travail pourrait être comme suit;

function arrayifyMap(m){
  return m.constructor === Map ? [...m].map(([v,k]) => [arrayifyMap(v),arrayifyMap(k)])
                               : m;
}

Une fois que vous avez cet outil, vous pouvez toujours faire comme;

localStorage.myMap = JSON.stringify(arrayifyMap(myMap))

Une chose qui est à gauche outis que la Carte est un COMMANDÉ structure - c'est à dire lors de l'itération le premier élément entré serait la première liste.

C'est PAS comme un Objet Javascript. J'ai ce type de structure (j'ai donc utilisé la Carte), puis de trouver que le JSON.stringify ne fonctionne pas est douloureux (mais compréhensible).

J'ai fini par faire un " value_to_json fonction, ce qui signifie que l'analyse de TOUT le
à l'aide de JSON.stringify seulement pour les plus de base "types".

Malheureusement sous-classement, CARTE, avec un .la méthode toJSON() ne fonctionne pas comme il l'exclut pas une valeur d'un JSON_string. Aussi il est considéré comme l'héritage.

Mon cas d'utilisation serait exceptionnel si.

connexes:

• https://github.com/DavidBruant/Map-Set.prototype.toJSON/issues/16
• JSON à gauche en sortant de l'Infini et NaN; JSON état dans ECMAScript?
• Comment stringify les objets contenant de l'ES5 Jeux et des Cartes?
• JSON stringify un Ensemble

JS:

function value_to_json(value) {
if (value === null) {
return 'null';
}
if (value === undefined) {
return 'null';
}
//DEAL WITH +/- INF at your leisure - null instead..
const type = typeof value;
//handle as much as possible taht have no side effects. function could
//return some MAP /SET -> TODO, but not likely
if (['string', 'boolean', 'number', 'function'].includes(type)) {
return JSON.stringify(value)
} else if (Object.prototype.toString.call(value) === '[object Object]') {
let parts = [];
for (let key in value) {
if (Object.prototype.hasOwnProperty.call(value, key)) {
parts.push(JSON.stringify(key) + ': ' + value_to_json(value[key]));
}
}
return '{' + parts.join(',') + '}';
}
else if (value instanceof Map) {
let parts_in_order = [];
value.forEach((entry, key) => {
if (typeof key === 'string') {
parts_in_order.push(JSON.stringify(key) + ':' + value_to_json(entry));
} else {
console.log('Non String KEYS in MAP not directly supported');
}
//FOR OTHER KEY TYPES ADD CUSTOM... 'Key' encoding...
});
return '{' + parts_in_order.join(',') + '}';
} else if (typeof value[Symbol.iterator] !== "undefined") {
//Other iterables like SET (also in ORDER)
let parts = [];
for (let entry of value) {
parts.push(value_to_json(entry))
}
return '[' + parts.join(',') + ']';
} else {
return JSON.stringify(value)
}
}
let m = new Map();
m.set('first', 'first_value');
m.set('second', 'second_value');
let m2 = new Map();
m2.set('nested', 'nested_value');
m.set('sub_map', m2);
let map_in_array = new Map();
map_in_array.set('key', 'value');
let set1 = new Set(["1", 2, 3.0, 4]);
m2.set('array_here', [map_in_array, "Hello", true, 0.1, null, undefined, Number.POSITIVE_INFINITY, {
"a": 4
}]);
m2.set('a set: ', set1);
const test = {
"hello": "ok",
"map": m
};
console.log(value_to_json(test));