JavaScript - 索引集合

Array对象

创建数组

var arr = new Array(element0, element1, ..., elementN);
var arr = Array(element0, element1, ..., elementN);
var arr = [element0, element1, ..., elementN];

var arr = new Array(arrayLength);
var arr = Array(arrayLength);
// This has exactly the same effect
var arr = [];
arr.length = arrayLength;

var obj = {};
// ...
obj.prop = [element0, element1, ..., elementN];
// OR
var obj = {prop: [element0, element1, ...., elementN]};

var arr = [42];      // Creates an array with only one element:
                     // the number 42.
var arr = Array(42); // Creates an array with no elements
                     // and arr.length set to 42; this is
                     // equivalent to:
var arr = [];
arr.length = 42;

var arr = Array(9.3);  // RangeError: Invalid array length

填充数组

var emp = [];
emp[0] = 'Casey Jones';
emp[1] = 'Phil Lesh';
emp[2] = 'August West';

var myArray = new Array('Hello', myVar, 3.14159);
var myArray = ['Mango', 'Apple', 'Orange'];

引用数组

var arr = ['one', 'two', 'three'];
arr[2];  // three
arr['length'];  // 3

了解数组长度

var cats = [];
cats[30] = ['Dusty'];
console.log(cats.length); // 31

var cats = ['Dusty', 'Misty', 'Twiggy'];
console.log(cats.length); // 3
cats.length = 2;
console.log(cats); // logs "Dusty, Misty" - Twiggy has been removed
cats.length = 0;
console.log(cats); // logs []; the cats array is empty
cats.length = 3;
console.log(cats); // logs [ <3 empty items> ]

遍历数组

var colors = ['red', 'green', 'blue'];
for (var i = 0; i < colors.length; i++) {
  console.log(colors[i]);
}

var divs = document.getElementsByTagName('div');
for (var i = 0, div; div = divs[i]; i++) {
  /* Process div in some way */
}

var colors = ['red', 'green', 'blue'];
colors.forEach(function(color) {
  console.log(color);
});
// red
// green
// blue

var colors = ['red', 'green', 'blue'];
colors.forEach(color => console.log(color)); 
// red
// green
// blue

var array = ['first', 'second', , 'fourth'];

array.forEach(function(element) {
  console.log(element);
});
// first
// second
// fourth

if (array[2] === undefined) { 
  console.log('array[2] is undefined'); // true
} 

array = ['first', 'second', undefined, 'fourth'];

array.forEach(function(element) {
  console.log(element);
});
// first
// second
// undefined
// fourth

数组对象的方法

concat() 连接两个或多个数组，之后返回连接后的新数组。

var myArray = new Array('1', '2', '3');
myArray = myArray.concat('a', 'b', 'c'); 
// myArray is now ["1", "2", "3", "a", "b", "c"]

join(delimiter=',') 以分隔符指定的符号，连接数组中的元素，成为字符串。

var myArray = new Array('Wind', 'Rain', 'Fire');
var list = myArray.join(' - '); // list is "Wind - Rain - Fire"

push() 向数组的末尾，添加元素，并且返回添加完成之后的数组长度。

var myArray = new Array('1', '2');
myArray.push('3'); // myArray is now ["1", "2", "3"]

pop() 移除数组的最后一个元素，并且返回该被移除的元素。

var myArray = new Array('1', '2', '3');
var last = myArray.pop(); 
// myArray is now ["1", "2"], last = "3"

shift() 移除数组的第一个元素，并且返回该被移除的元素。

var myArray = new Array('1', '2', '3');
var first = myArray.shift(); 
// myArray is now ["2", "3"], first is "1"

unshift() 向数组的首部添加元素，并且返回添加完成之后数组的长度。

var myArray = new Array('1', '2', '3');
myArray.unshift('4', '5'); 
// myArray becomes ["4", "5", "1", "2", "3"]

slice(start_index, end_index) 提取数组的片段，以新数组的形式返回。

var myArray = new Array('a', 'b', 'c', 'd', 'e');
myArray = myArray.slice(1, 4); // starts at index 1 and extracts all elements
                               // until index 3, returning [ "b", "c", "d"]

splice(index, count_to_remove, addElement1, addElement2...) 从数组中移除元素，并且替换它们(可选)，返回值为被移除的元素。

var myArray = new Array('1', '2', '3', '4', '5');
myArray.splice(1, 3, 'a', 'b', 'c', 'd'); 
// myArray is now ["1", "a", "b", "c", "d", "5"]
// This code started at index one (or where the "2" was), 
// removed 3 elements there, and then inserted all consecutive
// elements in its place.

