Все, что вам нужно знать о массивах

ВВЕДЕНИЕ

Массив — это самая распространенная структура данных в компьютерном программировании. Каждый язык программирования включает в себя ту или иную форму массива. Массивы обычно используются в компьютерных программах для организации данных таким образом, чтобы связанный набор значений можно было легко сортировать или искать.

Поэтому для большинства моих фрагментов кода я буду использовать язык JavaScript, с которым мне удобнее всего работать, но я также постараюсь написать код так, чтобы его могли понять программисты с других языков.

ОПРЕДЕЛЕНИЕ МАССИВА

Массив — это структура данных, которая содержит группу элементов. Как правило, все эти элементы имеют один тип данных, например, целое число или строка.

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

score_0
score_1
score_2
score_3
score_4
score_5
score_6
score_7
score_8
score_9

Это сработает, но есть способ получше. Гораздо проще хранить все связанные данные под одним именем. Для этого мы используем массив.
Вместо десяти переменных, каждая из которых содержит оценку, можно использовать один массив, содержащий все связанные данные:
score(9)

Возможно, вам интересно, почему score(9)? Когда у нас 10 оценок, это потому, что массивы имеют нулевую индексацию; то есть, когда элементы хранятся в массиве, каждому элементу массива присваивается индекс/ключ, чтобы мы могли получить доступ или изменить этот элемент в будущем.

Вот иллюстрация:

Массив можно представить как ряд ячеек, как в таблице. Каждая ячейка представляет собой элемент. Отдельные значения, или элементы массива, нумеруются от 0 до 9, поскольку счет в массивах начинается с 0.

В другом примере поисковая система может использовать массив для хранения веб-страниц, найденных в результате поиска, выполненного пользователем. При выводе результатов программа будет выводить по одному элементу массива за раз. Это может быть сделано для определенного количества значений или пока не будут выведены все значения, хранящиеся в массиве. Хотя программа может создать новую переменную для каждого найденного результата, хранение результатов в массиве является более эффективным способом управления памятью.

Синтаксис для хранения и отображения значений в массиве обычно выглядит следующим образом:

arrayname[0] = "This ";
arrayname[1] = "is ";
arrayname[2] = "pretty simple.";

console.log(arrayname[0]);
console.log(arrayname[1]);
console.log(arrayname[2]);

Приведенные выше команды выведут первые три значения массива, или «Это довольно просто».

Используя цикл «while» или «for», программист может указать программе выводить каждое значение в массиве, пока не будет достигнуто последнее значение. Таким образом, массивы не только помогают более эффективно управлять памятью, но и делают работу программиста более эффективной.

ИСПОЛЬЗОВАНИЕ МАССИВОВ

Существует несколько способов создания массивов, доступа к элементам массива и выполнения таких задач, как поиск и сортировка элементов, хранящихся в массиве. В этом разделе мы рассмотрим несколько методов и свойств массивов.

Создание массива

Самый простой способ создать массив — объявить переменную массива с помощью оператора []:

var numbers = [];

Когда вы создаете массив таким образом, у вас получается массив с длиной 0. Вы можете проверить это, вызвав встроенное свойство length:

console.log(numbers.length); // displays 0

Другой способ создания массива — объявить переменную массива с набором элементов внутри оператора []:

var numbers = [1,2,3,4,5];
console.log(numbers.length); // displays 5

Вы также можете создать массив, вызвав конструктор Array:

var numbers = new Array();
console.log(numbers.length); // displays 0

Вы можете вызвать конструктор Array с набором элементов в качестве аргументов конструктора:

var numbers = new Array(1,2,3,4,5);
console.log(numbers.length); // displays 5

Наконец, можно создать массив, вызвав конструктор Array с единственным аргументом, задающим длину массива:

var numbers = new Array(10);
console.log(numbers.length); // displays 10

В отличие от многих других языков программирования, но характерно для большинства скриптовых языков,
элементы массива JavaScript не обязательно должны быть одного типа:

var objects = [1, "Joe", true, null];

Мы можем проверить, что объект является массивом, вызвав функцию Array.isArray(), например
вот так:

var numbers = 3;
var arr = [7,4,1776];
console.log(Array.isArray(number)); // displays false
console.log(Array.isArray(arr)); // displays true

