Как узнать номер элемента массива

For primitive arrays

Starting with Java 8, the general purpose solution for a primitive array arr, and a value to search val, is:

public static int indexOf(char[] arr, char val) {
    return IntStream.range(0, arr.length).filter(i -> arr[i] == val).findFirst().orElse(-1);
}

This code creates a stream over the indexes of the array with IntStream.range, filters the indexes to keep only those where the array’s element at that index is equal to the value searched and finally keeps the first one matched with findFirst. findFirst returns an OptionalInt, as it is possible that no matching indexes were found. So we invoke orElse(-1) to either return the value found or -1 if none were found.

Overloads can be added for int[], long[], etc. The body of the method will remain the same.

For Object arrays

For object arrays, like String[], we could use the same idea and have the filtering step using the equals method, or Objects.equals to consider two null elements equal, instead of ==.

But we can do it in a simpler manner with:

public static <T> int indexOf(T[] arr, T val) {
    return Arrays.asList(arr).indexOf(val);
}

This creates a list wrapper for the input array using Arrays.asList and searches the index of the element with indexOf.

This solution does not work for primitive arrays, as shown here: a primitive array like int[] is not an Object[] but an Object; as such, invoking asList on it creates a list of a single element, which is the given array, not a list of the elements of the array.

For primitive arrays

Starting with Java 8, the general purpose solution for a primitive array arr, and a value to search val, is:

public static int indexOf(char[] arr, char val) {
    return IntStream.range(0, arr.length).filter(i -> arr[i] == val).findFirst().orElse(-1);
}

This code creates a stream over the indexes of the array with IntStream.range, filters the indexes to keep only those where the array’s element at that index is equal to the value searched and finally keeps the first one matched with findFirst. findFirst returns an OptionalInt, as it is possible that no matching indexes were found. So we invoke orElse(-1) to either return the value found or -1 if none were found.

Overloads can be added for int[], long[], etc. The body of the method will remain the same.

For Object arrays

For object arrays, like String[], we could use the same idea and have the filtering step using the equals method, or Objects.equals to consider two null elements equal, instead of ==.

But we can do it in a simpler manner with:

public static <T> int indexOf(T[] arr, T val) {
    return Arrays.asList(arr).indexOf(val);
}

This creates a list wrapper for the input array using Arrays.asList and searches the index of the element with indexOf.

This solution does not work for primitive arrays, as shown here: a primitive array like int[] is not an Object[] but an Object; as such, invoking asList on it creates a list of a single element, which is the given array, not a list of the elements of the array.

В этом посте будет обсуждаться, как найти индекс элемента в массиве в C#.

Решение должно либо возвращать индекс первого вхождения требуемого элемента, либо -1, если его нет в массиве.

1. Использование Array.IndexOf() метод

Рекомендуемое решение — использовать Array.IndexOf() метод, который возвращает индекс первого вхождения указанного элемента в этот массив.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

using System; public static class Extensions {     public static int findIndex<T>(this T[] array, T item) {         return Array.IndexOf(array, item);     } } public class Example {     public static void Main()     {         int[] array = { 1, 2, 3, 4, 5 };         int item = 4;         int index = array.findIndex(item);         if (index != —1) {             Console.WriteLine(String.Format(«Element {0} is found at index {1}», item, index));         }         else {             Console.WriteLine(«Element not found in the given array.»);         }     } } /*     результат: Element 4 is found at index 3 */

Скачать  Выполнить код

2. Использование Array.FindIndex() метод

The Array.FindIndex() метод возвращает индекс первого элемента, который удовлетворяет предоставленному предикату, или -1 если такого элемента нет.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

using System; public static class Extensions {     public static int findIndex<T>(this T[] array, T item) {         return Array.FindIndex(array, val => val.Equals(item));     } } public class Example {     public static void Main()     {         int[] array = { 1, 2, 3, 4, 5 };         int item = 4;         int index = array.findIndex(item);         if (index != —1) {             Console.WriteLine(String.Format(«Element {0} is found at index {1}», item, index));         }         else {             Console.WriteLine(«Element not found in the given array.»);         }     } } /*     результат: Element 4 is found at index 3 */

Скачать  Выполнить код

3. Использование Enumerable.Select() метод

