JavaScript Array Methods
Tags: javascript, arraymethods, beginners
Published: 2023-12-26 05:23:11

Hello developer community! I'm sharing an article with you that dives into JavaScript array methods. I found this topic interesting, as a solid understanding of array manipulation is foundational in programming.

Arrays play a crucial role in software development, and efficiently manipulating them is key. In this article, we'll explore various JavaScript array methods, understanding their purpose, syntax, and practical examples.

**Methods Covered**
- **`forEach`**: Iterates over the elements of an array.
- **`map`**: Creates a new array by applying a function to each element.
- **`filter`**: Creates a new array containing only elements that meet a filtering condition.
- **`reduce`**: Transforms an array into a single value by applying a callback function.
- **`slice`**: Works with a specific portion of an array without modifying the original.
- **`splice`**: Modifies the content of an array, allowing insertion or removal of elements.
- **`sort`**: Rearranges the elements of an array.
- **`concat`**: Combines two or more arrays into a new array.
- **`fill`**: Fills the elements of an array with a specific value.
- **`includes`**: Checks the presence of an element in an array.
- **`join`**: Concatenates all elements of an array, separated by a specified separator.
- **`reverse`**: Reverses the order of elements in an array.
- **`push`**: Adds elements to the end of an array.
- **`pop`**: Removes the last element of an array.
- **`unshift`**: Adds elements to the beginning of an array.
- **`shift`**: Removes the first element of an array.
- **`indexOf`**: Finds the index of the first occurrence of an element in an array.
- **`lastIndexOf`**: Finds the index of the last occurrence of an element in an array.
- **`every`**: Checks if all elements in an array satisfy a specific condition.
- **`some`**: Checks if at least one element in an array satisfies a specific condition.
- **`find`**: Locates the first element that satisfies a specific condition in an array.
- **`findIndex`**: Finds the index of the first element in an array that satisfies a specific condition.
- **`from`**: Creates a new array from a sequence of values or iterable objects.
- **`isArray`**: Checks if a given value is an array.
- **`flat`**: Flattens a multidimensional array by removing nesting.

Each method comes with practical examples, allowing you to experiment and understand its functionality. Run the examples in your development environment for a hands-on experience.

## Method 1: `forEach`

**Purpose**
The `forEach` method is used to iterate over the elements of an array.

**Return**
Unlike some array methods, `forEach` does not return a new array. Instead, it executes a callback function for each element in the array.

**Modifications**
It's important to note that `forEach` does not modify the original array.

**Syntax**
```js
array.forEach(function (element, index, array) {
  // Your logic here
});
```
- `element`: The current element being processed in the array.
- `index`: The index of the current element in the array.
- `array`: The array to which the element belongs.

**Example**
```js
const array1 = [1, 2, 3, 4, 5];

// Example of using forEach to log each element in the array
array1.forEach(
   (element) => console.log(element)
);

/* Output:
1
2
3
4
5
*/

```
In this example, the `forEach` method iterates through each element in `array1` and logs it to the console. This is a powerful tool for performing actions on each element of an array without the need for explicit loops. Feel free to experiment with your own logic inside the `forEach` callback.

## Method 2: `map`

**Purpose**
The `map` method is used to create a new array resulting from the application of a function to each element of the original array.

**Return**
`map` returns a new array with the results of the operations applied to each element.

**Modifications**
It's crucial to understand that `map` does not modify the original array.

**Syntax**
```js
const newArray = array.map(function(element, index, array) {
  // Your logic here
  return result; // The transformed element to be included in the new array.
});
```
- `element`: The current element being processed in the array.
- `index`: The index of the current element in the array.
- `array`: The array to which the element belongs.

**Example**
```js
const array2 = [1, 2, 3, 4, 5];

// Example of using map to create a new array with the same elements
const ElementMap = array2.map((element) => {
   return element;
});

console.log(ElementMap);

/* Output:
[1, 2, 3, 4, 5]
```
In this example, the `map` method iterates through each element in `array2`, applying a function that simply returns each element. This results in a new array (`ElementMap`) that is identical to the original array. `map` is particularly useful when you need to transform each element in an array based on a specific logic.

## Method 3: `filter`

**Purpose**
The `filter` method is used to create a new array containing only the elements that satisfy a filtering condition.

**Return**
`filter` returns a new array containing the elements that passed the filtering condition. If no elements meet the condition, the result will be an empty array.

