Qualche punto nell'utilizzare ES6 Map quando le chiavi sono tutte stringhe?

Le chiavi oggetto semplici devono essere stringhe, mentre a Mappuò avere chiavi di qualsiasi tipo.

Ma in pratica mi serve poco. In quasi tutti i casi, mi ritrovo ad usare le stringhe come chiavi comunque. E presumibilmente new Map()è più lento di {}. Quindi c'è qualche altro motivo per cui potrebbe essere meglio usare un oggetto Mapanziché un oggetto semplice?

Ci sono alcuni motivi per cui preferisco usare Maps su oggetti semplici ( {}) per archiviare i dati di runtime (cache, ecc.):

1. La .sizeproprietà mi fa sapere quante voci esistono in questa mappa;
2. I vari metodi di utilità - .clear(), .forEach(), ecc;
3. Mi forniscono iteratori di default!

Ogni altro caso, come il passaggio di argomenti di funzioni, la memorizzazione di configurazioni e così via, sono tutti scritti usando oggetti semplici.

Inoltre, ricorda: non tentare di ottimizzare il codice troppo presto. Non perdere tempo a fare benchmark di oggetti semplici e mappe a meno che il tuo progetto non abbia problemi di prestazioni.

Non ne sono sicuro, ma penso che le prestazioni NON siano un motivo per utilizzare Maps. Dai un'occhiata a questa pagina jsperf aggiornata:

http://jsperf.com/es6-map-vs-object-properties/73

Sembra che (quando si ha a che fare con le stringhe almeno) gli oggetti sono molto più veloci delle mappe per l'impostazione di base e per ottenere.

Le altre risposte non menzionano un'ultima differenza tra oggetti e Maps:

L' Mapoggetto contiene coppie chiave-valore e ricorda l'ordine di inserimento originale delle chiavi .

Pertanto, quando si scorre su di esso, un oggetto Mappa restituisce le chiavi in ​​ordine di inserimento.

Citazione da MDN , enfasi mia

Questo è stato il motivo principale per cui ho deciso di utilizzare Mapper la prima volta in un recente progetto. Avevo un oggetto normale che dovevo visualizzare in a <table>, con ogni proprietà che andava in una riga specifica.

let productPropertyOrder = [ "name", "weight", "price", "stocked" ];

let product =
{
    name: "Lasagne",
    weight: "1kg",
    price: 10,
    stocked: true
}

Ho scritto una funzione per trasformare un oggetto in un Mapsecondo un ordine di tasti desiderato:

function objectToMap( obj, order )
{
    let map = new Map();

    for ( const key of order )
    {
        if ( obj.hasOwnProperty( key ) )
        {
            map.set( key, obj[ key ] );
        }
    }

    return map;
}

Quindi la mappa potrebbe essere ripetuta nell'ordine desiderato:

let productMap = objectToMap( product, productPropertyOrder );

for ( const value of productMap.values() )
{
    let cell = document.createElement( "td" );
    cell.innerText = value;
    row.appendChild( cell );
}

Naturalmente questo è un po 'inventato perché si potrebbe anche visualizzare quando si itera sull'ordine delle proprietà senza creare un Mapnel processo:

for ( const key of productPropertyOrder )
{
    if ( product.hasOwnProperty( key ) )
    {
        let value = product[ key ];
        // create cell
    }
}

Ma se hai una serie di tali oggetti e li visualizzerai in molti luoghi, allora convertirli tutti in mappe ha senso.