js数组详解：

一. 数组的浅复制与深复制：

数组之间的复制，由于数组是引用类型，如果是字面量式复制，导致只要是改变其中一个数组的值两者都会发生变化，这种复制叫做浅复制。如果要想复制后不收影响，则需要深复制。深复制就是写一个函数，通过遍历把两者之间的值一一交换。

1.浅复制：

var arr = [];
for(var i = 0;i < 10;i++) {
　　arr.push(i+1);//装了个数而已
}
var array = arr;
arr[0] = 400;
alert(array[0]);//

2.深复制：

function deepCopy(arr1,arr2) {
　　for(var i = 0;i < arr.length;i++) {
　　　　arr2[i] = arr1[i];
　　}
}

var arr = [];
for(var i = 0;i < 10;i++) {
　　arr.push(i+1);
}
var array = [];
deepCopy(arr,array);
arr[0] = 100;
alert(array[0]);

二. 数组的查找

indexOf();lastIndexOf();用来查找数组中的参数是否存在，如果存在返回该参数的索引，不存在就返回-1；

三. 数组与字符串的转换：
jion()和toString();这两个方法可将数组形式转化成字符串，个元素用逗号隔开；

var arr = ["Wunworld",22,"assassin","intelwisd",67,90];
var array = arr.join();//Wunworld,22,assassin,intelwisd,67,90
var arra = arr.toString();//Wunworld,22,assassin,intelwisd,67,90

四.已有数组创建数组

concat()和splice();方法允许通过已有的数组创建新数组。concat()可以合并多个数组创建一个数组。splice()截取一个数组的子集创建一个数组。splice的一个参数是截取的其实索引值，第二个是截取的长度。

var arr1 = ["assassin",11,1,23,"Wunworld","intelwisd"];
var arr2 = ["wanghaifu","yangxian","son","daughter"];
var arr3 = arr1.concat(arr2);
alert(arr3);

var arr = [1,2,3,4,5,6,7,8,9,10];
var array = arr.splice(3,5);
alert(array);//4,5,6,7,8

数组的可变函数：

一. 为数组添加元素：push()和unshift();
push();方法将一个元素添加的数组的尾部，unshift();将一个元素添加到数组的头部。添加元素时同样可以用length属性，arr[arr.leng-X] = 元素;这种插入式的添加很耗性能，添加到某一位时后面的都要后移。

二. 从数组中删除元素：pop()和shift();
pop();删除数组末尾的元素，shift();方法可以删除数组的第一个元素。

三. 从数组的中间位置添加和删除元素
删除数组的第一个元素和在数组开头添加一个元素存在同样的问题————都需要将数组的元素向前或向后移动，这时就用splice();方法：
1.起始索引
2.需要截取的个数（添加元素时0）
3.添加进去的数组元素

var arr1 = [1,2,3,7,8,9];
var arr2 = [4,5,6];
var arr3 = arr1.splice(3,0,arr2);
alert(arr3);//???空???

var arr1 = [1,2,3,7,8,9];
var arr2 = [4,5,6];
arr1.splice(3,0,arr2);
alert(arr1);//1,2,3,4,5,6,7,8,9

splice();用法总结：

1).用于截取数组构成新的数组

var arr = [1,2,3,4,5,6,7,8,9,10];
var array = arr.splice(3,5);
alert(array);//4,5,6,7,8

2).用于添加元素

splice(x,0,arr);//x:起始位置，arr:添加的数组

3).用于删除元素

splice(x,y);//x:起始位置，y:个数

1和3，其实是一样的只是对于不同的数组而言。

四. 数组的排序
reverse();该方法将数组中的元素顺序进行翻转
sort();对于sort()方法最好适用于字符的排序，要是进行数组排序（该方法是按照字典排序），调用一个比较大小的函数，简单的相减操作，一个数组减去另一个数字，如果为负数那么被减数小于减数；。。

function de(n1,n2) {
　　return n1-n2;
}

var arr = [11,3,56,78,990,44,56];
var arr2 = arr.sort(de);
alert(arr2);

另见排序总结：

五.数组的迭代方法;

一).不生成新数组的迭代器方法：
1).forEach();该方法接受一个函数作为参数，对与数组中的每一个元素使用该函数。

