JS nesneleri yerine ES6 Haritasını kullanmaya başlamak istiyorum ama geri çekiliyorum çünkü JSON.stringify () a Map'i nasıl yapacağımı çözemiyorum. Anahtarlarımın dizi olması garantilidir ve değerlerim her zaman listelenecektir. Serileştirmek için gerçekten bir sarmalayıcı yöntemi yazmam gerekiyor mu?

İkisi de JSON.stringifyve JSON.parseikinci bir argümanı destekler. replacerve reviversırasıyla. Değiştirici ve değiştirici ile, derinlemesine iç içe geçmiş değerler dahil olmak üzere yerel Harita nesnesi için destek eklemek mümkündür

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

Kullanım :

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

Diziler, Nesneler ve Haritalar kombinasyonu ile derinlemesine yerleştirme

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

MapHerhangi bir özelliğe sahip olmadığı için örneği doğrudan dizileme yapamazsınız , ancak onu bir demet dizisine dönüştürebilirsiniz:

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

Tersi için kullanın

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

Yapamazsın.

Bir haritanın anahtarları, nesneler dahil herhangi bir şey olabilir. Ancak JSON sözdizimi yalnızca dizelere anahtar olarak izin verir. Yani genel bir durumda imkansızdır.

Anahtarlarımın dize olması garantilidir ve değerlerim her zaman liste olacaktır

Bu durumda düz bir nesne kullanabilirsiniz. Şu avantajlara sahip olacak:

• JSON'a bağlanabilecektir.
• Daha eski tarayıcılarda çalışacaktır.
• Daha hızlı olabilir.

Henüz ECMAScript'e tarafından sağlanan hiçbir yöntem olsa da, bu yine de kullanılarak yapılabilir JSON.stingifysen eşlerseniz Mapbir JavaScript ilkel için. İşte Mapkullanacağımız örnek .

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

Bir JavaScript Nesnesine Gitmek

Aşağıdaki yardımcı işlevle değişmez JavaScript Nesnesine dönüştürebilirsiniz.

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 Nesne Dizisine Gitme

Bunun için yardımcı işlev daha da kompakt olacaktır.

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

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

Dizi Dizisine Gitme

Bu daha da kolay, sadece kullanabilirsiniz

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

Kullanılması yayılma sytax Harita tek satırda serileştirilebilir:

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

ve şununla serisini kaldır:

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

Bir Mapörneği dizgi (anahtar olarak nesneler uygundur) :

JSON.stringify([...map])

veya

JSON.stringify(Array.from(map))

veya

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

çıkış formatı:

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

Aşağıdaki çözüm, Haritalar'ı iç içe yerleştirseniz bile çalışır

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

Daha İyi Bir Çözüm

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

Çıktı

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

Umarım bu, yukarıdaki cevaplardan daha az zordur.

Örneğinizin, anahtarların basit türler olacağı basit bir kullanım durumu olduğu göz önüne alındığında, bunun JSON bir Haritayı dizgiselleştirmenin en kolay yolu olduğunu düşünüyorum.

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

Bir Haritanın temelindeki veri yapısı hakkında düşünme şeklim, anahtar-değer çiftlerinden oluşan bir dizidir (dizilerin kendileri olarak). Yani, bunun gibi bir şey:

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

Bu temel veri yapısı, Object.entries'de bulduğumuz şey olduğu için, bir Array'de Object.fromEntries()olduğu gibi bir Map üzerinde yerel JavaScript yöntemini kullanabiliriz :

Object.fromEntries(myMap);

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

Ve bunun sonucunda geriye kalan tek şey JSON.stringify () kullanmaktır.