Where do undefined properties in JavaScript arrays…

Arrays in JavaScript can have missing properties for the following reasons:

Sparse Arrays: An array can be created with missing elements. For example, when assigning a value to an index that exceeds the current length of the array, JavaScript will expand the array, leaving intermediate elements as uninitialized.
```
// Creating a sparse array
const sparseArray = [];
sparseArray[5] = 'value at index 5';
// sparseArray will look like: [ <5 empty items>, 'value at index 5' ]
```
delete operator: Using the delete operator to remove an array element leaves a "hole" in the array, making the element at that index uninitialized, but does not reduce the array's length.
```
const arrayToDelete = [1, 2, 3, 4];
delete arrayToDelete[1];
// arrayToDelete will look like: [ 1, <1 empty item>, 3, 4 ]
// arrayToDelete.length is still 4
```
Array() constructor with a single numeric argument: Creating an array with new Array(length) or Array(length), where length is a positive integer, creates an array of the specified length with uninitialized elements.
```
// Creating an array with 5 uninitialized elements
const emptyArray = new Array(5);
// emptyArray will look like: [ <5 empty items> ]
```
Some array methods: Certain array methods, such as splice(), can remove elements, creating uninitialized spots if new elements are not inserted in their place or other elements are shifted. However, splice() usually shifts elements to fill gaps. A more illustrative example is manually assigning undefined.
```
const arrayWithUndefined = [1, 2, 3];
arrayWithUndefined[1] = undefined;
// This makes the element explicitly undefined, not a "hole"
// Array sparseArrayExample = [1, , 3];  // Syntax for a sparse array
```
Note: undefined is not a "missing property" in the same sense as a "hole" from delete or creating a sparse array. When iterating over an array with "holes", these elements are skipped or have the value undefined depending on the iteration method.

Creation method	Result in array	Array length	Perception during iteration (e.g., `for...of`)
Sparse array	Skips element	Maintained (based on the highest index)	Element is skipped
`delete` operator	Skips element	Maintained	Element is skipped
`new Array(length)`	Skips elements	`length`	Elements are skipped
Explicit assignment of `undefined`	Value `undefined`	Maintained	Element is processed with value `undefined`

It is important to understand the difference between an element with the value undefined and a "hole" in the array. Iteration methods like forEach, map, filter usually skip "holes", whereas a for loop with a numeric index or for...in handles them differently (for example, for...in iterates over own enumerable properties, including those manually created, but may not iterate over "holes").

Where do undefined properties in JavaScript arrays come from?