The System.Linq.Enumerable.Select() метод проецирует каждый элемент последовательности в новую форму. В следующем примере кода показано, как мы можем использовать Select() для проецирования последовательности значений и использования как значения, так и индекса каждого элемента, чтобы найти первое вхождение указанного элемента в этом массиве.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

using System; using System.Linq; using System.Collections.Generic; public static class Extensions {     public static int findIndex<T>(this T[] array, T item)     {         try {             return array                 .Select((element, index) => new KeyValuePair<T, int>(element, index))                 .First(x => x.Key.Equals(item)).Value;         }         catch (InvalidOperationException) {             return —1;         }     } } public class Example {     public static void Main()     {         int[] array = { 1, 2, 3, 4, 5 };         int item = 4;         int index = array.findIndex(item);         if (index != —1) {             Console.WriteLine(String.Format(«Element {0} is found at index {1}», item, index));         }         else {             Console.WriteLine(«Element not found in the given array.»);         }     } } /*     результат: Element 4 is found at index 3 */

Скачать  Выполнить код

 
Мы можем избежать блока try-catch, используя FirstOrDefault() метод вместо First():

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

using System; using System.Linq; public static class Extensions {     public static int findIndex<T>(this T[] array, T item)     {         return array             .Select((element, index) => new { element, index })             .FirstOrDefault(x => x.element.Equals(item)) ?. index ?? —1;     } } public class Example {     public static void Main()     {         int[] array = { 1, 2, 3, 4, 5 };         int item = 4;         int index = array.findIndex(item);         if (index != —1) {             Console.WriteLine(String.Format(«Element {0} is found at index {1}», item, index));         }         else {             Console.WriteLine(«Element not found in the given array.»);         }     } } /*     результат: Element 4 is found at index 3 */

Скачать  Выполнить код

4. Выполнение линейного поиска

Наивное решение состоит в том, чтобы выполнить линейный поиск в заданном массиве, чтобы определить, присутствует ли целевой элемент в массиве.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

using System; using System.Collections.Generic; public static class Extensions {     public static int findIndex<T>(this T[] array, T item)     {         EqualityComparer<T> comparer = EqualityComparer<T>.Default;         for (int i = 0; i < array.Length; i++)         {             if (comparer.Equals(array[i], item)) {                 return i;             }         }         return —1;     } } public class Example {     public static void Main()     {         int[] array = { 1, 2, 3, 4, 5 };         int item = 4;         int index = array.findIndex(item);         if (index != —1) {             Console.WriteLine(String.Format(«Element {0} is found at index {1}», item, index));         }         else {             Console.WriteLine(«Element not found in the given array.»);         }     } } /*     результат: Element 4 is found at index 3 */

Скачать  Выполнить код

Вот и все, что касается поиска индекса элемента в массиве в C#.

Спасибо за чтение.

Пожалуйста, используйте наш онлайн-компилятор размещать код в комментариях, используя C, C++, Java, Python, JavaScript, C#, PHP и многие другие популярные языки программирования.

Как мы? Порекомендуйте нас своим друзьям и помогите нам расти. Удачного кодирования 🙂

Array

Объект Array служит для создания массивов. Массив — это набор элементов, содержащих значения, сохраненный под одним именем. Например, массив score может использоваться для сохранения счета сыгранных матчей. Массивы могут состоять из чисел, строковых переменных, объектов и других типов данных. Перед использованием массив необходимо объявить через конструктор Array и оператор new.

Создадим несколько массивов:

array1 = new Array(); // массив без заданных значений
array2 = new Array(30); // Массив из 30 элементов
array3 = new Array(1,, 2, 3, "four", "five"); // Массив с определенными значениями

Если длина массива не определена, как показано в первом примере, то она может изменяться динамически, при этом элементами массива могут быть значения любого типа. Чтобы определить значения массива, укажите его индекс в скобках. Индексирование элементов массива начинается с 0, поэтому элементы объявленного выше второго массива имеют индексы 0—29, но общее их количество равно числу аргументов. Следующие операторы определяют значения первых четырех элементов массива:

scores[0] = 39;
scores[1] = 40;
scores[2] = 100;
scores[3] = 49;

Также можно использовать другой способ создания массива через квадратные скобки.

const cats = ["Барсик", "Мурзик", "Рыжик"];
console.log(cats[2]); // выводит третий элемент массива Рыжик

Вы можете переписать значение в массиве по его индексу.

cats[1] = "Васька";
// Проверим
console.log(cats[1]);