**Modifications**
It's important to note that `filter` does not modify the original array.

**Syntax**
```js
const newArray = array.filter((element, index, array) => {
  // Condition for including the element in the new array
  return condition;
});
```
- `element`: The current element being processed in the array.
- `index`: The index of the current element in the array.
- `array`: The array to which the element belongs.

**Example**
```js
const array3 = [1, 2, 3, 4, 5];

// Example of using filter to create a new array with only even elements
const elementPair = array3.filter((element) => {
   return element % 2 === 0;
});

console.log(elementPair);

/* Output:
[2, 4]
```
In this example, the `filter` method is applied to `array3` to create a new array (`elementPair`) containing only the even elements. The condition (`element % 2 === 0`) ensures that only elements satisfying this condition are included in the new array. `filter` is particularly useful when you need to extract specific elements based on a certain criterion.

## Method 4: `reduce`

**Purpose**
The `reduce` method serves the purpose of transforming an array into a single value by applying a callback function to each element of the array and accumulating the result.

**Return**
`reduce` returns a single value that represents the result of the accumulation.

**Modifications**
It's crucial to note that `reduce` does not modify the original array.

**Syntax**
```js
const result = array.reduce(
    (accumulator, currentValue, index, array) => {
        // Logic to be executed for each element
        return updatedAccumulator;
    }, initialValue
);
```

- `accumulator`: The accumulated result of the callback function.
- `currentValue`: The current element being processed in the array.
- `index`: The index of the current element in the array.
- `array`: The array to which the element belongs.
- `initialValue`: An optional parameter representing the initial value of the accumulator.

**Example**
```js
const array4 = [1, 2, 3, 4, 5];

// Example of using reduce to sum all elements in the array
const elementSum = array4.reduce(
   (accumulator, currentValue) => {
      return accumulator + currentValue;
   }
   , 0);

console.log(elementSum);

/* Output:
15
```
In this example, the `reduce` method is applied to `array4` to accumulate the sum of all elements. The callback function takes two parameters, `accumulator` and `currentValue`, and it updates the accumulator with the sum of each element in the array. The `reduce` method is particularly useful for aggregating values in an array into a single result.

## Method 5: `slice`

**Purpose**
The `slice` method is designed to work with a specific portion of an array without modifying the original array.

**Return**
`slice` returns a new array containing the elements extracted from the original array.

**Modifications**
It's essential to highlight that `slice` does not modify the original array.

**Syntax**
```js
const newArray = array.slice(start, end);
```
- `start` (optional): The index from which to begin extraction. If omitted, the default is 0.
- `end` (optional): The index at which to end extraction. The element at the end index is not included. If omitted, all elements up to the end of the array are included.

**Example**
```js
const array5 = [1, 2, 3, 4, 5];

// Example of using slice to extract a specific portion of the array
const elementExtract = array5.slice(1, 2);
 
console.log(elementExtract);
 
/* Output:
[2]
```
In this example, the `slice` method is applied to `array5` to extract a portion of the array. The `start` parameter is set to 1, and the `end` parameter is set to 2, resulting in a new array containing the element at index 1 (`2`). It's a handy method for obtaining a subarray without modifying the original one.

## Method 6: `splice`

**Purpose**
The `splice` method serves the purpose of modifying the content of an array, enabling the insertion or removal of elements at specific positions in the array.

**Return**
`splice` returns an array containing the removed elements. If no elements are removed, the method returns an empty array.

**Modifications**
It's crucial to note that `splice` directly modifies the original array.

**Syntax**
```js
const removedElements = array.splice(start, deleteCount, element1, element2, ...);
```
- `start`: The index at which to start changing the array.
- `deleteCount`: An integer indicating the number of elements in the array to remove from start.
- `element1, element2, ...`: The elements to add to the array, beginning at the start index.

**Example**
```js
const array6 = [1, 2, 3, 4, 5];

// Example of using splice to remove elements and insert new ones
const elementsRemoved = array6.splice(2, 2, 5, 6);

console.log(elementsRemoved);
console.log(array6);

/* Output:
[3, 4]
[1, 2, 5, 6, 5]
```
In this example, the `splice` method is applied to `array6`, starting at index 2, removing 2 elements, and inserting `5` and `6`. The method returns the removed elements (`[3, 4]`), and the modified array becomes `[1, 2, 5, 6, 5]`. It's a versatile method for dynamic array manipulations.

