A.sort();

var s = a.join(", "); // s == "apple, banana, cherry"

Неопределенные элементы переносятся в конец массива.

Для сортировки в каком-либо ином порядке, отличном от алфавитного, можно передать методу sort() в качестве аргумента функцию сравнения. Эта функция устанавливает, какой из двух ее аргументов должен присутствовать раньше в отсортированном списке. Если первый аргумент должен предшествовать второму, функция сравнения возвращает отрицательное число. Если первый аргумент в отсортированном массиве должен следовать за вторым, то функция возвращает число, большее нуля. А если два значения эквивалентны (т. е. порядок их расположения не важен), функция сравнения возвращает 0. Поэтому, например, для сортировки элемента в числовом порядке, а не в алфавитном, можно сделать следующее:

var a = [33, 4, 1111, 222];

a.sort();// Алфавитный порядок: 1111, 222, 33, 4

a.sort(function(a,b) { //Числовой порядок: 4, 33, 222, 1111

return a-b; //Возвращает значение < 0, 0, или > 0

});// в зависимости от порядка сортировки a и b

Обратите внимание, насколько удобно использовать в этом фрагменте функциональный литерал. Функция сравнения вызывается только один раз, поэтому нет необходимости давать ей имя.

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

à Метод concat()

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

var a = [1,2,3];

a.concat(4, 5) // Возвращает [1,2,3,4,5]

a.concat([4,5]); // Возвращает [1,2,3,4,5]

a.concat([4,5],[6,7]) // Возвращает [1,2,3,4,5,6,7]

a.concat(4, [5,[6,7]]) // Возвращает [1,2,3,4,5,[6,7]]

à Метод slice()

Метод Array.slice() возвращает фрагмент, или подмассив, указанного массива.

Два аргумента метода определяют начало и конец возвращаемого фрагмента.

Возвращаемый массив содержит элемент, номер которого указан в качестве первого аргумента, плюс все последующие элементы, вплоть до (но не включая) элемента, номер которого указан во втором аргументе. Если указан только один аргумент, возвращаемый массив содержит все элементы от начальной позиции до конца массива. Если какой_либо из аргументов отрицателен, он задает номер элемента массива относительно конца массива. Так, аргумент, равный –1, задает последний элемент массива, а аргумент, равный –3, – третий элемент массива с конца. Вот несколько примеров:

var a = [1,2,3,4,5];

a.slice(0,3); // Возвращает [1,2,3]

a.slice(3); // Возвращает [4,5]

a.slice(1,-1); // Возвращает [2,3,4]

a.slice(-3,-2); // Возвращает [3]

à Метод splice()

Метод Array.splice() – это универсальный метод для вставки или удаления элементов массива. Он изменяет массив на месте, а не возвращает новый массив, как это делают методы slice() и concat(). Обратите внимание: splice() и slice() имеют очень похожие имена, но выполняют разные операции.

Метод splice() может удалять элементы из массива, вставлять новые элементы в массив или выполнять обе операции одновременно. Элементы массива при не обходимости смещаются, чтобы после вставки или удаления образовывалась непрерывная последовательность. Первый аргумент splice() задает позицию в массиве, с которой начинается вставка и/или удаление. Второй аргумент задает количество элементов, которые должны быть удалены (вырезаны) из массива. Если второй аргумент опущен, удаляются все элементы массива от начального до конца массива. Метод splice() возвращает массив удаленных элементов или (если ни один из элементов не был удален) пустой массив. Например:

var a = [1,2,3,4,5,6,7,8];

a.splice(4); //Возвращает [5,6,7,8]; a равно [1,2,3,4]

a.splice(1,2); //Возвращает [2,3]; a равно [1,4]

a.splice(1,1); //Возвращает [4]; a равно [1]

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

var a = [1,2,3,4,5];

a.splice(2,0,'a','b'); //Возвращает []; a равно [1,2,'a','b',3,4,5]

a.splice(2,2,[1,2],3); //Возвращает ['a','b']; a равно [1,2,[1,2],3,3,4,5]

Обратите внимание, что, в отличие от concat(), метод splice() не разбивает на отдельные элементы вставляемые аргументы-массивы. То есть если методу передается массив для вставки, он вставляет сам массив, а не элементы этого массива.

à Методы push() и pop()

Методы push() и pop() позволяют работать с массивами как со стеками. Метод push() добавляет один или несколько новых элементов в конец массива и возвращает его новую длину. Метод pop() выполняет обратную операцию – удаляет последний элемент массива, уменьшает длину массива и возвращает удаленное им значение. Обратите внимание: оба эти метода изменяют массив на месте, а не создают его модифицированную копию. Комбинация push() и pop() позволяет в JavaScript с помощью массива реализовать стек с дисциплиной обслуживания «первым вошел – последним вышел». Например:

var stack = [];// стек: []

stack.push(1,2); //стек: [1,2] Возвращает 2

stack.pop(); //стек: [1] Возвращает 2

stack.push(3); //стек: [1,3] Возвращает 2

stack.pop();// стек: [1] Возвращает 3

stack.push([4,5]); //стек: [1,[4,5]] Возвращает 2

stack.pop()// стек: [1] Возвращает [4,5]

stack.pop();// стек: [] Возвращает 1

à Методы unshift() и shift()

Методы unshift() и shift() ведут себя во многом так же, как push() и pop(), за исключением того, что они вставляют и удаляют элементы в начале массива, а не в его конце.

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

var a = []; // a:[]

a.unshift(1); // a:[1] Возвращает: 1

a.unshift(22); // a:[22,1] Возвращает: 2

a.shift(); // a:[1] Возвращает: 22

a.unshift(3,[4,5]); // a:[3,[4,5],1] Возвращает: 3

a.shift(); // a:[[4,5],1] Возвращает: 3

a.shift(); // a:[1] Возвращает: [4,5]

a.shift(); // a:[] Возвращает: 1

Обратите внимание на поведение метода unshift() при вызове с несколькими аргументами. Аргументы вставляются не по одному, а все сразу (как в случае с методом splice()). Это значит, что в результирующем массиве они будут следовать в том же порядке, в котором были указаны в списке аргументов.

à Методы toString() и toLocaleString()

У массива, как и у любого другого объекта в JavaScript, имеется метод toString(). Для массива этот метод преобразует каждый из его элементов в строку (вызывая в случае необходимости методы toString() для элементов массива) и выводит список этих строк через запятую. Отметьте, что результат не включает квадратных скобок или каких-либо других разделителей вокруг значений массива. Например:

[1,2,3].toString() // Получается '1,2,3'

["a", "b", "c"].toString() // Получается 'a,b,c'

[1, [2,'c']].toString() // Получается '1,2,c'

Обратите внимание: toString() возвращает ту же строку, что и метод join() при вызове его без аргументов.

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