Algum ponto em usar o ES6 Map quando chaves são todas strings?

Chaves de objetos simples devem ser cadeias de caracteres, enquanto a Mappode ter chaves de qualquer tipo.

Mas tenho pouco uso para isso na prática. Em quase todos os casos, eu me pego usando cadeias de caracteres como chaves de qualquer maneira. E presumivelmente new Map()é mais lento que {}. Portanto, existe alguma outra razão pela qual seria melhor usar um Mapobjeto em vez de um objeto simples?

Existem algumas razões pelas quais prefiro usar Maps sobre objetos simples ( {}) para armazenar dados de tempo de execução (caches, etc):

1. A .sizepropriedade me informa quantas entradas existem neste mapa;
2. Os vários métodos de utilidade - .clear(), .forEach(), etc;
3. Eles me fornecem iteradores por padrão!

Todos os outros casos, como passar argumentos de função, armazenar configurações e etc, são todos escritos usando objetos simples.

Lembre-se também: não tente otimizar seu código muito cedo. Não perca seu tempo fazendo comparações entre o objeto simples e o Maps, a menos que seu projeto esteja sofrendo problemas de desempenho.

Não tenho certeza disso, mas acho que o desempenho NÃO é um motivo para usar o Maps. Dê uma olhada nesta página jsperf atualizada:

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

Parece que (ao lidar com seqüências de caracteres, pelo menos) objetos são muito mais rápidos que mapas para configuração e obtenção básicas.

As outras respostas não mencionam uma última diferença entre objetos Mapes:

O Mapobjeto contém pares de valores-chave e lembra a ordem de inserção original das chaves .

Assim, ao iterar sobre ele, um objeto Map retorna chaves em ordem de inserção.

Citação de MDN , ênfase minha

Essa foi a principal razão pela qual decidi usar Mappela primeira vez em um projeto recente. Eu tinha um objeto normal que precisava exibir em um <table>, com cada propriedade em uma linha específica.

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

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

Eu escrevi uma função para transformar um objeto em um Map acordo com uma ordem de chave desejada:

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

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

    return map;
}

Em seguida, o mapa pode ser iterado na ordem desejada:

let productMap = objectToMap( product, productPropertyOrder );

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

É claro que isso é um pouco artificial, porque é possível exibir ao iterar a ordem da propriedade sem criar um Mapno processo:

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

Mas se você tem uma variedade desses objetos e os exibe em muitos lugares, primeiro faz sentido convertê-los em mapas.