When using the length property in JavaScript arrays, it will return a number that is one higher than the highest assigned "index". These array "indexes" are integers greater than or equal to zero. It's important to note that JS allows for "sparse" arrays:

var someArray = [];
someArray[10] = "whatever";
console.log(someArray.length); // "11"

If an array has no elements, then its length will be 0. Additionally, deleting the highest element of an array does not update the length.

Although arrays are objects in JavaScript, you can assign properties with arbitrary names such as negative numbers or fractions:

someArray[-1] = "A property";
someArray[3.1415] = "Vaguely Pi";
someArray["test"] = "Whatever";

It's worth mentioning that even if you supply a number like -1, JavaScript converts property names to strings behind the scenes. This conversion also applies to positive integer indexes.

Methods specific to arrays, like .pop(), .slice(), and others, only work on integer "indexes" zero or higher, and not on other properties. This ensures that the behavior of the length property remains consistent.

Keep in mind that using a proper position (or 0) index is essential for values to be placed accurately within the array:

var array = [];

array[0] = "Foo";
array[1] = "Bar";

// Result: ["Foo", "Bar"]
// Length: 2

If non-index values outside of the range 0-9+ are added, they will not be included in the array:

var array = [];

array[0]  = "Foo";
array[1]  = "Bar";
array[-1] = "Fizzbuzz"; // This is an incorrect array index - discard it

// Result: ["Foo", "Bar"]
// Length: 2

Values are only accepted within the array when the rules are followed. Any deviations are not recognized. However, such values can still be accessed on the Array object itself, as is common in JavaScript. Even if ["Foo", "Bar"] are the sole values in our array, we can retrieve "Fizzbuzz":

array[-1]; // "Fizzbuzz"

It should be noted that this value is not part of the array values, given its invalid "index". It was simply appended as another member of the array. Other array members can be accessed similarly:

array["pop"]; // function pop() { [native code] }

In this case, the pop method of the array is being accessed, indicating native code. No array values with a key of "pop" are retrieved, just a member of the array object. This distinction can be confirmed by iterating over the public members of the object:

for (var prop in array) 
    console.log(prop, array[prop]);

Upon running this loop, the following output is generated:

 0 Foo
 1 Bar
-1 Fizzbuzz

Hence, while the value exists on the object, it is not technically in the array.

Great question! Definitely made me take a second look.

If you are looking to include negative indexes and other index types in the length calculation, you can implement this functionality on your own:

function getCustomArray() {
    var arr = [];

    Object.defineProperty(arr, 'totalItems', { 
        get : function() { return Object.keys(arr).length; }
    });

    return arr;
}

Here is an example of how you can use it:

var customArr = getCustomArray();
console.log(customArr.totalItems); // 0
customArr.push("example");
customArr[-2] = "some text";
customArr[1.2345] = "another text";
console.log(customArr.totalItems); // 3

Did you know that in JavaScript, arrays are actually objects that are prototyped from the Array constructor?

Each array index is essentially a key in a hashmap, and all these keys are automatically converted to strings. This means you can use any key, such as "-1", but the methods provided by the Array object are specifically designed to mimic traditional array behavior. For example, the length property does not indicate the actual size of the array but rather it guarantees to be larger than the largest integer index. Additionally, when printing an array, only values with integer keys greater than or equal to 0 will show up.

For more detailed information on this topic, check out this resource.

An array is essentially a specialized form of object in the realm of JavaScript. The presence of a unique syntax for arrays is beneficial as it enables effective manipulation. Imagine the arduous task of creating an array literal without this syntax:

const array = {0: 'foo', 1: 'bar', 2: 'baz'} //etc...

Despite their uniqueness, arrays are fundamentally objects. Therefore, executing the following code statements:

const myArray = [42, 'foo', 'bar', 'baz'];

myArray[-1] = 'I am not here';
myArray['whatever'] = 'Hello World';

Results in these non-integer properties being linked to an object (which an array technically is), but they remain inaccessible via certain native methods like Array.length.

The native 'length' method acts as a getter that counts all properties (wherein indexes are properties and values are the actual values) which can be converted into positive integers or zero. This analysis is encapsulated by a pseudo-implementation like so:

Based on specifications, the built-in length method – when used as a getter (exampleArray.length) – scans keys classified as nonnegative integers less than 2³², identifies the largest one, then returns its numerical value incremented by 1.

Applied as a setter (exampleArray.length = 42), the mechanism either generates vacant slots for 'missing' indices if the specified length exceeds the number of existing nonnegative integer keys, or purges nonnegative integer keys (along with their associated values) exceeding the specified length.

This hypothetical implementation illustrates these concepts through:

const myArray = {
  '-1': 'I am not here',
  0: 42,
  1: 'foo',
  2: 'bar',
  3: 'baz',
  whatever: 'Hello World',

  get myLength() {
    let highestIndex = -1;
    for (let key in this) {
      let toInt = parseInt(key, 10);
      if (!Number.isNaN(toInt) && toInt > -1) {
        if (toInt > highestIndex) highestIndex = toInt;
      }
    }
    return highestIndex + 1;
  },
  set myLength(newLength) {
    /* This setter would either:
      1) create empty slots for 'missing' indices if the given length is greater than the actual number of non-negative-integer keys
      2) delete non-negative-integer keys (along with their values) which do not exceed the provided length.
    */
  }
}

console.log(myArray.myLength); // 4

myArray[9] = 'foobar';

console.log(myArray.myLength); // 10

As explained on MDN:

The length property holds an integer value with a positive sign and a number less than 2 to the power of 32 (232).

In JavaScript, it is possible to assign properties to any object you create.

var array = new Array();
array = [1,2,3];
array["boom"] = "pow";

Similarly, when assigning a negative index to an array, it is stored as a property rather than part of the index itself.

array[-1] = "property does not affect array length";

This discrepancy in the length property can be observed through a for..in loop.