If you're designing a new language, don't make everything (even arrays!) a hashmap.
So I would say "Yes[1]" ^^
However, what I was referring to is much worse than that:
JavaScript arrays are defined as a normal hashmap with string keys with hooks on assignment to parse the key as a uint32 and update the length property if the value is larger than the current one, and on length assignment iterate over all keys and delete those that successfully parse as a uint32 and has a numeric value larger than the one assigned to length.
You don't need in place memory operations with ridiculous performance in most(tm) applications. On the contrary there are many applications where security is far more important than speed and something that basically embodies remote code execution (browser) is one of those.
The fact that JS has made this implementation choice while at the same time being mutable is the true peril, not the specific implementation per se.
I can see at least 10 types which are not hash maps. Including all the flavors of Typed Arrays.
But regardless of them being a bandaid, you are correct that it is an exception. ArrayBuffer and all its views count 10 types in total, so were they the only exception? If so, I believe my point still stands.
For example, try this:
var foo = [1,2,3]; // or `foo = new Array(1,2,3)` also works
foo['bar'] = 'test';
console.log(foo);
and you get: 0:1
1:2
2:3
bar:"test"