Можно сначала создать пустой массив, а потом добавить нужные элементы.

const cats[];
cats[0] = "Барсик";
cats[1] = "Мурзик";

Можно добавлять не по порядку, например, сразу в пятый индекс. Тогда в 3 и 4 будут значения undefined.

cats[5] = "Пушок";
console.log(cats[4]);

В массив можно вложить ещё один массив.

Массивы имеют свойство length. Оно определяет количество элементов, из которых состоит массив. Оно же определяется при создании массива. В следующем примере отображается число элементов массива array2:

console.log(array2.length);

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

console.log(cats.length - 1);

Массивы часто используются в циклах

var num = new Array (1, 2, 3, 4, 5, 6, 7, 8, 9);
var sum = 0;
for (i = 0; i < num.length; i++)
  sum += num[i];

В начале примера инициируется массив с именем num, состоящий из девяти элементов. В цикле пробегаем по всем элементам массива с помощью конструкции num[i] и суммируем все значения массива.

Массивы являются весьма гибкими. Размер массива устанавливается динамически. Если мы создадим массив myArray[29] = «Вася», то величина массива автоматически устанавливается в размере 30 элементов.

Массивы в JavaScript могут лишь увеличиваться в размерах, но не могут уменьшаться.

Управление элементами массива

Содержимое массива определяется значениями его элементов. При управлении элементами массива используются те же методы, что и при управлении значениями и переменными. Например, следующий оператор позволяет отобразить значения первых четырех элементов массива scores:

scoredisp = "Статистика: " + scores[0] + "," + scores[1] + "," + scores[2] + "," + scores [3];
document.write(scoredisp);

Использование строковых массивов

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

names = new Array(30);
names[0] = "Александр";
names[1] = "Вера";

Элементы строкового массива используются везде, где позволено использовать строковые переменные. Все описанные выше методы выполняются и для элементов строковых массивов. Например, следующий оператор позволяет распечатать первые пять символов значения первого элемента массива names:

document.write(names[0].substring(0,5));

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

Для добавления нового элемента в массив используется метод push(), в скобках нужно указать элемент для добавления.

var cats = ["Барсик", "Мурзик", "Рыжик"];
cats.push("Васька");
console.log(cats);

При добавлении нового элемента изменяется длина массива. Сам элемент добавляется в конец массива.

Для добавления элемента в начало массива используйте метод unshift().

cats.unshift("Пушок");

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

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

Удалить последний элемент массива можно через метод pop(), который возвращает удаляемый элемент. Соответственно, уменьшается и длина массива.

var deleted = cats.pop();
console.log(deleted);

Первый элемент можно удалить через метод shift(), который также возвращает значение удаляемого элемента.

deleted = cats.shift();
console.log(deleted);

Объединение массивов

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

firstArray.concat(secondArray)

Попробуем.

var cats = ["Барсик", "Мурзик", "Рыжик"];
var dogs = ["Бобик", "Шарик", "Тузик"];
var pets = cats.concat(dogs);
console.log(pets);

Сами массивы остаются прежними и не меняются.

Можно объединять несколько массивов, перечисляя их через запятую.

firstArray.concat(secondArray, thirdArray, fourthArray)

Поиск индекса по элементу

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

var cats = ["Барсик", "Мурзик", "Рыжик"];
console.log(cats.indexOf("Мурзик")); // вернет 1

По сути метод работает наоборот. По индексу мы можем узнать значение элемента, а по элементу его индекс.

var cats = ["Барсик", "Мурзик", "Рыжик"];
var index = cats.indexOf("Мурзик");
console.log(cats[index]); // вернет Мурзик

Если элемента по запрашиваемому индексу нет, то возвращается -1.

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

Превращаем массив в строку

С помощью функции join() можно преобразовать массив в строку.

var cats = ["Барсик", "Мурзик", "Рыжик"];
console.log(cats.join());
// возвращает Барсик,Мурзик,Рыжик

Как видите, элементы массива перечисляются через запятую и без пробелов и кавычек.

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

var cats = ["Барсик", "Мурзик", "Рыжик"];
console.log(cats.join("#"));
// Барсик#Мурзик#Рыжик

Если в массиве находятся нестроковые значения, то JavaScript автоматически сделает их строками.

Реклама

Массив (Array) в JavaScript является глобальным объектом, который используется для создания массивов; которые представляют собой высокоуровневые спископодобные объекты.

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

