JavaScript 数组总结

JavaScript没有明确的数组数据类型，可是外面能够经过使用内置Array对象和它的方法对数组进行操做，Array对象有不少操做数组的方法，好比 合并，反转 ，排序，数组对象有一个决定数组长度和使用正则表达式操做其余属性的属性，你能够分配length属性，写一个小于数组元素变量的值会缩短数组自己，写0会完全清空数组

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 nothing; the cats array is empty

cats.length = 3;
console.log(cats); // [undefined, undefined, undefined]

 

遍历数组

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

若是你肯定数组中没有一个元素的求值是false —— 若是你的数组只包含DOM节点，以下,你能够选择一个更高效的土法子:

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

这样避免了检测数组长度的开销，额外的好处是确保了div变量当前在每次循环中都被从新赋值为当前项。 

forEach()方法提供了遍历数组元素的其它方法
var colors=['red', 'green', 'blue'];
colors.forEach(function(color){
console.log(color); //color要写或其余的名字也行，但不能为空
});

被传递给forEach的函数会在数组的每一个元素像上执行一次，元素做为参数传递给该函数。未赋值的值不会在forEach循环迭代。

注意，在数组定义时省略的元素不会在forEach遍历时被列出，可是手动赋值为undefined的元素是会被列出的：

数组的方法 concat()链接两个数组并返回一个新的数组

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

join()将数组的全部元素链接成一个字符串 

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()从数组提取一个片断，并做为一个新数组返回 

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

splice(添加或删除的位置，数量，增长的元素)从数组移出一些元素（可选）并替换他们

在数组的第2位置添加一个元素 - splice()
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,0,"Lemon","Kiwi");
Banana,Orange,Lemon,Kiwi,Apple,Mango

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" ]

sort()也能够带一个回调函数来决定怎么比较数组元素，这个回调函数比较2个值，并返回3个值中的一个
var points = [40,100,1,5,25,10];
points.sort(function(a,b){return a-b});//数字升序排列数组，
解释：第一次比较第一个与第二个数（a(40)与b(100)）,a-b为负数，则位置不变，若a-b为正数则位置交换，而后比较第一个和第三个，依次比较到第一个与最后一个，第二轮，第二个与第三个开始比较，第二个与第四个比较，直到第二个与最后一个，而后第三轮。。。
这种排序方法叫作冒泡排序
var points = [40,100,1,5,25,10];
points.sort(function(a,b){return b-a});//数字降序排列数组

例如，下面的代码经过字符串的最后一个字母进行排序：
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"]
若是 a 小于 b ，返回 -1(或任何负数)
若是 a 大于 b ，返回 1 (或任何正数)
若是 a 和 b 相等，返回 0。

indexOf(选择元素，开始位置)

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,

laseIndexOf(选择元素，开始位置)和indexOf差很少，可是从结尾开始，而且是反向搜索

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

map(callback[, thisObject]) 也就是遍历数组，并经过callback对数组元素进行操做，并将所要操做结果放入数组中并返回该数组

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

filter(callback[, thisObject]) 返回一个全部在回调函数上返回true的元素的新数组

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

every(callback[, thisObject])  当数组中每一个元素在callback上被返回true时就返回true,功能相似filter,只不过
功能是判断是否是数组中的全部元素都符号条件，而且返回的是bool值

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]) 只要数组中有一项在callback上被返回true，就返回true。

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

如下代码建立了一个二维数组.

var a = []; for (i = 0; i < 4; i++) {   a[i] = [];   for (j = 0; j < 4; j++) {     a[i][j] = "[" + i + "," + j + "]";   } }