javascript引用类型值Array

定义：

1.使用Array构造函数。

var arr = new Array()

2.使用数组字面量定义：

var arr = []

以上两种定义方法是等价的。

查询和修改数组：

alert(arr[0])  //查询arr数组索引为0的一项得值
arr[0]=\'hello\' //修改arr数组索引为0的一项的值

属性：

a.数组的项数保存在其length属性中，这个属性始终会返回0或更大的值，如下所示：

var arr = [1,2,3,4];
var arrl = [];
alert(arr.length) // 4
alert(arrl.length) // 0

length不是只读的，因此我们可以通过设置这个属性，将数组末尾移除项或者向数组中添加新项：

var arr = [\'jack\',\'henry\',\'lily\'];
arr.length = 2;
alert(arr[2])  //undefined 这里的索引值2刚好是arr数组的第三项，所以获取到的值是undefined。

检测数组：

var arr = [{ name:\'jack\' },1,\'hello\']
console.log(arr instanceof Array) // true
console.log(Array.isArray(arr))   // true

instanceof有一个问题，它假定只有一个全局执行环境。

方法：

所有对象都具有toLocalString()、toString()、valueOf()、join()方法。

调用valueOf()方法返回的还是数组本身。

调用数组的toString()方法会返回每个值得字符串形式拼接而成的以一个逗号分割的字符串，实际上，为了创建这个字符串会调用数组每一项的toString()方法。

join()方法只接受一个参数，即用作分隔符的字符串，然后返回所有包含数组项的字符串。

var arr = [\'blue\',\'red\',\'pink\',null,undefined];
console.log(arr.toString());      // blue,red,pink,,
console.log(arr.valueOf());       // [\"blue\", \"red\", \"pink\", null, undefined]
console.log(arr);                 // [\"blue\", \"red\", \"pink\", null, undefined]
console.log(arr.join(\'.\'));       // blue.red.pink..

如果数组的某一项是null或者undefined，那么该值在以上几种方法返回的结果中以空字符串出现。

栈方法：

** 数组可以表现得像栈一样，后者是一种可以限制插入和删除的的数据结构，栈是一种LIFO(后进先出)的的数据结构,也就是最新添加的项最早被移除，而栈中项的插入和移除只发生在一个位置--栈的顶部，push()和pop()方法就专门为数组提供了实现类似栈的行为。

push()：push()方法可以接收任意数量的参数，把它们逐个添加到数组的末尾，并返回修改后数组的长度。

pop()：pop()方法从数组末尾移除最后一项，减少数组的length值，然后返回移除项。

var arr = new Array();        // 创建素组
var count = arr.push(\'a\',1);  // 推入（插入）两项
console.log(arr);             // [\"a\", 1]
console.log(count);           // 2
count = arr.push({name:\'zs\'});// 推入一项
console.log(arr);             // [\"a\", 1, {…}]
console.log(count);           // 3
var item = arr.pop();	      //移除最后一项并返回移除的项
console.log(item);            // {name: \"zs\"}
console.log(arr.length);      // 2

队列方法：

队列数据结构的访问规则是FIFO（先进先出），队列在数组的末尾插入项，在数组的前段移除项

shift()：它能够移除数组中的第一项并返回该项。

unshift()：与shift()方法相反，它能在数组的前端添加任意个项，并返回新的长度。

var arr = [\'blue\',\'red\',\'pink\',null,undefined];
console.log(arr.length);        // 5
var item = arr.shift();
console.log(item);              // blue 获得了数组arr第一项的值
console.log(arr.length);        // 4 
console.log(arr.unshift(item)); // 5

重排序方法：

数组中已经存在两个可以直接用来重排序的方法

reverse()：反转数组项的顺序。

var arr = [1,2,3,6,45,8];
arr.reverse(); 
console.log(arr); //  [8, 45, 6, 3, 2, 1]

 sort()：按照升序排列数组项---即最小的值位于最前面，最大的值排在最后面，为了实现排序，该方法会调用每个数组项的toString()：转型方法，然后比较得到的字符串，确定如何排序。

这里我们定义了一个方法：compare，可以适用于大多数数据类型的比较。

var arr = [1,2,3,\'6\',\'a\',8];
	arr.reverse(); 
	console.log(arr); //  [8, \"a\", \"6\", 3, 2, 1]
	function compare(a,b) {
		if(a>b) {
			return 1;
		}else if(a<b) {
			return -1;
		}else{
			return 0;
		}	
	}
	var index = arr.sort(compare) //将重排序的数组赋值给变量index
	console.log(index); // [1, 2, 3, \"6\", 8, \"a\"]

对于数值类型或者其valueOf()方法会返回数值类型的对象类型，可以使用一个更加简单的比较函数：

var arr = [1,2,3,6,45,8];
arr.reverse(); 
console.log(arr);  //  [8, 45, 6, 3, 2, 1]
function compare(value1,value2) {
	return value1-value2;
}
var index = arr.sort(compare)
console.log(index); //[45, 8, 6, 3, 2, 1];

reverse()和sort()方法的返回值是经过排序后的数组

操作方法：

ECMA 为操作已经包含在数组中的项提供了很多方法。

concat()：concat()方法可以基于当前数组中的所有项创建一个新数组。具体来说，这个会先创建当前数组的一个副本，然后将接收到的参数添加到当前数组并返回副本的末尾，最后返回构建的数组。

var arr = [\'mary\',\'jack\',\'lily\',\'lql\'];
console.log(arr);   // [\"mary\", \"jack\", \"lily\", \"lql\"]
var newarr = arr.concat(\'hehe\',[5,\'1\']);
console.log(newarr); // [\"mary\", \"jack\", \"lily\", \"lql\", \"hehe\", 5, \"1\"]

slice()：它能够基于当前数组中的一或多个项创建一个新数组。该方法可以接收一个或者两个参数，即要返回的项的起始位置和结束位置，在只有一个参数的情况下，slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。如果有两个参数，该方法返回起始和结束位置之间的项。 slice()不会影响到原始数组。

var arr = [\'mary\',\'jack\',\'lily\',\'lql\'];
var newarr = arr.slice(1);
console.log(newarr); // [\"jack\", \"lily\", \"lql\"]截取索引值为1的项后面所有的项，并组成一个新的数组。
var newarr1 = arr.slice(1,3);
console.log(newarr1);  //[\"jack\", \"lily\"] 截取的项目数是一个左闭右开区间。

如果slice()方法的参数中有一个负数，则用该数组的长度加上该数来确定相应的位置。如下：数组中调用slice(-2,,-1),与调用slice(3,4)是同样的结果。

var arr = [\'mary\',\'jack\',\'lily\',\'lql\',\'hehe\'];
var newarr = arr.slice(3,4);
var newarr1 = arr.slice(-2,-1);
console.log(newarr);  // [\"lql\"]
console.log(newarr1); // [\"lql\"]

splice()： 这个方法的主要用途是向数组的中部插入项，但是使用这个方法的方式就有3种。

删除：

可以删除任意数量的项，只需指定两个参数：要删除的第一项位置和要删除的项数。

var arr = [\'mary\',\'jack\',\'lily\',\'lql\',\'hehe\'];
var newarr = arr.splice(0,2); 
console.log(arr); // [\"lily\", \"lql\", \"hehe\"] 前两项已被删除。 
console.log(newarr); // [\"mary\", \"jack\"] 被删除的两项被返回到newarr这个新的数组里面。

插入：

可以向指定位置插入任意的项，只需提供三个参数：起始位置、要删除的项数，和要插入的项。如果需要插入多个项，可以一次在插入项后面添加并用逗号隔开：

var arr = [\'mary\',\'jack\',\'lily\',\'lql\',\'hehe\'];
var newarr = arr.splice(0,2,\'hello\',\'ninhao\',\'nihaoa\'); 
console.log(arr);    // [\"hello\", \"ninhao\", \"nihaoa\", \"lily\", \"lql\", \"hehe\"] 新的数组
console.log(newarr); // [\"mary\", \"jack\"] 被删除的两项被返回到newarr这个新的数组里面。

替换：

var arr = [\'mary\',\'jack\',\'lily\',\'lql\',\'hehe\'];
var newarr = arr.splice(2,1,\'hello\',); 
console.log(arr);    // [\"mary\", \"jack\", \"hello\", \"lql\", \"hehe\"] 索引值为2的那一项已经被替换
console.log(newarr); // [\"lily\"] 被删除的两项被返回到newarr这个新的数组里面。

位置方法：

ECMA 为数组实例添加了两个位置方法： indexOf()，lastIndexOf()。这两个方法都要接收两个参数：要查找的项和表示查找起点的位置（可选）的索引。

indexOf()：

var arr = [1,55,3,4,3,\'a\',{name:\'aaa\'},null];
console.log(arr.indexOf(\'a\')); // 返回索引值5

lastIndexOf()：

var arr = [1,55,3,4,3,\'a\',{name:\'aaa\'},null];
console.log(arr.lastIndexOf(null)); // 返回索引值7

迭代方法：

ECMA 5给数组定义了5个迭代方法。每个方法都接收两个参数：要在每一项上运行的函数和运行函数的作用域对象（可选）----影响this值。传入这些方法中的函数会接收三个参数：数组项的值、该项在数组中的位置和数组本身对象。根据使用的方法不同，这个函数执行后的返回值可能会也可能不会影响方法的返回值。

every()：对数组中的每一项运行运行定函数，如果该函数对每一项都返true，则返回true。

fifter()：对数组中的每一项运行给定函数，返回该函数会返回true的项组成的数组。

forEach()：对数组中的每一项运行给定函数，这个方法没有返回值。

some():对数组中的每一项运行给定函数，如果该函数对任一项返回true，则返回true。

以上方法都不会修改数组中包含的值。