## Method 7: `sort`

**Purpose**
The `sort` method is used to rearrange the elements of an array so that they appear in a specific order. The default order is lexicographical when no argument is provided.

**Return**
`sort` modifies the original array and returns the sorted array itself.

**Modifications**
It's essential to be aware that `sort` directly modifies the original array.

**Syntax**
```js
const sortedArray = array.sort([comparisonFunction]);
```
- `comparisonFunction` (optional): A function that defines the sort order. If omitted, the elements are converted into strings and arranged in lexicographical order.

**Example**
```js
const array7 = [3, 4, 1, 2, 5, 10, 9, 6, 7, 8];

// Example of using sort with a comparison function for numerical sorting
const orderedArray = array7.sort(
   (a, b) => {
      return a - b;
   }
);

console.log(orderedArray);

/* Output:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```
In this example, the `sort` method is applied to `array7` with a comparison function that sorts the elements in ascending numerical order. The modified array is then logged to the console.

## Method 8: `concat`

**Purpose**
The `concat` method is used to combine two or more arrays into a new array.

**Return**
`concat` returns a new array containing all the elements from the source arrays.

**Modifications**
`concat` does not modify the original array.

**Syntax**
```js
const newArray = array1.concat(array2, array3, ..., arrayN);
```
- `array1`: The array to which other arrays are concatenated.
- `array2, array3, ..., arrayN`: Additional arrays to be concatenated.

Example
```js
const array8 = [1, 2, 3, 4, 5];

// Example of using concat to combine two arrays
const arrayConcat = array8.concat([6, 7]);

console.log(arrayConcat);

/* Output:
[1, 2, 3, 4, 5, 6, 7]
```
In this example, the `concat` method is used to combine the elements of array8 with the elements of the array `[6, 7]`, creating a new array named `arrayConcat`. The result is then logged to the console.

## Method 9: `fill`

**Purpose**
The `fill` method is used to fill the elements of an array with a specific value.

**Return**
`fill` returns a reference to the modified array.

Modifications
`fill` modifies the original array.

**Syntax**
```js
array.fill(value, startIndex, endIndex);
```
- `value`: The value to fill the array elements with.
- `startIndex` (optional): The index from which to begin filling. If omitted, the default is 0.
- `endIndex` (optional): The index at which to stop filling. The element at the endIndex is not included. If omitted, all elements up to the end of the array are filled.

**Example**
```js
const array9 = [1, 2, 2, 4, 5];

// Example of using fill to replace elements in a specific range
array9.fill(3, 2, 3);

console.log(array9);

/* Output:
[1, 2, 3, 4, 5]
```
In this example, the `fill` method is used to replace elements in the range from index 2 to 3 (exclusive) of `array9` with the value `3`. The modified array is then logged to the console.

## Method 10: `includes`

**Purpose**
The `includes` method is used to check the presence of an element in an array.

**Return**
`includes` returns a boolean value (`true` or `false`).

**Modifications**
`includes` does not modify the original array.

**Syntax**
```js
array.includes(searchValue, startIndex);
```
- `searchValue`: The value to search for in the array.
- `startIndex` (optional): The index from which to start the search. If omitted, the default is 0.

**Example**
```js
const array10 = [1, 2, 3, 4, 5];

// Example of using includes to check if an element is present in the array
const elementIncludes = array10.includes(3, 3);

console.log(elementIncludes);

/* Output:
false
```
In this example, the `includes` method is used to check if the value `3` is present in the array `array10` starting from index 3. The result (`false`) is then logged to the console.

## Method 11: `join`

**Purpose**
The `join` method is designed to concatenate all elements of an array, separated by a specified separator.

**Return**
`join` returns a string containing all the elements of the array concatenated and separated by the specified separator.

**Modifications**
`join` does not modify the original array.

**Syntax**
```js
const resultString = array.join(separator);
```
`separator`: The string used to separate the array elements in the resulting string.

**Example**
```js
const array11 = [1, 2, 3, 4, 5];

// Example of using join to create a string with elements separated by a hyphen
const elementJoin = array11.join('-');

console.log(elementJoin);

/* Output:
1-2-3-4-5
```
In this example, the `join` method is applied to array11 with a hyphen (`-`) as the separator. The resulting string, where array elements are separated by hyphens, is then displayed in the console.


