If I want to have string:object dictionary with type checking in TypeScript, there are two ways doing that which I'm aware of:
const m = new Map<string, MyObject>();
m.set("a", new MyObject("a"));
m.set("b", new MyObject("b"));
and
const m : {[index: string]: MyObject} = {};
m["a"] = new MyObject("a");
m["b"] = new MyObject("b");
What are advantages and disadvantages of each of them? If there another way to declare and work with string:MyObject dictionary?
As has been detailed in this answer (up vote this before mine!), an object with typed key and value (sometimes called a hashmap) was commonly used in Typescript before it had support for Map:
const m : {[index: string]: MyObject} = {};
The problem with this approach is that keys can only be of type string or number, and it actually doesn't matter what you use as the key type, since numbers/strings are still accepted interchangeably (only the value is enforced).
Typescript now has native support for ES6 Map type, which doesn't have any of the disadvantages regarding the key mentioned above. As for advantages of the hashmap compared to the Map, I cant see any.
However if you did want to interact with the (now legacy) Map type via the index operator you could do so by wrapping it in a Proxy e.g.
const map = new Map<string, number>();
// Set the value of "a" using Map's set function
map.set("a", 123);
const handler = {
get: (target: Map<string, number>, name: string) => { return target.get(name)},
set: (target: Map<string, number>, name: string, value: number) => {target.set(name, value)}
};
const mapWrapper = new Proxy(map, handler);
// Now add "b" to the Map with the value of 321 via the Proxy wrapper
mapWrapper["b"] = 321;
You can see this example running here.
