Предыдущие слова
Массив - это набор значений, расположенных по порядку, и по сравнению с именами свойств объекта не в порядке. По сути, массивы используют числа в качестве клавиш поиска, в то время как объекты имеют определенные пользовательские имена атрибутов. JavaScript не имеет реальных ассоциативных массивов, но объекты могут использоваться для реализации функции ассоциативного
Array () - это просто особый тип объекта (), то есть экземпляр Array () - это в основном экземпляр объекта () с некоторой дополнительной функциональностью. Массивы могут содержать любой тип значений, которые могут быть обновлены или удалены в любое время, а размер массива динамически скорректирован.
В дополнение к объектам тип массива, вероятно, является наиболее часто используемым типом в JavaScript. Более того, массивы в JavaScript сильно отличаются от того, что на большинстве других языков. Эта статья представит тип массива в JavaScript
Создать массив
Есть два способа создания массива: использование буквального синтаксиса и использования конструктора Array ()
【Буквальный】
Использование литералов массива - самый простой способ создать массив. Отдельные элементы массива с запятыми в квадратных скобках
var пусто = []; // массив без элементов var primes = [2,3,5,7,11]; // массив с 5 значениями
Хотя массивы JavaScript заказаны списки данных, а также массивы на других языках, в отличие от других языков, каждый элемент массивов JavaScript может содержать любой тип данных
var misc = [1.1, true, "a"]; // 3 элементы разных типов
Значения в литералах массива не должны быть постоянными, они могут быть любым выражением
var base = 1024; var table = [base, base+1, base+2, base+3];
Он может содержать объектные литералы или другие литералы массива
var b = [[1, {x: 1, y: 2}], [2, {x: 3, y: 4}]];Если элементы массива все еще являются массивами, сформируется многомерный массив
var a = [[1, 2], [3, 4]];
[Примечание] При использовании численных буквальных обозначений конструктор массива не будет вызван
【Конструктор】
Есть три способа вызвать конструкторы
【1】 Нет параметров, создайте пустой массив
// Этот метод создает пустой массив без каких -либо элементов, что эквивалентно прямому количеству массива [] var a = new Array ();
【2】 Существует числовой параметр, который используется для указания длины массива
var a = new Array (10); console.log (a); // [] console.log (a [0], a.length); // не определено 10
[Примечание] Если есть другой тип параметра, будет создан массив, содержащий только те из этого значения.
var a = new Array ('10 '); console.log (a); // [' 10 '] console.log (a [0], a.length); // 10 1【3】 Когда есть несколько параметров, параметры представлены в виде конкретных элементов массива
var a = new Array (1,2,3); console.log (a); // [1,2,3] консоль.log (a [0], a [1], a [2]); // 1 2 3
При использовании конструктора Array () новый оператор может быть опущен
var a1 = array (); var a2 = массив (10); var a3 = массив (1,2,3); консоль.log (a1, a2, a3); // [] [] [1,2,3]
Массив природа
Массивы - это набор значений, расположенных по порядку. По сути, массивы являются специальными объектами.
typeof [1, 2, 3] // "Объект"
Особенность массива отражается в том, что его ключевые имена представляют собой набор целых чисел (0, 1, 2…), расположенных по порядку. Поскольку ключевые имена участников массива исправлены, массив не нужно указывать имя ключа для каждого элемента, но каждый член объекта должен указывать имя ключа.
var arr = ['a', 'b', 'c']; console.log (object.keys (arr)); // ["0", "1", "2"] var obj = {name1: 'a', name2: 'b', name3: 'c'};Массивы являются специальными формами объектов. Доступ к элементам массива с квадратными кронштейнами похож на доступ к свойствам объектов с квадратными скобками.
Язык JavaScript предусматривает, что ключевые имена объектов являются строками, поэтому ключевые имена массивов на самом деле являются строками. Причина, по которой его можно прочитать с помощью числовых значений, заключается в том, что имена ключей без строки будут преобразованы в строки, а затем используются в качестве имен атрибутов
o = {}; // Создать обычный объект o [1] = "One"; // индексируйте его с помощью целого числа // имени цифрового ключа автоматически преобразуется в строку var arr = ['a', 'b', 'c']; arr ['0'] // 'a'Arr [0] //' a 'Тем не менее, необходимо различить имена атрибутов индекса массива и объекта: все индексы являются именами атрибутов, но только имена атрибутов целого числа между 0 ~ 232-2 (4294967294) являются индексами
var a = []; // индекс a ['1000'] = 'abc'; a [1000] // 'abc' // index a [1.00] = 6; a [1] // 6
[Примечание] Отдельные значения не могут использоваться в качестве идентификаторов. Поэтому члены массива могут быть выражены только в квадратных скобках
var arr = [1, 2, 3]; arr [0]; // 1Arr.0; // Синтаксиртор
Массив может быть проиндексирован с использованием отрицательных или неинтемерных чисел. Однако, поскольку он не находится в пределах диапазона 0 ~ 2 к мощности 32 -2, это только имя атрибута массива, а не индекс массива. Очевидной особенностью является то, что он не меняет длину массива
var a = [1,2,3]; // Имя атрибута a [-1.23] = true; console.log (a.length); // 3 // Индекс a [10] = 5; console.log (a.length); // 11 // Имя атрибута a ['abc'] = 'testing'; console.log (a.length); // 11
Редкие массивы
Разреженный массив - это массив, содержащий прерывистые индексы, начиная с 0.
【1】 Самый прямой способ сделать разреженные массивы - использовать оператор удаления
var a = [1,2,3,4,5]; удалить a [1]; console.log (a [1]); // undefinedConsole.log (1 в а); // ложь
【2】 Значения элементов могут быть пропущены между запятыми массивами, и разреженные массивы могут быть созданы путем пропущения значений элементов.
var a = [1,, 3,4,5]; console.log (a [1]); // undefinedConsole.log (1 в а); // ложь
[Примечание] Существует разница между значением пропущенного элемента и значением элемента, значение которого не определен.
var a = [1,, 3,4,5]; console.log (a [1]); // undefinedconsole.log (1 в a); // falsevar a = [1, не определено, 3,4,5]; console.log (a [1]); // undefinedConsole.log (1 в);
Если вы используете запятые в конце массива, между браузерами существуют различия. Запятая игнорируется стандартным браузером, в то время как Browser IE8 добавляет неопределенное значение в конце
// Стандартный выход браузера [1,2], в то время как выход IE8-браузер [1,2, неопределенная] var a = [1,2,]; console.log (a); // Стандартный выходной сигнал 2, в то время как выход IE8-браузер 3var a = [,,]; console.log (a.length);
Массивы, которые достаточно скудны, обычно медленнее в реализации, чем плотные массивы, и имеют более высокое использование памяти, и время для поиска элементов в таком массиве, как и время, чтобы искать свойства обычного объекта
Длина массива
Каждый массив имеет атрибут длины, который является этим атрибутом, который отличает его от обычных объектов JavaScript. Для плотных (то есть не-SPARSE) массивов длины значение атрибута представляет количество элементов в массиве, а его значение больше, чем самый большой индекс в массиве.
[] .length // => 0: массив не имеет элементов ['a', 'b', 'c']. Длина // => 3: максимальный индекс составляет 2, а длина 3 - 3
Когда массив является редким массивом, значение атрибута длины больше, чем количество элементов. Точно так же его значение на 1 больше, чем самый большой индекс в массиве
[,,].длина; //3(Array(10)).length;//10var a = [1,2,3]; console.log (a.length); // 3delete a [1]; console.log (a.length); // 3
Специфика массивов в основном отражается в том факте, что длина массива может быть динамически отрегулирована:
【1】 Если вы назначаете значение элементу массива, а индекс I больше или равна длине существующего массива, значение атрибута длины будет установлено на i+1
var arr = ['a', 'b']; arr.length // 2Arr [2] = 'c'; arr.length // 3arr [9] = 'd'; arr.length // 10Arr [1000] = 'e'; arr.length // 1001
【2】 При настройке атрибута длины на неотрицательное целое число меньше, чем длина текущего, элементы со значением индекса массива текущего
a = [1,2,3,4,5]; // из массива 5 элементов A.Length = 3; // теперь a IS [1,2,3] A.Length = 0; // Удалить все элементы. a IS [] A.Length = 5; // длина 5, но нет элементов, как новые
Массив (5)
[Примечание] Эффективный способ очистить массив - установить свойство длины на 0
var arr = ['a', 'b', 'c']; arr.length = 0; arr // []
【3】 Установите значение атрибута длины массива, чтобы быть больше его текущей длины. На самом деле это не добавляет новые элементы в массив, это просто создает пустую область в конце массива
var a = ['a']; a.length = 3; console.log (a [1]); // undefinedconsole.log (1 в a); // ложь
Если длина установлена на незаконное значение (то есть значение за пределами диапазона 0--232-2), JavaScript сообщит об ошибке
// Установить отрицательное значение []. Length = -1 // DrangeError: неверная длина массива // Количество элементов массива больше или равно 2 к мощности 32 [].
Поскольку массив по сути является объектом, вы можете добавить атрибуты в массив, но это не влияет на значение атрибута длины
var a = []; a ['p'] = 'abc'; console.log (a.length); // 0a [2.1] = 'abc'; console.log (a.length); // 0
Массив
Наиболее распространенный способ пройти через элементы массива, используя для петли
var a = [1, 2, 3]; for (var i = 0; i <a.length; i ++) {console.log (a [i]);}Конечно, вы также можете использовать цикл WINT
var a = [1, 2, 3]; var i = 0; while (i <a.length) {console.log (a [i]); i ++;} var l = a.length; while (l--) {console.log (a [l]);}Но если массив является редким массивом, используйте петлю, и вам нужно добавить некоторые условия
// пропустить несуществующий элемент var a = [1 ,,, 2]; for (var i = 0; i <a.length; i ++) {if (! (I in a)) Продолжить; console.log (a [i]);}Вы также можете использовать для/в циклах для обработки разреженных массивов. Цикл присваивает перечисляемое имя атрибута (включая индекс массива) переменной цикла за раз. Несуществующий индекс не будет проходить к
var a = [1 ,,, 2]; for (var i in a) {console.log (a [i]);}Потому что цикл для/в цикле может перечислять унаследованные имена атрибутов, такие как методы, добавленные в массив. Прототип. По этой причине для/в циклах не следует использовать на массивах, если для фильтрации нежелательных свойств не используются дополнительные методы обнаружения.
var a = [1 ,,, 2]; ab = 'b'; for (var i in a) {console.log (a [i]); // 1 2 'b'} // пропустить ivar a = [1 ,,,, 2]; ab = 'b'; для (var i in a) {if (string.floor (math.abs (iman)))! Продолжить; console.log (a [i]); // 1 2}Спецификация JavaScript позволяет/в петлях проходить свойства объекта в разных порядках. Обычно реализация массива в порядке массива находится в порядке возрастания, но нельзя гарантированно будет такова. В частности, если у массива есть как атрибуты объекта, так и элементы массива, возвращаемые имена атрибутов, вероятно, находятся в порядке, которые они были созданы, а не в порядке численного размера. Если алгоритм зависит от порядка обхода, лучше всего не использовать для/in, но использовать регулярные для петли
Класс массив
Объекты с атрибутами длины и соответствующими неотрицательные целочисленные атрибуты называются массивными объектами
// Демонстрация массива классов var a = {}; var i = 0; while (i <10) {a [i] = i*i; i ++;} a.length = i; var total = 0; for (var j = 0; j <a.length; j ++) {total+= a [j];};Есть три общих объекта массива классов:
【1】 Аргументы объект
// arguments object function args () {return arguments} var arraylize = args ('a', 'b'); массив [0] // 'a'arraylike.length // 2Arraylike экземпляр массива // false【2】 Объект, возвращаемый методом DOM (например, Document.GetElementsBytagName () Метод)
// элемент dom var var alts = document.getElementsbytagname ('h3'); elts.length // 3elts ancementof array // false【3】 строка
// string 'abc' [1] // 'b''abc'.length // 3'abc' экземпляр массива // false
[Примечание] Строки являются неизменными значениями, поэтому при рассмотрении как массивов они только для чтения. Например, push (), sort (), reverse (), splice () и другие методы массива изменят массив. Они недействительны на строке и сообщат об ошибке
var str = 'abc'; array.prototype.foreach.call (str, function (chr) {console.log (chr); // abc}); array.prototype.splice.call (str, 1); console.log (str); // typeError: не удается удалить свойство 2 'из [объект -строки]Метод среза массива превращает объект класса массива в настоящий массив
var arr = array.prototype.slice.call (массив);
Методы массива JavaScript специально определены как общие, поэтому они работают правильно не только на реальных массивах, но и на объектах классов. В Ecmascript5 все методы массива являются общими. В Ecmascript3 все методы, кроме ToString () и tolocalestring (), также распространены
var a = {'0': 'a', '1': 'b', '2': 'c', длина: 3}; array.prototype.join.call (a, '+'); // 'a+b+c'array.p rototype.slice.call (a, 0); // ['a', 'b', 'c'] array.prototype.map.call (a, function (x) {return x.touppercase ();}); // ['a', 'b', 'c']