Мы рассмотрели несколько методов создания массивов. Что касается того, какая функция лучше, большинство экспертов JavaScript рекомендуют использовать оператор [], утверждая, что это более эффективно, чем вызов конструктора Array.

Доступ и запись элементов массива

Данные присваиваются элементам массива с помощью оператора [] в операторе присваивания.
Например, в следующем цикле массиву присваиваются значения от 1 до 100:

var nums = [];
for (var i = 0; i < 100; ++i) {
  nums[i] = i + 1;
}

Доступ к элементам массива также осуществляется с помощью оператора []. Например:

var numbers = [1,2,3,4,5];
var sum = numbers[0] + numbers[1] + numbers[2] + numbers[3] +
numbers[4];
console.log(sum); // displays 15

Конечно, получить последовательный доступ ко всем элементам массива гораздо проще с помощью цикла for
цикл:

var numbers = [1, 2, 3, 5, 8, 13, 21];
var sum = 0;
for (var i = 0; i < numbers.length; ++i) {
  sum += numbers[i];
}
console.log(sum); // displays 53

Обратите внимание, что цикл for управляется с помощью свойства length, а не целочисленного литерала. Поскольку массивы JavaScript являются объектами, они могут вырасти за пределы размера, указанного при их создании. Используя свойство length, которое возвращает количество элементов, находящихся в массиве в данный момент, вы можете гарантировать, что ваш цикл обработает все элементы массива.

Создание массивов из строк

(метод Split)

Массивы могут быть созданы в результате вызова функции split() для строки. Эта
функция разбивает строку по общему разделителю, например, пробелу для каждого слова, и
создается массив, состоящий из отдельных частей строки.

Следующая короткая программа демонстрирует, как функция split() работает на простой
строке:

var sentence = "the quick brown fox jumped over the lazy dog";
var words = sentence.split(" ");
for (var i = 0; i < words.length; ++i) {
  console.log("word " + i + ": " + words[i]);
}

Вывод этой программы следующий:

word 0: the
word 1: quick
word 2: brown
word 3: fox
word 4: jumped
word 5: over
word 6: the
word 7: lazy
word 8: dog

(Метод Array.from())

Функция Array.from() — это встроенная функция в JavaScript, которая создает новый экземпляр массива из заданного массива. В случае строки каждый алфавит строки преобразуется в элемент нового экземпляра массива, а в случае целочисленных значений новый экземпляр массива принимает простые элементы заданного массива.

var sentence = "the quick brown fox jumped over the lazy dog";
var words = Array.from(sentence);
console.log(words)

[
  't', 'h', 'e', ' ', 'q', 'u', 'i',
  'c', 'k', ' ', 'b', 'r', 'o', 'w',
  'n', ' ', 'f', 'o', 'x', ' ', 'j',
  'u', 'm', 'p', 'e', 'd', ' ', 'o',
  'v', 'e', 'r', ' ', 't', 'h', 'e',
  ' ', 'l', 'a', 'z', 'y', ' ', 'd',
  'o', 'g'
]

Агрегатные операции с массивами

Существует несколько операций агрегирования, которые можно выполнять с массивами. Во-первых, вы можете присвоить один массив другому массиву:

var nums = [];
for (var i = 0; i < 10; ++i) {
  nums[i] = i+1;
}
var samenums = nums;

Однако, когда вы присваиваете один массив другому массиву, вы присваиваете ссылку на присвоенный массив. Когда вы вносите изменения в исходный массив, эти изменения отражаются и в другом массиве. Следующий фрагмент кода демонстрирует, как это работает:

var nums = [];
for (var i = 0; i < 100; ++i) {
  nums[i] = i+1;
}
var samenums = nums;
nums[0] = 400;
console.log(samenums[0]); // displays 400

Это называется неглубоким копированием. Новый массив просто указывает на элементы исходного массива. Лучшей альтернативой является глубокое копирование, при котором каждый элемент исходного массива фактически копируется в элементы нового массива. Эффективный способ сделать это — создать функцию для выполнения этой задачи:

function copy(arr1, arr2) {
  for (var i = 0; i < arr1.length; ++i) {
    arr2[i] = arr1[i];
  }
}

Теперь следующий фрагмент кода дает ожидаемый результат:

