Индексные массивы

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

Самым простым способом добавления элемента в индексный массив является использование оператора доступа к массиву ( [] ). Чтобы задать значение для элемента индексного массива, используйте имя объекта Array или Vector и индекс в левой части инструкции присвоения.

songTitles[5] = "Happy Birthday";

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

Объект Array позволяет создавать элементы в любой позиции индекса. А в объекте Vector, напротив, значение можно присваивать только существующему индекса или следующему за ним. Следующий доступный индекс соответствует свойству length объекта Vector. Самым безопасным способом добавления нового элемента в объект Vector является использование кода, подобного следующему:

myVector[myVector.length] = valueToAdd;

Три метода классов Array и Vector: push() , unshift() и splice() — позволяют вставлять элементы в индексный массив. Метод push() добавляет один или несколько элементов в конец массива. Иными словами, у последнего элемента, вставленного в массив с помощью метода push() , будет наибольший индекс. Метод unshift() вставляет один или более элементов в начало массива, при этом первый индекс всегда равен 0. Метод splice() вставляет любое число элементов по заданному индексу в массиве.

В следующем примере показаны все три метода. Массив с именем planets создается для хранения названий планет в порядке удаленности от Солнца. Сначала вызывается метод push() и создается первый элемент Mars . Затем вызывается метод unshift() и вставляет в начало массива элемент Mercury . Наконец, вызывается метод splice() и вставляет элементы Venus и Earth после Mercury и перед Mars . Первый аргумент, передаваемый методу splice() , — это целое число 1. Он указывает, что вставку необходимо производить после индекса 1. Второй аргумент, передаваемый методу splice() , — это целое число 0. Он указывает, что никакие элементы удалять не нужно. Наконец, третий и четвертый аргументы — Venus и Earth , передаваемые методу splice() , — это вставляемые элементы.

var planets:Array = new Array(); 
planets.push("Mars"); // array contents: Mars 
planets.unshift("Mercury"); // array contents: Mercury,Mars 
planets.splice(1, 0, "Venus", "Earth"); 
trace(planets); // array contents: Mercury,Venus,Earth,Mars

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

Самый простой способ получить значение элемента индексного массива — использовать оператор доступа к массиву ( [] ). Чтобы получить значение для элемента индексного массива, используйте имя объекта Array или Vector и индекс в правой части инструкции присвоения.

var myFavoriteSong:String = songTitles[3];

Также можно попытаться получить значение из объекта Array или Vector, используя позицию индекса, в которой нет элемента. В этом случае объект Array возвращает значение undefined, а объект Vector выдает исключение RangeError.

Три метода классов Array и Vector: pop() , shift() и splice() — позволяют удалять элементы. Метод pop() удаляет элемент из конца массива. Иначе говоря, он удаляет элемент с наибольшим индексом. Метод shift() удаляет элемент из начала массива, т. е. каждый раз удаляется элемент с индексом 0. Метод splice() , который также может использоваться для вставки элементов, удаляет произвольное число элементов, начиная с индекса, заданного первым из передаваемых методу аргументов.

В примере ниже показано использование всех трех методов для удаления элементов из экземпляра Array. Массив Array с именем oceans создается для хранения названий океанов. Некоторые из названий в массиве — это озера, а не океаны, и их нужно удалить.

Во-первых, используем метод splice() для удаления элементов Aral и Superior и вставки элементов Atlantic и Indian . Первый аргумент, передаваемый методу splice() , — это целое число 2. Он указывает, что операцию необходимо начинать с третьего элемента в списке, т. е. элемента с индексом 2. Второй аргумент, 2, указывает, что нужно удалить два элемента. Остальные аргументы: Atlantic и Indian — это значения, которые нужно вставить после индекса 2.

Во-вторых, используем метод pop() для удаления последнего элемента массива — Huron . B-третьих, используем метод shift() для удаления первого элемента массива — Victoria .

var oceans:Array = ["Victoria", "Pacific", "Aral", "Superior", "Indian", "Huron"]; 
oceans.splice(2, 2, "Arctic", "Atlantic"); // replaces Aral and Superior 
oceans.pop(); // removes Huron 
oceans.shift(); // removes Victoria 
trace(oceans);// output: Pacific,Arctic,Atlantic,Indian

Методы pop() и shift() возвращают элемент, который был удален. Для объекта Array, типом данных возвращаемого значения является Object, так как массивы могут содержать данные любого типа. Для объекта Vector типом данных возвращаемого значения является его базовый класс. Метод splice() возвращает объект Array или Vector с удаленными значениями. Можно изменить пример с массивом oceans так, чтобы вызов метода splice() назначал возвращенный объект Array новой переменной Array, как показано ниже:

var lakes:Array = oceans.splice(2, 2, "Arctic", "Atlantic"); 
trace(lakes); // output: Aral,Superior

Вам может встретиться код, применяющий оператор delete к элементу объекта Array. Оператор delete задает элементу объекта Array значение undefined , но не удаляет его из массива. Например, в приведенном ниже коде оператор delete применяется к третьему элементу массива oceans , но длина объекта Array по-прежнему остается равной 5.

var oceans:Array = ["Arctic", "Pacific", "Victoria", "Indian", "Atlantic"]; 
delete oceans[2]; 
trace(oceans);// output: Arctic,Pacific,,Indian,Atlantic 
trace(oceans[2]); // output: undefined 
trace(oceans.length); // output: 5