## Method 12: `reverse`

**Purpose**
The reverse method serves the purpose of reversing the order of elements in an array.

**Return**
`reverse` returns a reference to the reversed array.

**Modifications**
`reverse` modifies the original array by rearranging its elements in reverse order.

**Syntax**
```js
array.reverse();
```

**Example**
```js
const array12 = [1, 2, 3, 4, 5];

// Example of using reverse to reverse the order of elements in the array
array12.reverse();

console.log(array12);

/* Output:
[5, 4, 3, 2, 1]
```

In this example, the `reverse` method is applied to `array12`, resulting in the original array's elements being reversed. The reversed array is then displayed in the console.

## Method 13: `push`

**Purpose**
The `push` method serves the purpose of adding elements to the end of an array.

**Return**
`push` returns the new length of the array after the elements are added.

**Modifications**
`push` modifies the original array by appending the provided elements to its end.

**Syntax**
```js
array.push(element1, element2, ..., elementN);
```
- `element1, element2, ..., elementN`: Elements to be added to the end of the array.

**Example**
```js
const array13 = [1, 2, 3, 4, 5];

// Example of using push to add elements to the end of the array
array13.push(6, 7, 8, 9, 10);

console.log(array13);

/* Output:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```
In this example, the `push` method is applied to `array13`, adding elements `6, 7, 8, 9, 10` to the end of the array. The modified array is then displayed in the console.

## Method 14: `pop`

**Purpose**
The `pop` method is designed to remove the last element of an array.

**Return**
`pop` returns the removed element from the end of the array. If the array is empty, pop returns undefined since there are no elements to remove.

**Modifications**
`pop` modifies the original array by removing its last element.

**Syntax**
```js
const removedElement = array.pop();
```

**Example**
```js
const array14 = [1, 2, 3, 4, 5];

// Example of using pop to remove the last element from the array
const removedLastElement = array14.pop();

console.log(array14);
console.log(removedLastElement);

/* Output:
[1, 2, 3, 4]
5
```
In this example, the `pop` method is applied to array14, removing the last element (`5`) from the array. The modified array (`[1, 2, 3, 4]`) and the removed element (`5`) are then displayed in the console.

## Method 15: `unshift`

**Purpose**
The `unshift` method is utilized to add elements to the beginning of an array.

**Return**
`unshift` returns the new length of the array after adding the elements.

**Modifications**
`unshift` modifies the original array by adding elements to its beginning.

**Syntax**
```js
const newLength = array.unshift(element1, element2, ..., elementN);
```
- `element1, element2, ..., elementN`: Elements to be added to the beginning of the array.

**Example**
```js
const array15 = [1, 2, 3, 4, 5];

// Example of using unshift to add elements to the beginning of the array
const newLength = array15.unshift(6, 7);

console.log(newLength);
console.log(array15);

/* Output:
7
[6, 7, 1, 2, 3, 4, 5]
```
In this example, the `unshift` method is applied to `array15`, adding elements `6` and `7` to the beginning of the array. The new length of the array (7) and the modified array (`[6, 7, 1, 2, 3, 4, 5]`) are then displayed in the console.

## Method 16: `shift`

**Purpose**
The `shift` method serves the purpose of removing the first element of an array.

**Return**
`shift` returns the first element removed from the array.

**Modifications**
`shift` modifies the original array by removing its first element.

**Syntax**
```js
const removedFirstElement = array.shift();
```

**Example**
```js
const array16 = [1, 2, 3, 4, 5];

// Example of using shift to remove the first element from the array
const removedFirstElement = array16.shift();

console.log(removedFirstElement);
console.log(array16);

/* Output:
1
[2, 3, 4, 5]
```
In this example, the `shift` method is applied to `array16`, removing its first element (`1`). The removed element and the modified array (`[2, 3, 4, 5]`) are then displayed in the console.

## Method 17: `indexOf`

**Purpose**
The `indexOf` method is designed to find the index of the first occurrence of an element in an array.

**Return**
`indexOf` returns the index of the first found element or -1 if the element is not present in the array. If the element occurs multiple times, only the index of the first occurrence is returned.

**Modifications**
indexOf does not modify the original array. When dealing with objects or arrays, it checks references, not values.

**Syntax**
```js
const index = array.indexOf(element, startIndex);
```
- `element`: The element to search for in the array.
- `startIndex` (optional): The index from which to start the search. If omitted, the default is 0.