var nums = [];
for (var i = 0; i < 100; ++i) {
  nums[i] = i+1;
}
var samenums = [];
copy(nums, samenums);
nums[0] = 400;
console.log(samenums[0]); // displays 1

Функции доступа

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

Поиск значения

Одной из наиболее часто используемых функций-дополнителей является indexOf(), которая проверяет, находится ли переданный функции аргумент в массиве. Если аргумент содержится в массиве, функция возвращает индексную позицию аргумента. Если аргумент не найден в массиве, функция возвращает -1. Вот пример:

var names = ["David", "Cynthia", "Raymond", "Clayton", "Jennifer"];
putstr("Enter a name to search for: ");
var name = readline();
var position = names.indexOf(name);
if (position >= 0) {
  console.log("Found " + name + " at position " + position);
}
else {
  console.log(name + " not found in array.");
}

Если запустить эту программу и ввести Cynthia, программа выдаст:

Found Cynthia at position 1

Если вы введете Джо, программа выдаст следующее:

Joe not found in array.

Если в массиве имеется несколько вхождений одних и тех же данных, функция indexOf() всегда возвращает позицию первого вхождения. Аналогичная функция, lastIndexOf(), возвращает позицию последнего вхождения аргумента в массив, или -1
если аргумент не найден.

Вот пример:

var names = ["David", "Mike", "Cynthia", "Raymond", "Clayton", "Mike", "Jennifer"];
var name = "Mike";
var firstPos = names.indexOf(name);
console.log("First found " + name + " at position " + firstPos);
var lastPos = names.lastIndexOf(name);
console.log("Last found " + name + " at position " + lastPos);

Вывод этой программы следующий:

First found Mike at position 1
Last found Mike at position 5

Строковое представление массивов

Существует две функции, возвращающие строковое представление массива: join() и toString(). Обе функции возвращают строку, содержащую элементы массива, разделенные запятыми.

Вот несколько примеров:

var names = ["David", "Cynthia", "Raymond", "Clayton", "Mike", "Jennifer"];
var namestr = names.join();
console.log(namestr); // David,Cynthia,Raymond,Clayton,Mike,Jennifer
namestr = names.toString();
console.log(namestr); // David,Cynthia,Raymond,Clayton,Mike,Jennifer

Создание новых массивов из существующих массивов

Есть две вспомогательные функции, которые позволяют создавать новые массивы из существующих: concat() и splice().

Функция concat() позволяет объединить два или более массивов для создания нового массива, а функция splice() позволяет создать новый массив из подмножества существующего массива.
Сначала рассмотрим, как работает функция concat(). Функция вызывается из существующего массива, а ее аргументом является другой существующий массив. Аргумент конкатенируется в конец массива, вызываемого функцией concat(). Следующая программа демонстрирует работу функции concat():

var cisDept = ["Mike", "Clayton", "Terrill", "Danny", "Jennifer"];
var dmpDept = ["Raymond", "Cynthia", "Bryan"];
var itDiv = cis.concat(dmp);
console.log(itDiv);
itDiv = dmp.concat(cisDept);
console.log(itDiv);

Программа выводит:

Mike,Clayton,Terrill,Danny,Jennifer,Raymond,Cynthia,Bryan
Raymond,Cynthia,Bryan,Mike,Clayton,Terrill,Danny,Jennifer

В первой выходной строке сначала отображаются данные из массива cis, а во второй — данные из массива dmp.

Функция splice() создает новый массив из содержимого существующего массива. Аргументами функции являются начальная позиция для взятия сплайса и количество элементов, которые нужно взять из существующего массива.

Вот как работает этот метод:

var itDiv = ["Mike","Clayton","Terrill","Raymond","Cynthia","Danny","Jennifer"];
var dmpDept = itDiv.splice(3,3);
var cisDept = itDiv;
console.log(dmpDept); // Raymond,Cynthia,Danny
console.log(cisDept); // Mike,Clayton,Terrill,Jennifer

Существуют и другие способы использования функции splice(), например, модификация массива путем добавления и/или удаления элементов. Более подробную информацию можно найти на сайте Mozilla Developer Network.

Функции-мутаторы

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

Добавление элементов в массив

Для добавления элементов в массив существуют две функции-мутаторы: push() и unshift(). Функция push() добавляет элемент в конец массива:

