Array.size() is not a valid method

Always use the length property

There is a library or script adding the size method to the array prototype since this is not a native array method. This is commonly done to add support for a custom getter. An example of using this would be when you want to get the size in memory of an array (which is the only thing I can think of that would be useful for this name).

Underscore.js unfortunately defines a size method which actually returns the length of an object or array. Since unfortunately the length property of a function is defined as the number of named arguments the function declares they had to use an alternative and size was chosen (count would have been a better choice).

What you are looking for is not the length of an array but the number values allocated in that array.

Array.length will NOT give you that result but the total number of values allocated.

A workarround is to count the properties of the object behind the array, with:

Object.keys(a).length

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#Relationship_between_length_and_numerical_properties

But with some caveats:

• It will also count literal properties, like a.a_property. I do not think that is what you want. So, you will have to filter that result:

!(+el % 1) which check if el can be considered as numerical property even if it has a type of string.

• you want count only positive integers, so you have to filter them with:

+el>=0

• finally, as array size is limited to 2^32, you will to also filter positive integers greater than that:

+el < Math.pow(2,32)

Functionally, you will have your result with this filter:

Array.realLength= Object.keys(a).filter(function(el){return !(+el % 1) && +el>=0 && +el < Math.pow(2,32) ;}).length 

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.

• Array(5) gives you an array with length 5 but no values, hence you can't iterate over it.

• Array.apply(null, Array(5)).map(function () {}) gives you an array with length 5 and undefined as values, now it can be iterated over.

• Array.apply(null, Array(5)).map(function (x, i) { return i; }) gives you an array with length 5 and values 0,1,2,3,4.

• Array(5).forEach(alert) does nothing, Array.apply(null, Array(5)).forEach(alert) gives you 5 alerts

• ES6 gives us Array.from so now you can also use Array.from(Array(5)).forEach(alert)

• If you want to initialize with a certain value, these are good to knows...
  Array.from('abcde'), Array.from('x'.repeat(5))
  or Array.from({length: 5}, (v, i) => i) // gives [0, 1, 2, 3, 4]