Можно усечь экземпляр Array или Vector с помощью свойства length . Если задать свойству length индексного массива значение меньше текущей длины, массив будет усечен, и все элементы с индексами больше нового значения length минус 1 будут удалены. Например, если массив oceans отсортировать так, чтобы все нужные значения были в начале массива, то с помощью свойства length можно удалить записи в конце массива, как показано ниже:

var oceans:Array = ["Arctic", "Pacific", "Victoria", "Aral", "Superior"]; 
oceans.length = 2; 
trace(oceans); // output: Arctic,Pacific

Существует три метода: reverse() , sort() и sortOn() , — позволяющих изменить порядок элементов в индексном массиве путем сортировки или задания обратного порядка. Все они изменяют имеющийся массив. В следующей таблице приводятся общие сведения об этих методах и их поведении для объектов Array и Vector.

var oceans:Array = ["Arctic", "Atlantic", "Indian", "Pacific"]; 
oceans.reverse(); 
trace(oceans); // output: Pacific,Indian,Atlantic,Arctic

var poets:Array = ["Blake", "cummings", "Angelou", "Dante"]; 
poets.sort(); // default sort 
trace(poets); // output: Angelou,Blake,Dante,cummings 
 
poets.sort(Array.CASEINSENSITIVE); 
trace(poets); // output: Angelou,Blake,cummings,Dante 
 
poets.sort(Array.DESCENDING); 
trace(poets); // output: cummings,Dante,Blake,Angelou 
 
poets.sort(Array.DESCENDING | Array.CASEINSENSITIVE); // use two options 
trace(poets); // output: Dante,cummings,Blake,Angelou

var names:Array = new Array("John Q. Smith", "Jane Doe", "Mike Jones"); 
function orderLastName(a, b):int 
{ 
    var lastName:RegExp = /\b\S+$/; 
    var name1 = a.match(lastName); 
    var name2 = b.match(lastName); 
    if (name1 < name2) 
    { 
        return -1; 
    } 
    else if (name1 > name2) 
    { 
        return 1; 
    } 
    else 
    { 
        return 0; 
    } 
} 
trace(names); // output: John Q. Smith,Jane Doe,Mike Jones 
names.sort(orderLastName); 
trace(names); // output: Jane Doe,Mike Jones,John Q. Smith

var poets:Array = new Array(); 
poets.push({name:"Angelou", born:"1928"}); 
poets.push({name:"Blake", born:"1757"}); 
poets.push({name:"cummings", born:"1894"}); 
poets.push({name:"Dante", born:"1265"}); 
poets.push({name:"Wang", born:"701"});

poets.sortOn("born", Array.NUMERIC); 
for (var i:int = 0; i < poets.length; ++i) 
{ 
    trace(poets[i].name, poets[i].born); 
} 
/* output: 
Wang 701 
Dante 1265 
Blake 1757 
cummings 1894 
Angelou 1928 
*/

var indices:Array; 
indices = poets.sortOn("born", Array.NUMERIC | Array.RETURNINDEXEDARRAY); 
for (var i:int = 0; i < indices.length; ++i) 
{ 
    var index:int = indices[i]; 
    trace(poets[index].name, poets[index].born); 
} 
/* output: 
Wang 701 
Dante 1265 
Blake 1757 
cummings 1894 
Angelou 1928 
*/

Четыре метода классов Array и Vector: concat() , join() , slice() , toString() — отправляют запросы в массив, но не изменяют его. Методы concat() и slice() возвращают новые массивы, а методы join() и toString() возвращают строки. Метод concat() принимает в качестве аргументов новый массив или список элементов и совмещает его с предыдущим массивом для создания нового. У метода slice() есть два параметра с говорящими названиями startIndex и endIndex . Этот метод возвращает новый массив, содержащий копии элементов, «вырезанных» из существующего массива. Вырезаемый фрагмент начинается с элемента с индексом startIndex и заканчивается перед элементом endIndex . Еще раз отметим, что элемент с индексом endIndex не включается в возвращаемые значения.

В следующем примере методы concat() и slice() используются для создания новых массивов с помощью элементов других массивов:

var array1:Array = ["alpha", "beta"]; 
var array2:Array = array1.concat("gamma", "delta"); 
trace(array2); // output: alpha,beta,gamma,delta 
 
var array3:Array = array1.concat(array2); 
trace(array3); // output: alpha,beta,alpha,beta,gamma,delta 
 
var array4:Array = array3.slice(2,5); 
trace(array4); // output: alpha,beta,gamma

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

В примере ниже создается объект Array с именем rivers , затем вызываются методы join() и toString() для возвращения значений массива в виде строки. Метод toString() возвращает значения, разделенные запятой ( riverCSV ), в то время как метод join() возвращает значения, разделенные знаком + .

var rivers:Array = ["Nile", "Amazon", "Yangtze", "Mississippi"]; 
var riverCSV:String = rivers.toString(); 
trace(riverCSV); // output: Nile,Amazon,Yangtze,Mississippi 
var riverPSV:String = rivers.join("+"); 
trace(riverPSV); // output: Nile+Amazon+Yangtze+Mississippi

При работе с методом join() необходимо помнить, что он всегда возвращает вложенные экземпляры Array или Vector со значениями, разделенными запятой, вне зависимости от того, какой разделительный знак вы задали для основных элементов массива. Это проиллюстрировано в примере:

var nested:Array = ["b","c","d"]; 
var letters:Array = ["a",nested,"e"];  
var joined:String = letters.join("+"); 
trace(joined); // output: a+b,c,d+e