**Example**
```js
const array17 = [1, 2, 3, 4, 5];

// Example of using indexOf to find the index of an element in the array
const elementIndex = array17.indexOf(4, 0);

console.log(elementIndex);

/* Output:
3
```
In this example, the `indexOf` method is used to find the index of the element `4` in the array `array17`. The search starts from index `0`, and the result (`3`) is then logged to the console.

## Method 18: `lastIndexOf`

**Purpose**
The `lastIndexOf` method is employed to find the index of the last occurrence of an element in an array.

**Return**
`lastIndexOf` returns the index of the last found element or -1 if the element is not present in the array. If the element occurs multiple times, only the index of the last occurrence is returned.

**Modifications**
`lastIndexOf` does not modify the original array. When dealing with objects or arrays, it checks references, not values.

**Syntax**
```js
const index = array.lastIndexOf(element, endIndex);
```
- `element`: The element to search for in the array.
- `endIndex` (optional): The index at which to stop searching. If omitted, the default is the last index of the array.

**Example**
```js
const array18 = [1, 4, 4, 4, 5];

// Example of using lastIndexOf to find the index of the last occurrence of an element in the array
const lastIndex = array18.lastIndexOf(4, 4);

console.log(lastIndex);

/* Output:
3
```
In this example, the `lastIndexOf` method is used to find the index of the last occurrence of the element `4` in the array `array18`. The search stops at index `4`, and the result (`3`) is then logged to the console.

## Method 19: `every`

**Purpose**
The `every` method is designed to check if all elements in an array satisfy a specific condition.

**Return**
`every` returns `true` if all elements pass the test defined by the callback function; otherwise, it returns `false`. If the array is empty, `every` returns true since there are no elements that fail the condition. The method stops iteration as soon as it finds an element that does not satisfy the condition, saving processing.

**Modifications**
`every` does not modify the original array.

**Syntax**
```js
const allPass = array.every((element, index, array) => {
    // Condition to be checked for each element
    return condition;
});
```
- `element`: The current element being processed in the array.
- `index`: The index of the current element in the array.
- `array`: The array to which the element belongs.

**Example**
```js
const array19 = [2, 4, 6, 8, 10];

// Example of using every to check if all elements are even numbers
const allPass = array19.every(
   (element) => {
      return element % 2 === 0;
   }
);

console.log(allPass);

/* Output:
true
```
In this example, the `every` method is used to check if all elements in the array `array19` are even numbers. The result (`true`) is then logged to the console.

## Method 20: `some`

**Purpose**
The `some` method is employed to check if at least one element in an array satisfies a specific condition.

**Return**
some returns true if at least one element passes the test defined by the callback function; otherwise, it returns false. If the array is empty, some returns false since there are no elements to satisfy the condition. The method stops iteration as soon as it finds an element that satisfies the condition, saving processing.

**Modifications**
`some` does not modify the original array.

**Syntax**
```js
const atLeastOnePasses = array.some((element, index, array) => {
    // Condition to be checked for each element
    return condition;
});
```
- `element`: The current element being processed in the array.
- `index`: The index of the current element in the array.
- `array`: The array to which the element belongs.

**Example**
```js
const array20 = [1, 2, 3, 4, 5];

// Example of using some to check if at least one element is an even number
const atLeastOnePasses = array20.some(
   (element) => {
      return element % 2 === 0;
   }
);

console.log(atLeastOnePasses);

/* Output:
true
```
In this example, the `some` method is used to check if at least one element in the array `array20` is an even number. The result (`true`) is then logged to the console.

## Method 21: `find`

**Purpose**
The `find` method is designed to locate the first element that satisfies a specific condition in an array.

**Return**
`find` returns the value of the first element that satisfies the condition defined by the callback function or `undefined` if no element is found. If the array is empty, the `find` method returns `undefined` since there are no elements to satisfy the condition. The method stops iteration as soon as it finds the first element that satisfies the condition, saving processing.

**Modifications**
`find` does not modify the original array.

**Syntax**
```js
const foundElement = array.find((element, index, array) => {
    // Condition to be checked for each element
    return condition;
});
```
- `element`: The current element being processed in the array.
- `index`: The index of the current element in the array.
- `array`: The array to which the element belongs