var fruits = ['Яблоко', 'Банан'];

console.log(fruits.length);
// 2

Доступ к элементу массива по индексу

var first = fruits[0];
// Яблоко

var last = fruits[fruits.length - 1];
// Банан

Итерирование по массиву

fruits.forEach(function(item, index, array) {
  console.log(item, index);
});
// Яблоко 0
// Банан 1

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

var newLength = fruits.push('Апельсин');
// ["Яблоко", "Банан", "Апельсин"]

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

var last = fruits.pop(); // удалим Апельсин (из конца)
// ["Яблоко", "Банан"];

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

var first = fruits.shift(); // удалим Яблоко (из начала)
// ["Банан"];

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

var newLength = fruits.unshift('Клубника') // добавляет в начало
// ["Клубника", "Банан"];

Поиск номера элемента в массиве

fruits.push('Манго');
// ["Клубника", "Банан", "Манго"]

var pos = fruits.indexOf('Банан');
// 1

Удаление элемента с определённым индексом

var removedItem = fruits.splice(pos, 1); // так можно удалить элемент

// ["Клубника", "Манго"]

Удаление нескольких элементов, начиная с определённого индекса

var vegetables = ['Капуста', 'Репа', 'Редиска', 'Морковка'];
console.log(vegetables);
// ["Капуста", "Репа", "Редиска", "Морковка"]

var pos = 1, n = 2;

var removedItems = vegetables.splice(pos, n);
// так можно удалить элементы, n определяет количество элементов для удаления,
// начиная с позиции(pos) и далее в направлении конца массива.

console.log(vegetables);
// ["Капуста", "Морковка"] (исходный массив изменён)

console.log(removedItems);
// ["Репа", "Редиска"]

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

var shallowCopy = fruits.slice(); // так можно создать копию массива
// ["Клубника", "Манго"]

Синтаксис

[element0, element1, ..., elementN]
new Array(element0, element1[, ...[, elementN]])
new Array(arrayLength)

elementN

Массив в JavaScript инициализируется с помощью переданных элементов, за исключением случая, когда в конструктор Array передаётся один аргумент и этот аргумент является числом (см. ниже). Стоит обратить внимание, что этот особый случай применяется только к JavaScript-массивам, создаваемым с помощью конструктора Array, а не к литеральным массивам, создаваемым с использованием скобочного синтаксиса.

arrayLength

Если конструктору Array передаётся единственный аргумент, являющийся целым числом в диапазоне от 0 до 232-1 (включительно), будет возвращён новый пустой JavaScript-массив, длина которого установится в это число (примечание: это означает массив, содержащий arrayLength пустых ячеек, а не ячеек со значениями undefined). Если аргументом будет любое другое число, возникнет исключение RangeError.

Описание

Массивы являются спископодобными объектами, чьи прототипы содержат методы для операций обхода и изменения массива. Ни размер JavaScript-массива, ни типы его элементов не являются фиксированными. Поскольку размер массива может увеличиваться и уменьшаться в любое время, то нет гарантии, что массив окажется плотным. То есть, при работе с массивом может возникнуть ситуация, что элемент массива, к которому вы обратитесь, будет пустым и вернёт undefined. В целом, это удобная характеристика; но если эта особенность массива не желательна в вашем специфическом случае, вы можете рассмотреть возможность использования типизированных массивов.

Некоторые полагают, что вы не должны использовать массив в качестве ассоциативного массива. В любом случае, вместо него вы можете использовать простые объекты, хотя у них есть и свои подводные камни. Смотрите пост Легковесные JavaScript-словари с произвольными ключами(англ.) в качестве примера.

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

Массивы в JavaScript индексируются с нуля: первый элемент массива имеет индекс, равный 0, а индекс последнего элемента равен значению свойства массива length минус 1.

var arr = ['первый элемент', 'второй элемент', 'последний элемент'];
console.log(arr[0]);              // напечатает 'первый элемент'
console.log(arr[1]);              // напечатает 'второй элемент'
console.log(arr[arr.length - 1]); // напечатает 'последний элемент'

Элементы массива являются свойствами, точно такими же, как, например, свойство toString, однако попытка получить элемент массива по имени его свойства приведёт к синтаксической ошибке, поскольку имя свойства не является допустимым именем JavaScript:

console.log(arr.0); // синтаксическая ошибка

