Düz bir nesneyi ES6 Haritasına nasıl dönüştürebilirim?

Bazı nedenlerden dolayı MDN belgelerinde bu basit şeyi bulamıyorum (belki de özlüyorum).

Bunun işe yaramasını bekliyordum:

const map = new Map({foo: 'bar'});

map.get('foo'); // 'bar'

... ama ilk satır atıyor TypeError: (var)[Symbol.iterator] is not a function

Düz bir nesneden nasıl Harita yaparım? İlk önce onu anahtar-değer çiftlerinden oluşan bir diziye dönüştürmem gerekiyor mu?

Evet, Mapyapıcı bir dizi anahtar-değer çifti alır.

Object.entriesES2017'de (19.1.2.5) bulunan yeni bir Nesne statik yöntemidir .

const map = new Map(Object.entries({foo: 'bar'}));

map.get('foo'); // 'bar'

Şu anda Firefox 46+ ve Edge 14+ ve Chrome'un daha yeni sürümlerinde uygulanmaktadır

Eski ortamları desteklemeniz gerekiyorsa ve aktarma sizin için bir seçenek değilse, georg tarafından önerilen gibi bir çoklu dolgu kullanın:

Object.entries = typeof Object.entries === 'function' ? Object.entries : obj => Object.keys(obj).map(k => [k, obj[k]]);

Lütfen bir jeneratör işlevi kullanarakObject.entries ve / veya bergi'nin cevabını kullanarak sıfırların cevabına bakın . Object.entriesSoru sorulduğunda henüz teknik özelliklerde yer almasa da , Aşama 4'teydi, böylece çoklu doldurmak ve Nisan 2016'da bile kullanmak çok güvenli (sadece). ( Buradaki aşamalarla ilgili daha fazla bilgi .) Ve jeneratör işlevleri ES2015'teydi. OP özellikle aracılardan kaçınmasını istedi ve jeneratör bundan tamamen kaçınmasa da aşağıdakilerden daha iyi bir iş çıkarır veya (biraz) Object.enties.

FWIW, şunu kullanarak Object.entries:

• Bir dizi oluşturur [name, value]diziler geçmesinenew Map
• MapYapıcı bir yineleyici elde etmek için bir dizi bir işlevini çağırır; dizi, bir dizi interator nesnesi oluşturur ve döndürür.
• MapYineleyici nesne girdileri (almak için o yapıcı kullandığı [name, value]diziler) ve harita oluşturmak

Jeneratörü kullanma:

• Oluşturucu işlevinin çağrılması sonucunda bir üreteç nesnesi oluşturur
• MapYapıcı ondan bir yineleyici elde etmek için bu jeneratör nesne üzerinde bir işlevini çağırır; jeneratör nesnesi kendini döndürür
• MapYapıcı (bir yineleyici gibi) jeneratör nesne girişleri (almak için kullandığı [name, value]diziler) ve harita oluşturmak

Yani: Bir tane daha az aracı (dizi Object.entries).

Bununla birlikte, kullanmak Object.entriesdaha basittir ve bu diziyi oluşturmak her zaman bir sorun değildir. Yani gerçekten, ikisi de. Ama ikisi de aşağıdakilerden daha iyi. :-)

Orijinal cevap:

A'yı başlatmak için Map, diziler dizisi gibi anahtar / değer çiftlerini diziler olarak döndüren herhangi bir yineleyici kullanabilirsiniz:

const map = new Map([
    ['foo', 'bar']
]);

Nesneden haritaya yerleşik bir dönüştürme yoktur, ancak şunlarla kolayca yapılabilir Object.keys:

const map = new Map();
let obj = {foo: 'bar'};
Object.keys(obj).forEach(key => {
    map.set(key, obj[key]);
});

Elbette, bunun üstesinden gelmek için kendinize bir işçi işlevi verebilirsiniz:

function buildMap(obj) {
    let map = new Map();
    Object.keys(obj).forEach(key => {
        map.set(key, obj[key]);
    });
    return map;
}

Sonra

const map = buildMap({foo: 'bar'});

Ya da işte daha l33t görünümlü (bu hala bir şey mi?) Versiyon:

function buildMap(obj) {
    return Object.keys(obj).reduce((map, key) => map.set(key, obj[key]), new Map());
}

(Evet, Map#setharita başvuru döndürür. Bazıları bu bir olduğunu iddia ediyorum abusage ait reduce.)

Ya da bilinmezliği gerçekten aşabiliriz:

const buildMap = o => Object.keys(o).reduce((m, k) => m.set(k, o[k]), new Map());

Hayır, bunu asla gerçek yapmam. :-)

İlk önce onu anahtar-değer çiftlerinden oluşan bir diziye dönüştürmem gerekiyor mu?

Hayır, anahtar-değer çifti dizilerinin bir yineleyicisi yeterlidir. Ara dizi oluşturmaktan kaçınmak için aşağıdakileri kullanabilirsiniz:

function* entries(obj) {
    for (let key in obj)
        yield [key, obj[key]];
}

const map = new Map(entries({foo: 'bar'}));
map.get('foo'); // 'bar'

Nils'in cevabı , çok yararlı bulduğum nesneleri haritalara nasıl dönüştüreceğimi açıklıyor . Ancak OP, bu bilgilerin MDN belgelerinde nerede olduğunu da merak ediyordu. Soru ilk sorulduğunda orada olmasa da, şu anda Object.entries () MDN sayfasında Bir Nesneyi Haritaya Dönüştürme başlığı altında şu ifadeler yer almaktadır :

Bir Nesneyi Haritaya Dönüştürme

new Map()Yapıcı bir iterable kabul entries. İle Object.entries, kolayca dönüştürebilirsiniz Objectiçin Map:

const obj = { foo: 'bar', baz: 42 }; 
const map = new Map(Object.entries(obj));
console.log(map); // Map { foo: "bar", baz: 42 }

const myMap = new Map(
    Object
        .keys(myObj)
        .map(
            key => [key, myObj[key]]
        )
)

Alternatif olarak lodash toPairs yöntemini kullanabilirsiniz:

const _ = require('lodash');
const map = new Map(_.toPairs({foo: 'bar'}));

ES6

nesneyi haritaya dönüştür:

const objToMap = (o) => new Map(Object.entries(o));

haritayı nesneye dönüştür:

const mapToObj = (m) => [...m].reduce( (o,v)=>{ o[v[0]] = v[1]; return o; },{} )

Not: mapToObj işlevi, eşleme anahtarlarının dizeler olduğunu varsayar (aksi takdirde başarısız olur)

Bazı JQuery'nin yardımıyla,

const myMap = new Map();
$.each( obj, function( key, value ) {
myMap[key] = value;
});