var nums = [1,2,3,4,5];
console.log(nums); // 1,2,3,4,5
nums.push(6);
console.log(nums); // 1,2,3,4,5,6

Использование push() более интуитивно понятно, чем использование свойства length для расширения массива:

var nums = [1,2,3,4,5];
console.log(nums); // 1,2,3,4,5
nums[nums.length] = 6;
console.log(nums); // 1,2,3,4,5,6

Добавить данные в начало массива гораздо сложнее, чем добавить данные в конец массива. Чтобы сделать это без использования функции мутатора, каждый существующий элемент массива должен быть сдвинут на одну позицию вверх перед добавлением новых данных. Вот код, иллюстрирующий этот сценарий:

var nums = [2,3,4,5];
var newnum = 1;
var N = nums.length;
for (var i = N; i >= 0; --i) {
  nums[i] = nums[i-1];
}
nums[0] = newnum;
console.log(nums); // 1,2,3,4,5

Этот код становится все более неэффективным по мере увеличения количества элементов, хранящихся в массиве. Функция-мутатор для добавления элементов массива в начало массива — unshift(). Вот как работает эта функция:

var nums = [2,3,4,5];
console.log(nums); // 2,3,4,5
var newnum = 1;
nums.unshift(newnum);
console.log(nums); // 1,2,3,4,5
nums = [3,4,5];
nums.unshift(1,2);
console.log(nums); // 1,2,3,4,5

Второй вызов unshift() демонстрирует, что вы можете добавить несколько элементов в массив одним вызовом функции.

Удаление элементов из массива

Удалить элемент из конца массива легко с помощью функции-мутатора pop():

var nums = [1,2,3,4,5,9];
nums.pop();
console.log(nums); // 1,2,3,4,5

Без функций-мутаторов удаление элементов из начала массива требует смещения элементов к началу массива, что вызывает ту же неэффективность, которую мы наблюдаем при добавлении элементов в начало массива:

var nums = [9,1,2,3,4,5];
console.log(nums);
for (var i = 0; i < nums.length; ++i) {
  nums[i] = nums[i+1];
}
console.log(nums); // 1,2,3,4,5,

Помимо того, что нам приходится сдвигать элементы вниз, чтобы свернуть массив, у нас также остается лишний элемент. Мы знаем об этом благодаря дополнительной запятой, которую мы видим при отображении содержимого массива.

Функция-мутатор, необходимая нам для удаления элемента из начала массива, — shift(). Вот как работает эта функция:

var nums = [9,1,2,3,4,5];
nums.shift();
console.log(nums); // 1,2,3,4,5

Вы заметите, что в конце массива не осталось лишних элементов. И pop(), и shift() возвращают удаленные значения, поэтому их можно собрать в переменную:

var nums = [6,1,2,3,4,5];
var first = nums.shift(); // first gets the value 9
nums.push(first);
console.log(nums); // 1,2,3,4,5,6

Добавление и удаление элементов из середины массива

Попытка добавить или удалить элементы в конце массива приводит к тем же проблемам, что и при попытке добавить или удалить элементы из начала массива — обе операции требуют смещения элементов массива либо к началу, либо к концу массива. Однако есть одна функция мутатора, которую мы можем использовать для выполнения обеих операций — splice().

Чтобы добавить элементы в массив с помощью функции splice(), необходимо предоставить следующие аргументы:

— Начальный индекс (с которого вы хотите начать добавление элементов)

— Количество элементов для удаления (0, если вы добавляете элементы)

— Элементы, которые вы хотите добавить в массив.

Давайте рассмотрим простой пример. Следующая программа добавляет элементы в середину массива:

var nums = [1,2,3,7,8,9];
var newElements = [4,5,6];
nums.splice(3,0,newElements);
console.log(nums); // 1,2,3,4,5,6,7,8,9

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

Например:

var nums = [1,2,3,7,8,9];
nums.splice(3,0,4,5,6);
console.log(nums);

В предыдущем примере аргументы 4, 5 и 6 представляют собой список элементов, которые мы хотим вставить в nums.
А вот пример использования функции splice() для удаления элементов из массива:

var nums = [1,2,3,100,200,300,400,4,5];
nums.splice(3,4);
console.log(nums); // 1,2,3,4,5

Упорядочивание элементов массива

Последние две функции мутатора используются для упорядочивания элементов массива в определенном порядке. Первая из них, reverse(), изменяет порядок элементов массива на обратный.

