¿Algún punto en el uso de ES6 Map cuando las teclas son todas cadenas?

Las claves de objetos simples deben ser cadenas, mientras que una Mappuede tener claves de cualquier tipo.

Pero tengo poco uso para esto en la práctica. En casi todos los casos, me encuentro usando cadenas como teclas de todos modos. Y presumiblemente new Map()es más lento que {}. Entonces, ¿hay alguna otra razón por la que podría ser mejor usar un objeto en Maplugar de un simple?

Hay algunas razones por las que prefiero usar Maps sobre objetos simples ( {}) para almacenar datos de tiempo de ejecución (cachés, etc.):

1. La .sizepropiedad me permite saber cuántas entradas existen en este Mapa;
2. Los diversos métodos de utilidad - .clear(), .forEach(), etc;
3. ¡Me proporcionan iteradores por defecto!

Todos los demás casos, como pasar argumentos de funciones, almacenar configuraciones, etc., se escriben utilizando objetos simples.

Además, recuerde: no intente optimizar su código demasiado pronto. No pierda su tiempo haciendo puntos de referencia de objetos simples frente a Maps a menos que su proyecto esté sufriendo problemas de rendimiento.

No estoy seguro de esto, pero creo que el rendimiento NO es una razón para usar Maps. Eche un vistazo a esta página actualizada de jsperf:

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

Parece que (cuando se trata de cadenas al menos) los objetos son mucho más rápidos que los mapas para la configuración básica y la obtención.

Las otras respuestas no mencionan una última diferencia entre objetos Mapys:

El Mapobjeto contiene pares clave-valor y recuerda el orden de inserción original de las claves .

Por lo tanto, al iterar sobre él, un objeto Map devuelve claves en orden de inserción.

Cita de MDN , énfasis mío

Esta fue la razón principal por la que decidí usar Mappor primera vez en un proyecto reciente. Tenía un objeto normal que necesitaba mostrar en un <table>, con cada propiedad yendo en una fila específica.

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

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

Escribí una función para transformar un objeto en un Maporden de teclas deseado:

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

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

    return map;
}

Luego, el mapa podría repetirse en el orden deseado:

let productMap = objectToMap( product, productPropertyOrder );

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

Por supuesto, esto es un poco artificial porque uno podría mostrarse al iterar sobre el orden de las propiedades sin crear un Mapen el proceso:

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

Pero si tiene una variedad de tales objetos y los va a mostrar en muchos lugares, entonces convertirlos a mapas primero tiene sentido.