Это не особенность массивов или их свойств. В JavaScript к свойствам, начинающимся с цифры, невозможно обратиться посредством точечной нотации; к ним можно обратиться только с помощью скобочной нотации. Например, если у вас есть объект со свойством, названным '3d', вы сможете обратиться к нему только посредством скобочной нотации. Примеры:

var years = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
console.log(years.0);   // синтаксическая ошибка
console.log(years[0]);  // работает как положено

renderer.3d.setTexture(model, 'character.png');     // синтаксическая ошибка
renderer['3d'].setTexture(model, 'character.png');  // работает как положено

Обратите внимание, что во втором примере 3d заключено в кавычки: '3d'. Индексы можно заключать в кавычки (например years['2'] вместо years[2]), но в этом нет необходимости. Значение 2 в выражении years[2] будет неявно приведено к строке движком JavaScript через метод преобразования toString. Именно по этой причине ключи '2' и '02' будут ссылаться на два разных элемента в объекте years и следующий пример выведет true:

console.log(years['2'] != years['02']);

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

var promise = {
  'var'  : 'text',
  'array': [1, 2, 3, 4]
};

console.log(promise['array']);

Взаимосвязь свойства length с числовыми свойствами

Свойство массивов length взаимосвязано с числовыми свойствами. Некоторые встроенные методы массива (например, join, slice, indexOf и т.д.) учитывают значение свойства length при своём вызове. Другие методы (например, push, splice и т.д.) в результате своей работы также обновляют свойство length массива.

var fruits = [];
fruits.push('банан', 'яблоко', 'персик');

console.log(fruits.length); // 3

При установке свойства в массиве, если свойство имеет действительный индекс и этот индекс выходит за пределы текущих границ массива, движок соответствующим образом обновит свойство length:

fruits[5] = 'манго';
console.log(fruits[5]);             // 'манго'
console.log(Object.keys(fruits));   // ['0', '1', '2', '5']
console.log(fruits.length);         // 6

Увеличиваем свойство length

fruits.length = 10;
console.log(Object.keys(fruits));   // ['0', '1', '2', '5']
console.log(fruits.length);         // 10

Однако, уменьшение свойства length приведёт к удалению элементов.

fruits.length = 2;
console.log(Object.keys(fruits)); // ['0', '1']
console.log(fruits.length); // 2

Более подробно эта тема освещена на странице, посвящённой свойству Array.length.

Создание массива с использованием результата сопоставления

Результатом сопоставления регулярного выражения строке является JavaScript-массив. Этот массив имеет свойства и элементы, предоставляющие информацию о сопоставлении. Подобные массивы возвращаются методами RegExp.exec, String.match и String.replace. Чтобы было проще понять, откуда и какие появились свойства и элементы, посмотрите следующий пример и обратитесь к таблице ниже:

// Сопоставляется с одним символом d, за которым следует один
// или более символов b, за которыми следует один символ d
// Запоминаются сопоставившиеся символы b и следующий за ними символ d
// Регистр игнорируется

var myRe = /d(b+)(d)/i;
var myArray = myRe.exec('cdbBdbsbz');

Свойства и элементы, возвращаемые из данного сопоставления, описаны ниже:

Свойство/Элемент	Описание	Пример
input	Свойство только для чтения, отражающее оригинальную строку, с которой сопоставлялось регулярное выражение.	cdbBdbsbz
index	Свойство только для чтения, являющееся индексом (отсчёт начинается с нуля) в строке, с которого началось сопоставление.	1
[0]	Элемент только для чтения, определяющий последние сопоставившиеся символы.	dbBd
[1], ...[n]	Элементы только для чтения, определяющие сопоставившиеся подстроки, заключённые в круглые скобки, если те включены в регулярное выражение. Количество возможных подстрок не ограничено.	[1]: bB [2]: d

Свойства

Array.length

Значение свойства length конструктора массива равно 1.

Array.prototype

Позволяет добавлять свойства ко всем объектам массива.

Методы

Array.from()
Экспериментальная возможность

Создаёт новый экземпляр Array из массивоподобного или итерируемого объекта.

Array.isArray()

Возвращает true, если значение является массивом, иначе возвращает false.

Array.observe()
Экспериментальная возможность

Асинхронно наблюдает за изменениями в массиве, подобно методу Object.observe() для объектов. Метод предоставляет поток изменений в порядке их возникновения.