reverse() 反转数组元素次序。

var myArray = new Array('1', '2', '3');
myArray.reverse(); 
// transposes the array so that myArray = ["3", "2", "1"]

sort() 排序数组，返回对该数组的引用；可以传入一个回调函数，来指定排序的方式。

var myArray = new Array('Wind', 'Rain', 'Fire');
myArray.sort(); 
// sorts the array so that myArray = ["Fire", "Rain", "Wind"]

var sortFn = function(a, b) {
  if (a[a.length - 1] < b[b.length - 1]) return -1;
  if (a[a.length - 1] > b[b.length - 1]) return 1;
  if (a[a.length - 1] == b[b.length - 1]) return 0;
}
myArray.sort(sortFn); 
// sorts the array so that myArray = ["Wind","Fire","Rain"]

indexOf(searchElement[, fromIndex]) 在数组中从首至尾搜索元素，返回第一处匹配的索引。

var a = ['a', 'b', 'a', 'b', 'a'];
console.log(a.indexOf('b')); // logs 1
// Now try again, starting from after the last match
console.log(a.indexOf('b', 2)); // logs 3
console.log(a.indexOf('z')); // logs -1, because 'z' was not found

lastIndexOf(searchElement[, fromIndex]) 在数组中从尾至首搜索元素，返回第一处匹配的索引。

var a = ['a', 'b', 'c', 'd', 'a', 'b'];
console.log(a.lastIndexOf('b')); // logs 5
// Now try again, starting from before the last match
console.log(a.lastIndexOf('b', 4)); // logs 1
console.log(a.lastIndexOf('z')); // logs -1

forEach(callBack[, thisObject]) 在数组中每个元素上执行回调函数，返回undefined。

var a = ['a', 'b', 'c'];
a.forEach(function(element) { console.log(element); }); 
// logs each item in turn

map(callBack[, thisObject]) 回调函数处理每个数组元素，之后以数组形式返回回调函数的执行结果。

var a1 = ['a', 'b', 'c'];
var a2 = a1.map(function(item) { return item.toUpperCase(); });
console.log(a2); // logs ['A', 'B', 'C']

filter(callBack[, thisObject]) 过滤数组，返回新数组，该数组元素为回调函数处理每一个元素的结果为真的元素。

var a1 = ['a', 10, 'b', 20, 'c', 30];
var a2 = a1.filter(function(item) { return typeof item === 'number'; });
console.log(a2); // logs [10, 20, 30]

every(callBack[, thisObject]) 返回true，若回调函数处理每个数组元素的返回结果为true，否则返回false。

function isNumber(value) {
  return typeof value === 'number';
}
var a1 = [1, 2, 3];
console.log(a1.every(isNumber)); // logs true
var a2 = [1, '2', 3];
console.log(a2.every(isNumber)); // logs false

some(callBack[, thisObject]) 返回true，若回调函数处理每个数组元素的返回结果有一个为true，若回调函数的返回结果都为false，侧返回false。

function isNumber(value) {
  return typeof value === 'number';
}
var a1 = [1, 2, 3];
console.log(a1.some(isNumber)); // logs true
var a2 = [1, '2', 3];
console.log(a2.some(isNumber)); // logs true
var a3 = ['1', '2', '3'];
console.log(a3.some(isNumber)); // logs false

reduce(callBack[, initialValue]) 从第一个元素至最后一个元素，执行回调函数callBack(firstValue, secondValue)，取得汇总值，返回汇总值。

var a = [10, 20, 30];
var total = a.reduce(function(first, second) { return first + second; }, 0);
console.log(total) // Prints 60

reduceRight(callBack[, initialValue]) 从最后一个元素至第一个元素，执行回调函数callBack(firstValue, secondValue)，取得汇总值，返回汇总值。

多维数组

var a = new Array(4);
for (i = 0; i < 4; i++) {
  a[i] = new Array(4);
  for (j = 0; j < 4; j++) {
    a[i][j] = '[' + i + ', ' + j + ']';
  }
}
/*
Row 0: [0, 0] [0, 1] [0, 2] [0, 3]
Row 1: [1, 0] [1, 1] [1, 2] [1, 3]
Row 2: [2, 0] [2, 1] [2, 2] [2, 3]
Row 3: [3, 0] [3, 1] [3, 2] [3, 3]
*/

类型数组

类型数组是类似数组的对象，其提供访问原始二进制数据的机制。