Вот пример ее использования:

var nums = [1,2,3,4,5];
nums.reverse();
console.log(nums); // 5,4,3,2,1

Нам часто требуется отсортировать элементы массива по порядку. Функция-мутатор sort(), предназначенная для этой задачи, отлично работает со строками:

var names = ["David","Mike","Cynthia","Clayton","Bryan","Raymond"];
nums.sort();
console.log(nums); // Bryan,Clayton,Cynthia,David,Mike,Raymond

Но sort() не так хорошо работает с числами:

var nums = [3,1,2,100,4,200];
nums.sort();
console.log(nums); // 1,100,2,200,3,4

Функция sort() сортирует данные лексикографически, предполагая, что элементы данных являются строками, хотя в предыдущем примере элементами являются числа. Мы можем заставить функцию sort() корректно работать для чисел, передав в качестве первого аргумента функции функцию упорядочивания, которую sort() будет использовать для сортировки элементов массива. Именно эта функция будет использоваться sort() при сравнении пар элементов массива для определения их правильного порядка.

Для чисел функция упорядочивания может просто вычитать одно число из другого. Если возвращаемое число отрицательно, то левый операнд меньше правого; если возвращаемое число равно нулю, то левый операнд равен правому; а если возвращаемое число положительно, то левый операнд больше правого.

Учитывая это, давайте повторим предыдущую небольшую программу, используя функцию упорядочивания:

function compare(num1, num2) {
  return num1 - num2;
}
var nums = [3,1,2,100,4,200];
nums.sort(compare);
console.log(nums); // 1,2,3,4,100,200

Функция sort() использует функцию compare() для сортировки элементов массива не лексикографически, а численно.

Функции итератора

Последний набор функций массива, который мы рассмотрим, — это функции-итераторы. Эти функции применяют функцию к каждому элементу массива, возвращая либо значение, либо набор значений, либо новый массив после применения функции к каждому элементу массива.

Функции-итераторы, не генерирующие массивы

Первая группа функций итератора, которую мы рассмотрим, не создает новый массив; вместо этого они либо выполняют операцию над каждым элементом массива, либо генерируют одно значение из массива. Первая из этих функций — forEach(). Эта функция принимает функцию в качестве аргумента и применяет вызванную функцию к каждому элементу массива.

Ниже приведен пример ее работы:

function square(num) {
  console.log(num, num * num);
}
var nums = [1,2,3,4,5,6,7,8,9,10];
nums.forEach(square);

Выход из этого режима будет следующим:

1 1
2 4
3 9
4 16
5 25
6 36
7 49
8 64
9 81
10 100

Следующая функция итератора, ** every()**, применяет булеву функцию к массиву и возвращает true, если функция может вернуть true для каждого элемента в массиве.

Вот пример:

function isEven(num) {
  return num % 2 == 0;
}
var nums = [2,4,6,8,10];
var even = nums.every(isEven);
if (even) {
  console.log("all numbers are even");
}
else {
  console.log("not all numbers are even");
}

Программа отображает:

all numbers are even

Если мы изменим массив на:

var nums = [2,4,6,7,8,10];

программа отобразит:

not all numbers are even

Функция some() принимает булеву функцию и возвращает true, если хотя бы один из элементов массива удовлетворяет критерию булевой функции.

Например:

function isEven(num) {
  return num % 2 == 0;
}
var nums = [1,2,3,4,5,6,7,8,9,10];
var someEven = nums.some(isEven);
if (someEven) {
  console.log("some numbers are even");
}
else {
  console.log("no numbers are even");
}
nums = [1,3,5,7,9];
someEven = nums.some(isEven);
if (someEven) {
  console.log("some numbers are even");
}
else {
  console.log("no numbers are even");
}

Выход из этого режима будет следующим:

some numbers are even
no numbers are even

Функция reduce() применяет функцию к аккумулятору и последовательным элементам массива до тех пор, пока не будет достигнут конец массива, давая одно значение. Вот пример использования функции reduce() для вычисления суммы элементов массива:

function add(runningTotal, currentValue) {
  return runningTotal + currentValue;
}
var nums = [1,2,3,4,5,6,7,8,9,10];
var sum = nums.reduce(add);
console.log(sum); // displays 55

