были представлены основные понятия о массивах и некоторые простые функции работы с элементами массива. На самом деле массивы предоставляют гораздо больше функций.
push , pop , shift и unshift — это функции, которые работают на обоих концах массива. Они упоминались выше и не будут повторяться в этой статье.
было кратко описано в предыдущей статье. Массив — это специальный объект, поэтому мы можем попробовать использовать метод удаления атрибута объекта: delete .
Например:
let arr = [1,2,3,4,5];delete arr[2];console.log(arr);
Результаты выполнения кода следующие:
Обратите внимание на желтую позицию на картинке. Хотя элемент был удален, длина массива по-прежнему равна 5 , а в удаленной позиции есть лишнее空. Если мы обратимся к элементу с индексом 2 , мы получим следующий результат:
Причина этого явления заключается в том, что delete obj.key удаляет соответствующее значение через key , то есть delete arr[2] удаляет пару ключ-значение 2:3 в массиве. Когда мы обращаемся к индексу 2 , он undefined .
В массиве мы часто надеемся, что после удаления элемента позиция элемента будет заполнена последующими элементами и длина массива станет короче.
На данный момент нам нужен метод splice() .
что метод splice() достаточно универсален и не только удаляет элементы. Синтаксис следующий:
arr.splice(start[,deleteCount,e1,e2,...,eN] )
метод splice Начиная с start позиции, удалите элементы deleteCount , а затем вставьте e1,e2,e3 и другие элементы на место.
Следующий пример позволяет удалить элемент из массива:
let arr = [1,2,3,4,5]arr.splice(0,1);//Удалить первый элемент 1console.log(arr
) приведенный выше код удаляет 1 в первой позиции массива. Результаты выполнения следующие:
аналогично удалению одного элемента. Вам нужно только изменить второй параметр на указанное число. Например:
let arr = [1,2,3,4,5];splice(0,3). ;//Удаляем первые три элемента console.log(arr);//[4,5]
Результаты выполнения кода следующие:
Если мы предоставим только один параметр start , то все элементы после start позиции массива будут удалены. Например:
let arr = [1,2,3,4,5]arr.splice(2); //Удалить Console.log(arr);//[1,2]:результаты выполнения кода
из индекса 2 и всех последующих элементов
Если мы предоставляем более двух параметров, мы можем заменить элементы массива, например:
let arr = [1,2,3,4,5];arr.splice(0,2,'itm1',' itm2', 'itm3');console.log(arr);//['itm1','itm2','itm3',3,4,5]
Результаты выполнения кода следующие:
Приведенный выше код фактически выполняет двухэтапную операцию: сначала удаляет 2 элемента, начиная с 0 , а затем вставляет три новых элемента в позицию 0 .
Если мы изменим второй параметр (количество удалений) на 0 , то мы сможем только вставлять элементы без удаления элементов. Например:
let arr = [1,2,3,4,5]arr.splice( 0, 0,'x','y','z')console.log(arr);//['x','y','z'1,2,3,4,5]
Функция splice() вернет массив удаленных элементов, например:
let arr = [1,2,3,4,5]let res = arr.splice(0,3,'x','y' ) console.log(arr)//['x','y',4,5]console.log(res)//[1,2,3]
Результаты выполнения кода:
Мы можем использовать отрицательные числа, чтобы указать позицию, с которой начинаются рабочие элементы, например:
let arr = [1,2,3,4,5]arr.splice(-1,1,'x','y' ,'z ')console.log(arr)//[1,2,3,4,'x','y','z']
Результаты выполнения кода следующие:
Метод slice() может перехватывать массив в указанном диапазоне. Синтаксис следующий:
arr.slice([start],[end])
возвращает новый массив. Новый массив начинается с start и заканчивается в end , но не включает end .
Пример:
пусть arr = [1,2,3,4,5]console.log(arr.slice(2,5))//[3,4,5]console.log(arr.slice(1,3) )//[2,3]
Результат выполнения кода:
slice() также может использовать отрицательные индексы:
пусть arr = [1,2,3,4,5]console.log(arr.slice(-3))//[3,4,5]console.log(arr . срез(-5,-1))//[1,2,3,4]
Результаты выполнения кода следующие:
Если вы предоставите только один параметр методу slice() , он будет усечен до конца массива, как и splice() .
Функция concat() может объединять несколько массивов или значений других типов в длинный массив. Синтаксис следующий:
arr.concat(e1, e2, e3).
Приведенный выше код вернет новый массив, и новый массив объединяется с помощью arr Он формируется из e1 , e2 и e3 .
Пример:
let arr = [1,2,3]console.log(arr.concat([4,5],6,7,[8,9]))
Результат выполнения кода следующий:
Обычные объекты, даже если они выглядят так же, как объекты, все равно вставляются в массив целиком, например:
let arr = [1,2]let obj = {1:'1',2:2}console.log (arr.concat(obj)) результаты выполнения кода:
Однако если у объекта есть свойство Symbol.isConcatSpreadable , он будет рассматриваться как массив:
let arr = [1,2]let obj = {0:'x',
1: 'й',
[Symbol.isConcatSpreadable]: правда,
length:2 }console.log(arr.concat(obj)) результаты выполнения кода:
обходит весь массив и предоставляет операционную функцию для каждого элемента массива. Синтаксис:
let arr = [1,2]arr.forEach((itm,idx,array)=>{.
...}) Пример приложения:
пусть arr = [1,2,3,4,5]arr.forEach((itm)=>{
console.log(itm)}) результаты выполнения кода:
пусть arr = [1,2,3,4,5]arr.forEach((itm,idx,array)=>{
console.log(`arr[${idx}] in [${array}] is ${itm}`)}) результаты выполнения кода:
аналогичны строкам. indexOf , lastIndexOf и includes могут использоваться с индексом указанного элемента в массиве запроса:
arr.indexOf(itm,start) : Поиск itm начиная с start позиции. Если найдено, верните нижний индекс, в противном случае верните -1 ;arr.lastIndexOf(itm,start) : выполните поиск по всему массиву в обратном порядке до start и верните первый найденный нижний индекс (то есть последний соответствующий элемент в массиве). Если не найден, верните -1 ;arr.includes(itm,start) : Найдите itm с start позиции, верните true , если найдено, в противном случае верните false .Пример:
let arr = [1,2,3,4,5, 6,"7","8","9" ,0,0,true,false]console.log(arr.indexOf(0))//9console.log(arr.lastIndexOf(0))//10console. log(arr.includes(10))//falseconsole. log(arr.includes(9))//false
Эти методы используют === при сравнении элементов массива, поэтому false и 0 различны.
Обработка NaN
NaN — это специальное число, и между ними есть небольшие различия в обработке NaN :
let arr = [NaN,1,2,3,NaN]console.log(arr.includes(NaN))//trueconsole. log( arr.indexOf(NaN))//-1console.log(arr.lastIndexOf(NaN))//-1Причина
такого результата связана с характеристиками самого NaN , то есть NaN не равно никакому числу , включая его самого.
Это содержание обсуждалось в предыдущих главах. Что касается забытой детской обуви, не забудьте вспомнить прошлое и узнать новое.
часто сталкиваются с массивами объектов в процессе программирования, и объекты нельзя сравнивать напрямую с помощью === . Как найти в массиве объекты, соответствующие условиям?
На данный момент вам нужно использовать методы find и findIndex . Синтаксис следующий:
let result = arr.find(function(itm,idx,array){.
//элемент массива itm //нижний индекс элемента idx //сам массив массива //передаем функцию оценки, если функция возвращает true, возвращаем текущий объект itm}) Например, мы ищем объекты, атрибут name которых равен xiaoming :
пусть обр =[
{id:1,имя:'Сяомин'},
{id:2,имя:'сяохун'},
{id:3,name:'xiaojunn'},]let xiaoming = arr.find(function(itm,idx,array){
if(itm.name == 'xiaoming')return true;})console.log(xiaoming) результат выполнения кода:
Если нет объекта, соответствующего условиям, будет возвращено undefined .
Приведенный выше код также можно упростить до:
let xiaoming = arr.find((itm)=> itm.name == 'xiaoming').
Эффект выполнения точно такой же.
Назначение arr.findIndex(func) почти такое же, как и arr.find(func) с той лишь разницей, что arr.findIndex возвращает индекс квалифицированного объекта, а не сам объект. Если он не найден, он возвращает значение. -1 .
find и findIndex могут найти только один объект, соответствующий требованиям. Если в массиве есть несколько объектов, отвечающих требованиям, вам необходимо использовать метод filter . Синтаксис следующий:
let results = arr.filter(function(). itm,idx,массив){
//То же самое, что и find, но вернет массив объектов, соответствующих требованиям //Если не найден, будет возвращен пустой массив}) Например:
let arr =[
{id:1,имя:'Сяомин'},
{id:2,имя:'сяохун'},
{id:3,name:'xiaojunn'},]let res = arr.filter(function(itm,idx,array){
if(itm.name == 'xiaoming' || itm.name == 'xiaohong')return true;})console.log(res) результат выполнения кода:
arr.map вызывать функцию для каждого объекта массива, а затем возвращать обработанный массив. Это один из наиболее полезных и важных методов массивов.
Синтаксис:
let arrNew = arr.map(function(itm,idx,array){
//Вернем новый результат}) Например, вернем массив длин, соответствующий массиву строк:
let arr = ['I','am','a','student']let arrNew = arr.map((itm) = >itm.length)//вернуть itm.lengthconsole.log(arrNew)//[1,2,1,7]
результат выполнения кода:
arr.sort сортирует массив на месте и возвращает отсортированный массив. Однако, поскольку исходный массив был изменен, возвращаемое значение фактически бессмысленно.
Так называемая сортировка на месте означает сортировку в исходном пространстве массива вместо создания нового массива.
let arr = ['a','c','b']arr.sort()console.log(arr)
выполнение кода результат:
Обратите внимание, что по умолчанию метод
sortсортируется в алфавитном порядке , что подходит для сортировки строк. Если вы хотите сортировать другие типы массивов, вам необходимо настроить метод сравнения
для числовых массивов,
пусть arr = [1,3,2]. сортировка (функция (а, б) {
если (а > б) вернуть 1;
если (а < б) вернуть -1;
вернуть 0;}) Результат выполнения кода:
Функция sort внутренне использует алгоритм быстрой сортировки или это может быть алгоритм timsort , но нам не нужно об этом заботиться, нам нужно только обратить внимание на функцию сравнения.
Функция сравнения может возвращать любое числовое значение: положительное число означает > , отрицательное число означает < , а 0 означает равенство, поэтому мы можем упростить метод численного сравнения:
пусть arr = [1,3,2]arr.sort(( a,b)=> a - b)
Если вы хотите отсортировать в обратном порядке, просто поменяйте местами a и b :
пусть arr = [1,3,2]arr.sort((a,b)=> b - a)Сортировка
строк
Забыли использовать метод str.localeCompare(str1) для сравнения строк?
let arr = ['asdfas','success','failures']arr.sort((a,b)=>a.localeCompare (б))
Результат выполнения кода:
arr.reverse используется для обратных массивов.
let arr = [1,2,3]arr.reverse()console.log(arr)//[3,2,1]
По этому поводу нечего сказать.
Помните функцию разделения строк? Функция разделения строки может разделить строку на массив символов:
let str = 'xiaoming,xiaohong,xiaoli'let arr = str.split(',')//['xiaoming','xiaohong','xiali'] Непопулярно Насколько известно, функция
splitимеет второй параметр, который может ограничивать длину сгенерированного массива.let str = 'xiaoming,xiaohong,xiaoli'let arr = str.split(',',2)//['xiaoming',' xiaohong' ]
Метод arr.join() является противоположностью метода split . Он может объединить массив в строку.
Например:
let arr = [1,2,3]let str = arr.join(';')console.log(str) результат выполнения кода:
Метод arr.reduce аналогичен методу arr.map . Они оба передают метод, а затем последовательно вызывают этот метод для элементов массива. Разница в том, что когда метод app.map обрабатывает элементы массива, каждый из них. вызов элемента независим, и arr.reduce передаст результат вызова предыдущего элемента в метод обработки текущего элемента.
Синтаксис:
let res = arr.reduce(function(prev,itm,idx,array){
//prev — это результат, возвращаемый вызовом предыдущего элемента //init будет служить результатом вызова предыдущего элемента при выполнении первого элемента}, [init]) Только представьте, как реализовать сумму элементов массива, состоящих из цифры? Невозможно реализовать карту. В настоящее время вам нужно использовать arr.reduce :
let arr = [1,2,3,4,5]let res = arr.reduce((sum,itm)=>sum+. itm,0) console.log(res)//15
Процесс выполнения кода выглядит следующим образом:
arr.reduceRight имеет ту же цель, что и arr.reduce , за исключением того, что методы вызываются для элементов справа налево.
Массив — это особый случай объекта. Использование typeof не может точно различить разницу между ними:
console.log(typeof {})//objectconsole.log(typeof [])//object Оба являются объектами, мы необходимо использовать метод Array.isArray() для принятия дальнейших решений:
console.log(Array.isArray({}))//falseconsole.log(Array.isArray([]))// true arr.some(func) и arr.every(func) методы используются для проверки чисел, а механизм выполнения аналогичен map .
some
выполняет переданный метод для каждого элемента массива. Если метод возвращает true , он возвращает true немедленно. Если не все элементы возвращают true , он возвращает false .
Every
выполняет переданный метод для каждого элемента массива, возвращая true , если все элементы возвращают true , в противном случае он возвращает false .
Например:
let arr = [1,2,3,4,5]//Определяем, есть ли в массиве элементы больше 2 console.log(arr.some((itm)=>{
if(itm > 2)return true;}))//true//Определить, все ли элементы больше 2console.log(arr.every((itm)=>{
if(itm > 2)return true;}))//false Во всех методах массива, кроме sort , есть необычный фиксированный параметр thisArg . Синтаксис следующий:
arr.find(func,thisArg)arr.filter( func,thisArg)arr.map(func,thisArg)
Если мы передадим thisArg , то в func он станет this .
В обычных обстоятельствах этот параметр малопригоден, но если func является методом-членом (методом объекта) и this используется в методе, то thisArg будет очень значимым.
Например:
пусть obj = {
номер: 3,
функция (итм) {
console.log(это)
return itm > this.num;//Найти числа больше 3}}let arr = [1,2,3,4,5,6,7]let newArr = arr.filter(obj.func,obj)console.log (newArr) результат выполнения кода:
Здесь мы видим, что this вывод в func — это значение thisArg которое мы передали.
Если мы используем методы-члены объекта без указания значения thisArg , this будет undefined , что приведет к ошибке программы.