If

Are the dynamic arrays indexed linked lists? Are they fixed arrays that are reinitialized?

No and no. All JavaScript objects are collections of key/value pairs called properties. Keys are strings(*) and values are any type. They're typically implemented as hash maps, but there's no requirement for that. Arrays are just special cases of objects whose keys are strings that look like non-negative integers. That's why arrays can have empty/missing values, as well as no predetermined size. You can even assign non-numeric-looking properties to arrays if you really want:

> var foo = [1, 2, 3];
undefined
> foo.bar = 'blurgh';
'blurgh'
> foo.length
3
> foo[2]
3
> foo['2']
3
> foo['bar']
'blurgh'
> Object.keys(foo)
[ '0', '1', '2', 'bar' ]

This example is meant to demonstrate several things:

• You can assign arbitrary properties to an object, and an array is still an object.

• Indexing always converts the argument to a string, i.e. foo[2] and foo['2'] are the same thing.

• The bar property is no different than the others when asked to list all the keys of the object, and all the keys are strings.

• For an array, the length property is only updated when assigning a key that is numeric-looking. It doesn't necessarily correspond to how many properties there are.

Note on the last point that length is really just a proxy for "one plus the last seen numeric-looking key." It doesn't have anything to do with the actual length. For example:

> var foo = [];
undefined
> foo[3] = 'abc';
'abc'
> foo
[ , , , 'abc' ]
> foo.length
4

Here foo is an object with a single key, '3'. When asked to display a representation of foo, this REPL chose to do it as [ , , , 'abc' ] which means that the indexes 0 through 2 don't exist. Other implementations may choose a different representation, but the point is that this array only holds one value. (Note: this does not mean that the indexes 0 through 2 just hold undefined or null or some other placeholder; that's a different and distinct case. They don't exist at all.) And yet its length is 4, which is one more than the highest seen index.

So you have to throw away the notion of an array being like an array in other languages; it's really a hash map. But an implementation is free to actually use a real array if you never do any of the things that require hash-map like behavior.

(*) ES6 adds Maps which allow for arbitrary objects as keys.