function square(num) {
　　alert(num*num);
}
var arr = [2,3,4,5,6,7];
arr.forEach(square);

2).every();该方法接受一个布尔类型的函数，读数组中的每一个元素使用该函数，如果对于所有的元素，该函数都（整体）返回true;否则false；

function isEven(num) {
　　return num % 2 == 0;
}
var arr = [2,4,6,8,10];
var even = arr.every(isEven);
if(even) {
　　alert("this num is even");
}else{
　　alert("this num is odd");
}//this num is even;

反例：

function isEven(num) {
　　return num % 2 == 0;
}
var arr = [2,3,10];
var even = arr.every(isEven);
if(even) {
　　alert("this num is even");
}else{
　　alert("this num is odd");
}//this num is odd;

两个例子说明every();接受的是一个布尔类型的一个函数，对于函数的整体进行判断。

3).some();该方法与every()方法相似，同样接受一个布尔类型的函数，读取数组的每一个元素，但只要有一个元素为真，则为真。

function isEven(num) {
　　return num % 2 == 0;
}
var arr = [2,3,5,7];
var even = arr.some(isEven);
if(even) {
　　alert("this num is even");
}else{
　　alert("this num is odd");
}//this num is even;

4)1.reduce();该方法接受一个函数，返回一个值，该方法会从一个累加值开始，不断的累加和数组中的后续元素调用该函数，知道数组中的最后一个元素。该函数和add();函数一起，从左到右，依次对数组中的元素求和。

function add(num1,num2) {
　　return num1+num2;
}
var arr = [1,2,3,4,5,6,7,8,9,10];
var nums = arr.reduce(add);
alert(nums);//
//1+2=3+3=6+4=10+5=15+6=21+7=28+8=36+9=45+10=55

2.reduce();该方法可以吧数组中的元素连接起来；

function add(num1,num2) {
　　return num1+num2;
}
var arr = ["Wunworld","assassin","is","man"];
var arr2 = arr.reduce(add);
alert(arr2);//Wunworldassassinisman;

3.reduceRight();该方法和reduce()方法相似只是从右往左执行。

二).生成新数组的迭代器方法：
//2016/12/22/
map()和filter();
map();与foreach();相似，该方法是对数组中的每一个元素使用某个函数，map();返回一个新的数组，是对原有的元素使用某一个函数的结果。

var arr = [1,2,3,4,0];
var newArr = arr.map(fn);
function fn(arr) {
　　return arr+5;
}
console.log(newArr);

var str = ["Wunworld","Assassin","Intelwisd"];
var newStr = str.map(fn);
function Fn(str) {
　　return str[0];
}
alert(newStr);

filter();与every();相似，传入一个返回值为布尔类型的函数。与every()方法不同的是对的数组中的所有元素执行此函数，结果为true时并不返回true，而是返回一个新的数组，该数组包含使用函数后所对应的元素。

二维数组：
通过扩展JavaScript数组对象为其增加了一个新的方法，该方法通过设置传入新的数据设定了数组的行，列，初始值。

Array.matrix = function(rows,cols,initial) {
var arr = [];
for(var i = 0; i < rows; i++) {
　　var columns = [];
　　for(var j = 0; j < cols; j++) {
　　　　columns[j] = initial;
　　}
　　arr[i] = columns;
　　}
　　return arr;
}

//接受三个参数，行，列，初始的数据0，先定义一个空数组用来存放列元素，遍历行，再遍历中声明一个空的列数组，再进行遍历列，空的列数组进行初始化的赋值。列元素分别赋值给空数组，外侧返回二维数组即可。

var num = Array.matrix(5,5,0);
alert( num[1][1] );//
num = [ [1,2,3],[4,5,6],[7,8,9] ];
alert( num[1][2] );

层次不齐的函数：JavaScript对层次不起的数组表现很好，通过计算每一行的长度来实现。

eg:

var grades = [ [89,90],[109,109,76],[98,99,140,120,56],[79,70,45,67,99] ];
var totals = 0;
var average = 0.0;
for(var row = 0; row < grades.length; row++) {
　　for(var col = 0; col < grades[row].length; col++) {
　　　　total += grades[row][col];
　　}
　　average = total/grades[row].length;
　　alert( "student"+(row+1)+"average:"+average );
　　total = 0;
　　average = 0;
}