/

The Array JavaScript Data Structure

The Array JavaScript Data Structure

Arrays are a fundamental data structure in programming languages, including JavaScript. In lower-level languages like C, arrays represent a set of contiguous cells in computer memory. However, in JavaScript, arrays work differently as we are abstracted away from the memory management.

In JavaScript, arrays can store any kind of data, allowing for mixing different types within the same array. Initialization of an array can be done using either const myArray = [] or const myArray = new Array(). The shorthand syntax [] is preferred.

Unlike lower-level languages, JavaScript arrays do not require specifying the size at creation time. However, it is possible to do so with const myArray = new Array(10). Once the array is created, we can fill it with values using a loop or directly assigning values to specific positions.

To access elements in an array, we use the index starting from 0. For example, myArray[0] retrieves the first item in the array. We can also perform calculations using the index, such as myArray[4] or myArray[3 + 4], which correspond to the 5th and 8th elements respectively.

Modifying array elements is straightforward with the syntax myArray[index] = value. This allows us to change the value at any position within the array.

In addition to being data containers, arrays in JavaScript are objects and come with built-in methods. The push method adds an item at the end of the array. Similarly, the splice() method can be used to insert an item at any position within the array.

Removing items from an array can be done using the pop() method to remove the last item or the shift() method to remove the first item.

The length of an array can be determined by checking the myArray.length property. This property provides the number of items in the array.

Iterating through array items can be achieved using different looping constructs. For example, a for loop can be used with the index:

1
2
3
4
for (let i = 0; i < myArray.length; i++) {
  console.log(myArray[i]); // value
  console.log(i); // index
}

Alternatively, the forEach method can be used to iterate through the array, providing both the value and index to a callback function:

1
2
3
4
myArray.forEach((item, index) => {
  console.log(item); // value
  console.log(index); // index
});

A while loop can also be used:

1
2
3
4
5
6
let i = 0;
while (i < myArray.length) {
  console.log(myArray[i]); // value
  console.log(i); // index
  i = i + 1;
}

Finally, the for...of loop can be used to iterate over the values of the array, while the entries() method can be used to access both the index and value simultaneously:

1
2
3
4
5
6
7
8
9
10
// iterate over the value
for (const value of myArray) {
  console.log(value); // value
}

// get the index as well, using `entries()`
for (const [index, value] of myArray.entries()) {
  console.log(index); // index
  console.log(value); // value
}

Tags: arrays, JavaScript, data structure, programming languages