Array.of()
Экспериментальная возможность

Создаёт новый экземпляр Array из любого количества аргументов, независимо от их количества или типа.

Экземпляры массива

Все экземпляры массива наследуются от Array.prototype. Изменения в объекте прототипа конструктора массива затронет все экземпляры Array.

Свойства

{{page(‘/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype’, ‘Properties’)}}

Методы

Методы изменения

{{page(‘ru/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype’, ‘Mutator_methods’)}}

Методы доступа

{{page(‘ru/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype’, ‘Accessor_methods’)}}

Методы обхода

{{page(‘ru/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype’, ‘Iteration_methods’)}}

Общие методы массива

Иногда хочется применить методы массива к строкам или другим массивоподобным объектам (например, к аргументам (en-US) функции). Делая это, вы трактуете строку как массив символов (другими словами, рассматриваете не-массив в качестве массива). Например, в порядке проверки каждого символа в переменной str на то, что он является буквой (латинского алфавита), вы пишете следующий код:

function isLetter(character) {
  return character >= 'a' && character <= 'z';
}

if (Array.prototype.every.call(str, isLetter)) {
  console.log("Строка '" + str + "' содержит только (латинские) буквы!");
}

Эта запись довольно расточительна и в JavaScript 1.6 введён общий сокращённый вид:

if (Array.every(str, isLetter)) {
  console.log("Строка '" + str + "' содержит только (латинские) буквы!");
}

Общие методы также доступны для объекта String.

В настоящее время они не являются частью стандартов ECMAScript (хотя в ES2015 для достижения поставленной цели можно использовать Array.from()). Следующая прослойка позволяет использовать их во всех браузерах:

// Предполагаем, что дополнения массива уже присутствуют (для них так же можно использовать polyfill'ы)
(function() {
  'use strict';

  var i,
    // Мы могли построить массив методов следующим образом, однако метод
    //  getOwnPropertyNames() нельзя реализовать на JavaScript:
    // Object.getOwnPropertyNames(Array).filter(function(methodName) {
    //   return typeof Array[methodName] === 'function'
    // });
    methods = [
      'join', 'reverse', 'sort', 'push', 'pop', 'shift', 'unshift',
      'splice', 'concat', 'slice', 'indexOf', 'lastIndexOf',
      'forEach', 'map', 'reduce', 'reduceRight', 'filter',
      'some', 'every'
    ],
    methodCount = methods.length,
    assignArrayGeneric = function(methodName) {
      if (!Array[methodName]) {
        var method = Array.prototype[methodName];
        if (typeof method === 'function') {
          Array[methodName] = function() {
            return method.call.apply(method, arguments);
          };
        }
      }
    };

  for (i = 0; i < methodCount; i++) {
    assignArrayGeneric(methods[i]);
  }
}());

Примеры

Пример: создание массива

Следующий пример создаёт массив msgArray с длиной 0, присваивает значения элементам msgArray[0] и msgArray[99], что изменяет длину массива на 100.

var msgArray = [];
msgArray[0] = 'Привет';
msgArray[99] = 'мир';

if (msgArray.length === 100) {
  console.log('Длина равна 100.');
}

Пример: создание двумерного массива

Следующий код создаёт шахматную доску в виде двумерного массива строк. Затем он перемещает пешку путём копирования символа ‘p’ в позиции (6,4) на позицию (4,4). Старая позиция (6,4) затирается пустым местом.

var board = [
  ['R','N','B','Q','K','B','N','R'],
  ['P','P','P','P','P','P','P','P'],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  ['p','p','p','p','p','p','p','p'],
  ['r','n','b','q','k','b','n','r'] ];

console.log(board.join('n') + 'nn');

// Двигаем королевскую пешку вперёд на две клетки
board[4][4] = board[6][4];
board[6][4] = ' ';
console.log(board.join('n'));

Ниже показан вывод:

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , ,
 , , , , , , ,
 , , , , , , ,
 , , , , , , ,
p,p,p,p,p,p,p,p
r,n,b,q,k,b,n,r

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , ,
 , , , , , , ,
 , , , ,p, , ,
 , , , , , , ,
p,p,p,p, ,p,p,p
r,n,b,q,k,b,n,r

Спецификации

Specification
ECMAScript Language Specification # sec-array-objects

Поддержка браузерами

BCD tables only load in the browser

Смотрите также