Массив — это специальная переменная, которая может содержать более одного значения:

Он имеет некоторые встроенные свойства и методы, которые мы можем использовать для добавления, удаления, повторения или манипулирования данными по мере необходимости. Знание методов массива JavaScript может сделать вас лучшим разработчиком.

В этом посте мы рассмотрим 15 методов массивов, которые можно использовать для эффективного управления вашими данными.

1. некоторые ()

Этот метод проверяет массив с помощью функции, переданной в качестве параметра. Он вернет true, если хотя бы один элемент соответствует тесту, и false в противном случае.

const myArray = ["a", "b", "c", "d", "e"]
myArray.some(test => test === "d")
//-------> Output : true

2. уменьшить ()

Этот метод получает функцию, которая имеет аккумулятор и значение в качестве аргумента. Он применяет функцию к аккумулятору и каждому значению в массиве, чтобы в конце вернуть только одно значение.

const myArray = [1, 2, 3, 4, 5]
myArray.reduce((total, value) => total * value)
// 1 * 2 * 3 * 4 * 5
//-------> Output = 120

3. каждый()

Этот метод проверяет массив с помощью функции, переданной в качестве параметра. Он вернет true, если каждый элемент массива соответствует тесту, и false в противном случае.

const myArray = ["a", "b", "c", "d", "e"]
myArray.every(test => test === "d")
//-------> Output : false
const myArray2 = ["a", "a", "a", "a", "a"]
myArray2.every(test => test === "a")
//-------> Output : true

4. карта ()

Этот метод получает функцию в качестве параметра. И вернуть новый массив, содержащий изображение каждого элемента массива. Он всегда будет возвращать одинаковое количество элементов.

const myArray = [5, 4, 3, 2, 1]
myArray.map(x => x * x)
//-------> Output : 25
//                  16
//                  9
//                  4
//                  1

5. квартира ()

Этот метод создает новый массив, содержащий элементы, хранящиеся в подмассиве, и объединяет их в новый массив. Обратите внимание, что этот метод будет работать только на один уровень глубины.

const myArray = [[1, 2], [3, 4], 5]
myArray.flat()
//-------> Output : [1, 2, 3, 4, 5]

6. фильтр()

Этот метод получает функцию в качестве параметра. И вернуть новый массив, содержащий все элементы массива, для которого функция фильтрации, переданная в качестве аргумента, возвращает true.

const myArray = [
  { id: 1, name: "Omri" },
  { id: 2, name: "Dan" },
  { id: 3, name: "Test" },
  { id: 4, name: "Test" },
]
myArray.filter(element => element.name === "Test")
//-------> Output : [
//                   {id: 3, name: "Test"},
//                   {id: 4, name: "Test"}
//                                         ]

7. для каждого()

Этот метод применяет функцию к каждому элементу массива.

const myArray = [
  { id: 1, name: "John" },
  { id: 2, name: "Omri" },
  { id: 3, name: "Dan" },
]
myArray.forEach(element => console.log(element.name))
//-------> Output : John
//                  Omri
//                  Dan

8. найтиИндекс()

Этот метод получает функцию в качестве параметра и применяет ее к массиву. Он возвращает индекс найденного элемента, который удовлетворяет тестовой функции, переданной в качестве аргумента, или -1, если ни один из них не удовлетворяет.

const myArray = [
  { id: 1, name: "John" },
  { id: 2, name: "Omri" },
  { id: 3, name: "Dan" },
]
myArray.findIndex(element => element.id === 3)
//-------> Output : 2
myArray.findIndex(element => element.id === 7)
//-------> Output : -1

9. найти()

Этот метод получает функцию в качестве аргумента и применяет ее к массиву. Он возвращает значение элемента, найденного в массиве и удовлетворяющего тестовой функции. В противном случае возвращается undefined.

const myArray = [
  { id: 1, name: "John" },
  { id: 2, name: "Omri" },
  { id: 3, name: "Dan" },
]
myArray.find(element => element.id === 3)
//-------> Output : {id: 3, name: "Dan"}
myArray.find(element => element.id === 7)
//-------> Output : undefined

10. сортировать()

Этот метод получает функцию в качестве параметра. Он сортирует элементы массива и возвращает его.

const myArray = [5, 4, 3, 2, 1]
// Sort from smallest to largest
myArray.sort((a, b) => a - b)
//-------> Output : [1, 2, 3, 4, 5]
// Sort from largest to smallest
myArray.sort((a, b) => b - a)
//-------> Output : [5, 4, 3, 2, 1]

11. конкат()

Этот метод объединит два или более массива/значения, объединив их. Он возвращает новый массив с элементами.

const myArray = [1, 2, 3, 4, 5]
const myArray2 = [10, 20, 30, 40, 50]
myArray.concat(myArray2)
//-------> Output : [1, 2, 3, 4, 5, 10, 20, 30, 40, 50]

12. заполнить ()

Этот метод заполняет все элементы заданного массива одним и тем же значением от начального индекса (по умолчанию 0) до конечного индекса (по умолчанию array.length).

const myArray = [1, 2, 3, 4, 5]
// The first argument (0) is the value
// The second argument (2) is the starting index
// The third argument (4) is the ending index
myArray.fill(0, 2, 4);
//-------> Output : [1, 2, 0, 0, 0]

13. включает()

Этот метод вернет true, если массив содержит определенный элемент, и false, если нет.

const myArray = [1, 2, 3, 4, 5]
myArray.includes(3)
//-------> Output : true
myArray.includes(8)
//-------> Output : false

14. реверс()

Этот метод переворачивает массив. Первый элемент становится последним, а последний элемент будет первым.

const myArray = ["e", "d", "c", "b", "a"]
myArray.reverse()
//-------> Output : ['a', 'b', 'c', 'd', 'e']

15. плоская карта ()

Метод применяет функцию к каждому элементу массива, а затем объединяет результат в массив. Он объединяет flat() и map() в одну функцию.

const myArray = [[1], [2], [3], [4], [5]]
myArray.flatMap(arr => arr * 10)
//-------> Output : [10, 20, 30, 40, 50]
// With .flat() and .map()
myArray.flat().map(arr => arr * 10)
//-------> Output : [10, 20, 30, 40, 50]