**Example**
```js
const array21 = [1, 2, 3, 4, 5];

// Example of using find to locate the first element equal to 1 in the array
const foundElement = array21.find(
   (element) => {
      return element === 1;
   }
);

console.log(foundElement);

/* Output:
1
```
In this example, the `find` method is used to locate the first element equal to 1 in the array `array21`. The result (`1`) is then logged to the console.

## Method 22: `findIndex`

**Purpose**
The `findIndex` method serves to find the index of the first element in an array that satisfies a specific condition.

**Return**
`findIndex` returns the index of the first element that satisfies the condition defined by the callback function or `-1` if no element is found. If the array is empty, the `findIndex` method returns `-1` since there are no elements to satisfy the condition. The method stops iteration as soon as it finds the first element that satisfies the condition, saving processing.

**Modifications**
`findIndex` does not modify the original array.

**Syntax**
```js
const foundIndex = array.findIndex((element, index, array) => {
    // Condition to be checked for each element
    return condition;
});
```
- `element`: The current element being processed in the array.
- `index`: The index of the current element in the array.
- `array`: The array to which the element belongs.

**Example**
```js
const array22 = [1, 2, 3, 4, 5];

// Example of using findIndex to find the index of the first occurrence of the element 3 in the array
const foundIndex = array22.findIndex(
   (element) => {
      return element === 3;
   }
);

console.log(foundIndex);

/* Output:
2
```
In this example, the `findIndex` method is used to find the index of the first occurrence of the element `3` in the array `array22`. The result (`2`) is then logged to the console.

## Method 23: `from`

**Purpose**
The `from` method is used to create a new array from a sequence of values or iterable objects.

**Return**
`from` returns a new array created from the elements of the iterable object. If the object is already an array, the method creates a shallow copy of the original array. If the mapping function is provided, it will be applied to each element of the object during the creation of the new array. The second and third parameters (mapping and context) are optional and can be omitted if not needed.

**Modifications**
`from` does not modify the original array.

**Syntax**
```js
const newArray = Array.from(iterable, mapping(element, index, array), context);
```
- `iterable`: An iterable object to convert to an array.
- `mapping` (optional): A function to map each element before creating the new array.
- `element`: The current element being processed in the array.
- `index`: The index of the current element in the array.
- `array`: The array to which the element belongs.
- `context` (optional): The value to use as `this` when executing the mapping function.

**Example**
```js
const array23 = [1, 2, 3, 4, 5];

// Example of using Array.from to create a new array with each element doubled
const doubleNumber = Array.from(array23, element => element * 2);

console.log(doubleNumber);

/* Output:
[2, 4, 6, 8, 10]
```
In this example, `from` is used to create a new array `doubleNumber` with each element of the original array `array23` doubled. The result is then logged to the console.

## Method 24: `isArray`

**Purpose**
The `isArray` method is used to check if a given value is an array.

**Return**
`isArray` returns true if the provided value is an array; otherwise, it returns false.

**Modifications**
`isArray` does not modify the original array.

**Syntax**
```js
const isArr = Array.isArray(value);
```
- `value`: The value to be checked whether it is an array.

**Example**
```js
const array24 = [1, 2, 3, 4, 5];
const str = 'Hello World';

// Example of using Array.isArray to check if a value is an array
console.log(Array.isArray(array24)); // Output: true
console.log(Array.isArray(str));      // Output: false
```
In this example, `isArray `is used to check if the variables `array24` and `str` are arrays. The results are then logged to the console.

## Method 25: `flat`

**Purpose**
The `flat` method is used to flatten or collapse a multidimensional array by removing the nesting of subarrays.

**Return**
`flat` returns a new array with elements from subarrays concatenated into a single dimension.

**Modifications**
`flat` does not modify the original array.

**Syntax**
```js
const newArray = array.flat([depth]);
```
- `depth` (optional): A value specifying how deep a nested array structure should be flattened. If not provided or set to `Infinity`, the `flat` method will completely flatten the array, removing all levels of nesting. If a subarray contains other arrays, the `flat` method will flatten only up to the specified depth.

**Example**
```js
const array25 = [1, 2, 3, [4, 5]];
const newArray25 = array25.flat();

console.log(newArray25);
/* Output:
[1, 2, 3, 4, 5]
```
In this example, the `flat` method is used to flatten the array `array25`, which contains a nested subarray. The result is then logged to the console.