Функция reduce() в сочетании с функцией add() работает слева направо,
вычисляя текущую сумму элементов массива, как показано ниже:

add(1,2) -> 3
add(3,3) -> 6
add(6,4) -> 10
add(10,5) -> 15
add(15,6) -> 21
add(21,7) -> 28
add(28,8) -> 36
add(36,9) -> 45
add(45,10) -> 55

Мы также можем использовать reduce() со строками для выполнения конкатенации:

function concat(accumulatedString, item) {
  return accumulatedString + item;
}
var words = ["the ", "quick ","brown ", "fox "];
var sentence = words.reduce(concat);
console.log(sentence); // displays "the quick brown fox"

JavaScript также предоставляет функцию reduceRight(), которая работает аналогично reduce(), только не слева направо, а справа налево. Следующая программа использует reduceRight() для инвертирования элементов массива:

function concat(accumulatedString, item) {
  return accumulatedString + item;
}
var words = ["the ", "quick ","brown ", "fox "];
var sentence = words.reduceRight(concat);
console.log(sentence); // displays "fox brown quick the"

Функции итератора, возвращающие новый массив

Есть две функции итератора, которые возвращают новые массивы: map() и filter().

Функция map() работает подобно функции forEach(), применяя функцию к каждому элементу массива. Разница между этими двумя функциями заключается в том, что map() возвращает новый массив с результатами применения функции.

Вот пример:

function curve(grade) {
  return grade += 5;
}
var grades = [77, 65, 81, 92, 83];
var newgrades = grades.map(curve);
console.log(newgrades); // 82, 70, 86, 97, 88

Вот пример с использованием строк:

function first(word) {
  return word[0];
}
var words = ["for","your","information"];
var acronym = words.map(first);
console.log(acronym.join("")); // displays "fyi"

В последнем примере массив acronym хранит первую букву каждого слова из массива words.

Однако если мы хотим отобразить элементы массива в виде истинного акронима, нам нужно избавиться от запятых, которые будут отображаться, если мы просто отобразим элементы массива с помощью подразумеваемой функции toString(). Для этого мы вызываем функцию join() с пустой строкой в качестве разделителя.

Функция filter() работает аналогично функции every(), но вместо того, чтобы возвращать true, если все элементы массива удовлетворяют булевой функции, функция возвращает новый массив, состоящий из тех элементов, которые удовлетворяют булевой функции.

Вот пример:

function isEven(num) {
  return num % 2 == 0;
}
function isOdd(num) {
  return num % 2 != 0;
}
var nums = [];
  for (var i = 0; i < 20; ++i) {
  nums[i] = i+1;
}
var evens = nums.filter(isEven);
console.log("Even numbers: ");
console.log(evens);
var odds = nums.filter(isOdd);
console.log("Odd numbers: ");
console.log(odds);

Эта программа выдает следующий результат:

Even numbers:
2,4,6,8,10,12,14,16,18,20
Odd numbers:
1,3,5,7,9,11,13,15,17,19

Вот еще одно интересное использование filter():

function passing(num) {
  return num >= 60;
}
var grades = [];
for (var i = 0; i < 20; ++i) {
  grades[i] = Math.floor(Math.random() * 101);
}
var passGrades = grades.filter(passing);
console.log("All grades: );
console.log(grades);
console.log("Passing grades: ");
console.log(passGrades);

Эта программа отображает:

All grades:
39,43,89,19,46,54,48,5,13,31,27,95,62,64,35,75,79,88,73,74
Passing grades:
89,95,62,64,75,79,88,73,74

Конечно, мы также можем использовать filter() со строками. Вот пример, в котором применяется правило правописания «i перед e, кроме как после c»:

function afterc(str) {
if (str.indexOf("cie") > -1) {
  return true;
}
  return false;
}
var words = ["recieve","deceive","percieve","deceit","concieve"];
var misspelled = words.filter(afterc);
console.log(misspelled); // displays recieve,percieve,concieve

На данном этапе, я думаю, мне удалось объяснить, что такое массивы, как мы их используем и как использовать несколько встроенных функций в Javascript для выполнения некоторых операций с массивами.

В следующей части этой статьи мы рассмотрим двумерные и многомерные формы массивов, массивы объектов и массивы в объектах.

Увидимся в следующий раз.