Are JavaScript Arrays Sparse?

Investigating the Sparsity of JavaScript Arrays

Much like the pseudo-tty bug in the AIX kernel, questions arise regarding the behavior of JavaScript arrays when utilizing highly varied indices. Specifically, will instantiating an element at a very high index cause the interpreter to instantiate all intermediate elements?

Are JavaScript Arrays Sparse?

The answer is a resounding yes. JavaScript arrays are actually implemented internally as hash tables. This means that you can utilize various data types for indices, including integers, strings, floats, and even objects. All keys are converted to strings via the toString() method before being added to the hash table.

To demonstrate this, consider the following code snippet:

var array = [];
array[0] = "zero";
array[new Date().getTime()] = "now";
array[3.14] = "pi";

for (var i in array) {
    alert("array["+i+"] = " + array[i] + ", typeof("+i+") == " + typeof(i));
}

When this code is executed, it will display the following output:

array[0] = zero, typeof(0) == string
array[1254503972355] = now, typeof(1254503972355) == string
array[3.14] = pi, typeof(3.14) == string

As you can observe, the array contains elements at indices 0, a large timestamp, and the floating-point value 3.14.

Conclusion

Unlike the AIX kernel bug, JavaScript arrays seamlessly handle sparse indices. Their implementation as hash tables allows for efficient and flexible storage of elements with non-contiguous indices. By understanding this behavior, developers can confidently utilize JavaScript arrays without the fear of unintended consequences.

The above is the detailed content of Are JavaScript Arrays Sparse?. For more information, please follow other related articles on the PHP Chinese website!