这里先提一下for in 循环，因为之前在C++ 和 OC中用到过快速遍历，但是发现JavaScript有所不同，所以要在这里提一下。
JS中的for/in 循环遍历，语法：for(variable in object)。variable通常是一个变量名，object是对象。for/in循环可以遍历对象属性成员，在遍历这个对象的属性成员的时候，属性名将会赋值给这个变量。for/in并不会遍历对象的所有属性，只会历可枚举的属性。现在来看看for/in遍历数组，因为数组可以说是特殊的对象（我的理解是属性名是非负数的对象），在for/in遍历的过程中，数组中的索引将会赋值给这个变量。（这跟我们使用的OC或者C++中的快速遍历不太一样，OC中是把数组中索引的值赋值给变量）。
说到这里，就看看数组的循环遍历吧，直接上例子
//---看点1 普通for循环
var mArray = [-1,0,1,2,3,4,5,6,7,8,9,null,,,123];
for(var i = 0; i<mArray.length; i++){
console.log(mArray[i]);
}
// 通过循环会打印出：
//-1,0,1,2,3,4,5,6,7,8,9,null,undefined,undefined,123
/*
*如果不想输出undefined，我们可以在循环中做判断。
*下面来看看另外一种方法，个人觉得这个方法更加快速。
*这里做个小优化，不必要每次循环都要获取一次数组长度。
*/
var keys = Object.keys(mArray);
for(var key = 0, len = keys.length; key < len; key++)
{
console.log(mArray[keys[key]]);
}
// 通过循环会打印出：
//-1,0,1,2,3,4,5,6,7,8,9,null,123
//-----------------------------------------------------------------
// ---看点2 来看看for in
// for/in 循环的时候，索引所对应的值如果不存在（undefined），是不会遍历的。
for(var index in mArray)
{
console.log(mArray[index]);
}
// 通过循环会打印出：
//-1,0,1,2,3,4,5,6,7,8,9,null,123简单介绍要给数组中用到的方法
* join()
Array.join()方法将数组中所有的元素都转化为字符串并连接在一起，返回一个最终生成的字符串，括号中的参数是一个字符串类型的连接符，默认为逗号。此方法是String.split()方法的逆向操作，后者将字符串分割成若干块来创建一个数组。
var mArray = [1,2,{x:666,y:"hello"},["JavaScript","C++",],null,,,"结束"];
var arrayStr = mArray.join();//==>"1,2,[object Object],JavaScript,C++,,,,结束"
var arrayStr2 = mArray.join("-");//==>"1-2-[object Object]-JavaScript,C++----结束"
var mArrayB = new Array(10);
mArrayB.join("A$");//==> "A$A$A$A$A$A$A$A$A$"reverse()
Array.reverse()方法将数组中的元素颠倒顺序，返回逆序的数组。（此方法是在原来的数组中通过替换的方法重新排列，所以不生成新的数组）
var a = [1,2,3];
a.reverse().join(); //==> "3,2,1"sort()
Array.sort()方法将数组中的元素排序并返回排序后的数组。（当不带参数时候，数组元素是以字母表排序）
var a = new Array("banana","cherry","apple");
a.sort();
a.join(); // ==>"apple,banana,cherry"
var b = [55,3,123,24,582,84]
b.sort();//==>123,24,3,55,582,84
/*此处的参数用一个函数来表示，表示按照从小到大的顺序排列（返回值>0 a在b之后，<0:a在b之前）*/
b.sort(function(a,b){return a-b});//==>3,24,55,84,123,582concat()
Array.concat()方法创建并返回一个新数组，新的数组中包含原数组的元素和’concat()’的每个参数，需要注意的是，如果参数是个数组的话，连接的是数组的元素，而非数组（与Array.push()方法有所区别的），还需注意的是，concat()不会递归扁平化数组的数组，也不会修改调用的数组。
var a =[1,2,3];
a.concat(4,5); //==>[1,2,3,4,5]
a.concat([4,5]); //==>[1,2,3,4,5]
a.concat([4,5],[6,7]); //==>[1,2,3,4,5,6,7]
a.concat(4,[5,[6,7]]); //==>[1,2,3,4,5,[6,7]]slice()
Array.slice()方法返回指定数组的一个片段或子数组。它的两个参数分别指定了片段的开始和结束的位置。
var a = [1,2,3,4,5];
a.slice(0,3); // 返回[1，2，3]
a.slice(3); // 返回[4,5]
a.slice(1-1); // 返回[2,3,4]
a.slice(-3,-2); // 返回[3]splice()
Array.splice()方法是在数组中插入或删除元素的通用方法。不同于slice()和concat(),splice()会修改调用的数组。
/*
*splice() 参数及返回值介绍
*第一个参数：指定掺入或删除的起始位置
*第二个参数：指定了应该从数组中删除的元素的个数。如果省略，则会从起始位置到结尾的元素都删除.
*第三个往后的参数：是指从第一个参数指定的位置开始插入到数组中的元素
*返回：返回一个由删除元素组成的数组。
*（注意：调用函数也会被修改）
*/
// 来看看 用此方法来删除元素
var a = [1,2,3,4,5,6,7,8];
a.splice(4); // 返回[5,6,7,8] a=[1,2,3,4];
a.splice(1,2)// 返回[2,3], a=[1,4];
a.splice(1,1)// 返回[4],a=[1];
// ---------------------------------------------------------
// 再来看看 用此方法来添加元素
var b = [1,2,3,4,5];
b.splice(2,0,"A","L"); //返回[]; b = [1,2,"A","L",3,4,5];
// ---------------------------------------------------------
// 再来看看 用此方法删除和添加元素
var c = [1,2,3,4,5];
//c.splice(2,2,[1,2],"a"); //返回[3,4]; c = [1,2,[1,2],"a",5];
var s = c.splice(2,2,[1,2],"a");push()和pop()
这两个方法允许数组当做栈来使用。这两个方法都修改了元是数组。
push()：在数组的尾部添加一个或多个元素，并返回数组新的长度。
pop()：删除数组的最后一个元素，减少数组长度并返回它删除的值。
var stack = []; // stack:[]
stack.push(1,2); // stack:[1,2] 返回:2
stack.push(3,[4,5]); // stack:[1,2,3,[4,5]] 返回:4
stack.pop(); // stack:[1,2,3] 返回:[4,5]
stack.pop(); // stack:[1,2] 返回:3unshift()和shift()
unshift()和shift()方法的行为非常类似于push()和pop()，但是不一样的是前者是在数组的头部进行操作，而后者是在数组的尾部进行操作。
unshift()：在数组的头部添加一个或者多个元素，并将已存在的元素往后移动，最后返回数组新的长度。
shift()：删除数组的第一个元素并将其返回，删除元素的之后的元素都往前移动。
var a =[]; // a:[]
a.unshift(1); // a:[1] 返回:1
a.unshift(2,[3,4]) // a:[2,[3,4],1] 返回:3
a.shift(); // a:[[3,4],1] 返回:2
a.shift(); // a:[1] 返回:[3,4]ECMAScript 5中的数组方法
forEach()
此方法从头到尾遍历数组，为每个元素调用指定的函数。
第一个参数:传递的函数作为第一个参数，此函数会使用三个参数：数组元素、元素的索引、数组本身。要注意的是，此函数无法再所有元素都传递给调用的函数之前终止遍历。也就是说，没有像for循环中使用的相应的break语句。
var data = [1,2,3,4,5];
//可以通过forEach()计算数组的和
var sum = 0;
data.forEach(function(value){sum+=value;});
document.write(sum +"<br>");
// 为每个数组元素的值自加1
data.forEach(function(value,index,array){array[index]+=1});
document.write(data +"<br>");map()
此方法调用的数组的每个元素传递给指定的函数，并返回一个数组，它包含该函数的返回值。此方法不修改调用的数组，它具有相同的长度，相同的缺失元素。
var a = [1,2,3,4,null,,,8];
var b = a.map(function(value){return value});
// b = [1,2,3,4,null,,,8]
var c = a.map(function(value){return value * value});
// c = [1,4,9,16,0,,,64]filter()
此方法返回的数组元素是调用的数组的一个子集。传递的函数是用来逻辑判定的，函数的返回值是bool类型。注意filter()会跳过稀疏数组中缺少的元素，它的返回数组总是稠密的。
var a = [1,2,3,4,5,null,,8];
var b = a.filter(function(value,index,array){return value>3;});
// b = [4,5,8];
var c = a.filter(function(value,index,array){return index%2 == 0});
// c = [1,3,5];
/*我们也可以通过此函数将稀疏函数转化成稠密函数
*/
var d = a.filter(function(){return true});
// d = [1,2,3,4,5,null,8];every()和some()
这两个函数是数组的逻辑判定：它们对数组元素应用指定的函数进行判定，返回一个Bool类型。
every()：当所有元素都满足函数的条件判断时候，才会返回ture。
some()：只要有元素满足函数的条件判断受，就会返回true。
注意的是，这两个方法一旦确认要返回什么值时候，就会停止遍历。
var a= [1,2,3,4,5,6];
a.every(function(value,index,array){return value > index}); // ==> true
a.every(function(value){return value > 5}); // ==> false
a.some(function(value){return value % 2 === 0}); // ==> true
a.some(isNaN) // ==> false a中不包含非负数元素reduce()和reduceRight()
这两个方法使用指定的函数将数组元素进行组合，生成单个值。这两个方法唯一的区别就是，redeuce()是从前到后（从左到右）执行，而reduceRight()是从后到前（从右到左）执行。
第一个参数:执行化简单操作的函数（函数中两个参数，将两个参数通过某种算法合成一个值）
第二个参数（可选）：是一个传递给函数的初始值。
注意：这两个函数不仅仅只是数学计算，还有更多用途。
var a = [1,2,3];
var sum = a.reduce(function(a,b){return a + b}); // ==> 6
var sum2 = a.reduce(function(a,b){return a + b},100); // ==> 106
// (1^2)^3
var value = a.reduce(function(v,a){return Math.pow(v,a)}); // ==> 1
// (3^2)^1
var value2 = a.reduceRight(function(v,a){return Math.pow(v,a)}) //==>9
document.write(value2);indexOf()和lastIndexOf()
这两个函数很常用，用于搜索整个数组中具有给定值的元素，并返回索引，indexOf()返回的是找到的第一个元素的索引，lastIndexOf()返回的是找到的最后一个元素的索引。