10 JavaScript Array Methods That Will Make You Look Like a Pro
Tags: javascript, array, method, webdev
Published: 2024-03-11 22:11:30

**Unlock Your JavaScript Potential: Master These 10 Array Methods**

Are you ready to take your JavaScript skills to the next level? Whether you're a seasoned developer or just starting your coding journey, mastering array methods is an essential step towards becoming a JavaScript pro.

In this article, we'll explore 10 powerful array methods that will not only streamline your code but also elevate your programming prowess. From simplifying complex operations to unleashing the full potential of your data structures, these methods are the secret weapons of top-tier developers.

So, let's dive into the world of JavaScript array methods and unleash your full programming potential!

**1. forEach() Method**

The _forEach()_ method executes a given function on every element of an array. It does not return a new array but instead modifies the original array if your callback function changes any elements.
```
const register = [
    { name: "Bruce Shittu", yearOfReg: 2000 },
    { name: "Will Smart", yearOfReg: 1998 },
    { name: "Adex Popins", yearOfReg: 2001 },
    { name: "Nurain Bamidele", yearOfReg: 1992 },
    { name: "John Doe", yearOfReg: 2001 },
]

register.forEach(register =>
    console.log(`Mr. ${register.name} 
    register in year ${register.yearOfReg}`))
```

Output:
```
Mr. Bruce Shittu register in year 2000
Mr. Will Smart register in year 1998
Mr. Adex Popins register in year 2001
Mr. Nurain Bamidele register in year 1992
Mr. John Doe register in year 2001
```

**2. map() Method**

The _map()_ method creates a new array with the results of calling a provided function on every element in the original array. It's designed for transforming existing elements into new elements.

```
const numbers = [1, 2, 3, 4, 5, 6, 7, 8];

const doubledNumbers = numbers.map((number) => {
    return number * 2; // Apply the operation to each element
});

console.log(doubledNumbers);
```
Output:
```
[2,  4,  6,  8, 10, 12, 14, 16]
```
The map method creates a new array (doubledNumbers) with the transformed elements (doubled values).

**3. shift() Method**

The _shift()_ method is used to remove the first element from an array and returns the removed element. It's a mutating method, meaning it modifies the original array. The remaining elements in the array are shifted down one position to fill the gap left by the removed element.

```
const fruits = ["Apple", "Banana", "Orange", "Mango", "Tangerine"];

const firstFruit = fruits.shift(); // firstFruit will be "Apple"
console.log(fruits);  // Output: ["Banana", "Orange", "Mango", "Tangerine"] (original array modified)
console.log(firstFruit); // Output: "Apple" (removed element)
```
Output:
```
[ 'Banana', 'Orange', 'Mango', 'Tangerine' ]
Apple
```
_shift()_ returns the value of the removed element. If the array is empty i.e length is 0, _shift()_ returns _undefined_. Remember, _shift()_ alters the original array.

**4. unshift() Method**

The _unshift()_ method in JavaScript is the opposite of _shift()_. It's used to add one or more elements to the beginning of an array and returns the new length of the array.

```
const colors = ["red", "green", "blue", "violet"];

const newColors = colors.unshift("yellow", "purple"); 
console.log(colors);  
console.log(newColors); 
```
Output:
```
[ 'yellow', 'purple', 'red', 'green', 'blue', 'violet' ]
6
```
_unshift()_ takes any number of arguments, which are the elements you want to add to the array. These elements are inserted at the beginning of the array.

**5. push() Method**

The _push()_ method is a versatile tool for manipulating arrays. It allows you to add one or more elements to the end of an array and returns the new length of the array. 
```
const numbers = [1, 2, 3, 4, 5];

const newNumbers = numbers.push(6, 7); 
console.log(numbers);
console.log(newNumbers); 
```
Output:
```
[1, 2, 3, 4, 5, 6, 7]
7
```
The _push()_ takes any number of arguments, which represent the elements you want to add to the array. These elements are inserted at the end of the array. Also,  _push() _  modifies the original array in place and the length.

**6. pop() Method**

The _pop()_ method is used to remove the last element from an array and return the removed element. It's a mutating method, meaning it modifies the original array. 

```
const fruits = ["Apple", "Banana", "Orange", "Mango", "Tangerine"];

const removeFruit = fruits.pop();
console.log(fruits);  
console.log(removeFruit);
```
Output:
```
[ 'Apple', 'Banana', 'Orange', 'Mango' ]
Tangerine
```
The _pop()_ method targets the element at the last index (which is length - 1) in the array and removes it, decreasing the length accordingly.

**7. join() Method**

The join() method in JavaScript is a powerful tool for combining the elements of an array into a single string. 

```
const colors = ["red", "green", "blue", "violet"];

const joinColors = colors.join(","); 
const joinColorsHyphen = colors.join(" - "); 

console.log(colors); 
console.log(joinColors); 
```
Output:
```
[ 'red', 'green', 'blue', 'violet' ]
red,green,blue,violet
```
The _join()_ iterates through the elements of the array and joins them together, separated by a specified separator string (optional). If no separator is provided, the default separator is a comma (,). Each element in the array is converted to a string.

**8. slice() Method**

The _slice()_ method is for extracting a section of an array and returning it as a new array. It doesn't modify the original array.
```
const countries = ["Panama", "USA", "Nigeria", "Ghana","Brazil"]

// Extracting everything from index 2 (inclusive) to the end
const restCountries = countries.slice(2); 
console.log(restCountries);

console.log(countries)
const subCountries = countries.slice(1, 3)
console.log(subCountries)
```
Output:
```
[ 'Nigeria', 'Ghana', 'Brazil' ]
[ 'Panama', 'USA', 'Nigeria', 'Ghana', 'Brazil' ]
[ 'USA', 'Nigeria' ]
```

_slice()_ takes two optional arguments, _startIndex_ and _endIndex_, to specify the portion of the array to be extracted.
_startIndex _(Default: 0): This argument defines the index from where the extraction should begin. Negative values are counted from the end of the array.

**9. sort() Method**

The _sort() _method in JavaScript is used to sort the elements of an array in place.  
```
const numbers = [3, 1, 4, 1, 5, 9];

numbers.sort((a, b) => a - b); // Sort numbers in ascending order
console.log(numbers);
```
Output:
```
[ 1, 1, 3, 4, 5, 9 ]
```
_sort()_ is a mutating method, meaning it modifies the original array in place.

**10. every() Method**

The _every()_ method is a powerful tool for checking whether all elements in an array pass a test implemented by a provided function. 

```
const numbers = [1, 2, 3, 4, 5];

// Checking if all numbers are even
const allEven = numbers.every(number => number % 2 === 0); 
console.log(allEven); 

// Checking if all numbers are greater than 0
const allPositive = numbers.every(number => number > 0); 
console.log(allPositive); 
```
Output:
```
false
true
```
_every()_ always return Boolean value.

**Conclusion**
This article explores 10 array methods in JavaScript programming, highlighting their potential to streamline tasks, manipulate data, and unlock the full potential of arrays in applications. By exploring these methods and experimenting, you can become a JavaScript array master.

**Key Takeaways:**
_**Array manipulation:**_ Methods like push(), pop(), shift(), and unshift() provide efficient ways to add, remove, and rearrange elements within arrays.

**_Iteration and transformation:_** forEach() and map()empower you to process and transform array elements, creating new data structures or applying calculations.

**_String manipulation:_** join() allows you to combine array elements into a single string, useful for formatting data or creating output.

_**Sorting and filtering:**_ sort() and every() enable you to organize and filter arrays based on specific criteria, ensuring your data is presented in the desired order or meets specific conditions.