内置对象Array及Array常见操做

Array内置对象的属性

数组方法：

sort(): arrayObject.sort(sortby);

sortby可选，规定排序顺序，可是必须是函数。sort() 方法用于对数组的元素进行排序。

若是调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序，A在a以前。

要实现这一点，首先应把数组的元素都转换成字符串（若有必要），以便进行比较。

实际生产中，受限于服务器成本等因素，当单次数据查询成为总体性能瓶颈时，也会考虑经过将排序在前端完成的方式来优化性能。

function sortBy(a,b)
{
    return a - b ;// 正序
}

reverse()：arrayObject.reverse()方法用于颠倒数组中元素的顺序。arrayObject.reverse()，该方法会改变原来的数组，而不会建立新的数组。

var arrs = [1,2,3,4];
console.log(arrs.reverse()); //[4,3,2,1]

splice(): splice() 方法向/从数组中添加/删除项目，而后返回被删除的项目组成的数组,该方法会改变原始数组。

arrayObject.splice(index,howmany,item1,.....,itemX);

//实例以下

var arr = new Array(6)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
arr[3] = "James"
arr[4] = "Adrew"
arr[5] = "Martin"

var del = arr.splice(2,3,"William")
del    //["Thomas", "James", "Adrew"]
arr    //["George", "John", "William", "Martin"]

toString(): 将数组转换为一个字符串，而且返回这个字符串；这个字符串默认以","进行分割。

var arrs = [1,2];
console.log(arrs.toString()); // 1,2

slice(): arrs.slice(start,end);从数组中截取一段，并返回。

start参数【必须】从何处开始选取(包括start)，若是是负数，那么会从尾部选取，好比-1表明最后一个元素，-2表明倒数第二个元素，以此类推。

End参数【可选】规定是从何处结束选取(不包括end)，若是没有指定该参数，那么数组会包含从start开始到数组结束的全部元素，若是该参数是负数的话，那么它规定的是从数组尾部开始算起的元素。

reduce()，归并方法：前向归并与

reduceRight()，后项归并

这两个的主要区别是从哪头开始遍历，迭代次数为ar.length - 1

var values = [1,2,3,4,5,6];
var i = 1;
var sum = values.reduce(function(prev,cur,index,array){
    console.log("prev  " + parseInt(prev));
    console.log("cur   " + parseInt(cur));
    console.log("迭代次数   " + i++)
    return prev + cur;
});
console.log(sum);

 //输出结果
prev  1
cur   2
迭代次数   1
prev  3
cur   3
迭代次数   2
prev  6
cur   4
迭代次数   3
prev  10
cur   5
迭代次数   4
prev  15
cur   6
迭代次数   5
21

var values = [1,2,3,4,5,6];
var i = 1;
var sum = values.reduceRight(function(prev,cur,index,array){
    console.log("prev  " + parseInt(prev));
    console.log("cur   " + parseInt(cur));
    console.log("迭代次数   " + i++)
    return prev + cur;
});
console.log(sum);

//输出结果
//
prev  6
cur   5
迭代次数   1
prev  11
cur   4
迭代次数   2
prev  15
cur   3
迭代次数   3
prev  18
cur   2
迭代次数   4
prev  20
cur   1
迭代次数   5
21

数组判断：

使用typeof不能测出来，由于数组是返回"object"的。 

//方法1 自带的isArray方法，须要考虑IE8-
var array6 = [];
Array.isArray(array6 );//true

//方法2 利用instanceof运算符,某些IE版本不兼容
var array5 = [];
array5 instanceof Array;//true

//方法3 能力检测，测试是否具备数组的一些方法，如slice();
array.slice

//方法4 利用toString的返回值,最好的方法
function isArray(o) {
     return Object.prototype.toString.call(o) === ‘[object Array]‘;
}

常见的数组问题： 

一、数组高效去重

原理：新建一新数组，遍历传入数组，值不在新数组就加入该新数组中；

注意点：判断值是否在数组的方法“indexOf”是ECMAScript5 方法，IE8如下不支持，需多写一些兼容低版本浏览器代码。

// 最简单数组去重法1
function unique(array){
  var n = []; //一个新的临时数组
  //遍历当前数组
  for(var i = 0; i < array.length; i++){
    //若是当前数组的第i已经保存进了临时数组，那么跳过，
    //不然把当前项push到临时数组里面
    if (n.indexOf(array[i]) == -1) n.push(array[i]);
  }
  return n;
}

// 借助于Set对象与...方法
[...new Set(arr)]

二、数组顺序扰乱 

原理：每次从元数组中抽取一个，而后添加到新数组中，并在原数组中删除。

注意点：arrayObject.splice(index,howmany,item1,.....,itemX) : splice() 方法向/从数组中添加/删除项目，而后返回被删除的项目（这里是一个数组）。该方法会改变原始数组。item是向数组中添加的新元素。

delete删除能够对数组和对象进行元素的删除，数组删除以后，使用Undefined来填补。对象就是删除属性的值（没有了）。

//每次随机抽一个数并移动到新数组中
function shuffle(array) {
    var copy = [],
        n = array.length,
        i;
    // 若是还剩有元素则继续。。。
    while (n) {
        // 随机抽取一个元素
        i = Math.floor(Math.random() * array.length);
        // 若是这个元素以前没有被选中过。。
        if (i in array) {
            copy.push(array[i]);
            delete array[i];
            n--;
        }
    }
    console.log(array);
    console.log(copy);
    return copy;
}
shuffle([2,5,6,9,8,5]);

这样原本的数组也被改变了，变为空。若是在进入函数的时候把array赋值给另外一个变量也是不可行的，由于数组的访问也是按引用的，除非深度复制一份副本（for循环）。否则使用delete||splice就会改变原来的数组。

三、数组求交集

原理：利用filter()方法，返回知足条件的值组成的数组。

相同使用方法的方法以下：

　　every():每项都（知足要求）为真则为真。

　　filter():返回为真的项组成的数组。

　　forEach():每一项都执行给定函数的操做，没有返回值。

　　map():执行函数操做，返回操做的返回值组成的数组。

　　some():任意项为真则为真。

如下是公用的模版形式：

var result = ArrObj.func(function(item,index,ArrObj){
　　return (item >2);//条件
});

//利用filter和数组自带的indexOf方法
array1.filter(function(n) {
     return array2.indexOf(n) != -1
});

四、数组求并集

原理：链接连个数组并去重

注意：concat()：concat() 方法用于链接两个或多个数组。该方法不会改变现有的数组，而仅仅会返回被链接数组的一个副本。arrayObject.concat(arrayX,arrayX,......,arrayX)

function unique(arr1,arr2){
    var a = arr1.concat(arr2),result = [];
    for (var i = 0,len = a.length;i<len;i++){
        if(result.indexOf(a[i]) == -1){
            result.push(a[i]);
        }        
    }
    return result;
}
unique([2,5,6,5,6,8],[5,8,9,2]);

五、数组去重的实现

一、基本数组去重

原理：新建一个数组并返回，把原数组的元素在新建数组中没有存在的添加到新数组中。

Array.prototype.unique = function(){
    var result = [];
    this.forEach(function(v){
        if(result.indexOf(v) < 0){
            result.push(v);
        }
    });
    return result;
}

二、利用hash表去重，这是一种空间换时间的方法，这里若是存在元素是引用类型的就会出问题的

原理：借助于一个对象来进行判断是否惟一

Array.prototype.unique = function(){
    var result = [],hash = {};
    this.forEach(function(v){
        if(!hash[v]){
            hash[v] = true;
            result.push(v);
        }
    });
    return result;
}

上面的方法存在一个bug，对于数组[1,2,'1','2',3]，去重结果为[1,2,3]，缘由在于对象对属性索引时会进行强制类型转换，arr[‘1’]和arr[1]获得的都是arr[1]的值，所以需作一些改变：

Array.prototype.unique = function(){
    var result = [],hash = {};
    this.forEach(function(v){
        var type = typeof(v);  //获取元素类型
        hash[v] || (hash[v] = new Array());
        if(hash[v].indexOf(type) < 0){
            hash[v].push(type);  //存储类型
            result.push(v);
        }
    });
    return result;
}

三、先排序后去重

Array.prototype.unique = function(){
    this.sort();
    var result = this;
    result.forEach(function(v,i){
        if(v === result[i+1]){
            result.splice(i,1);
        }
    });
    return result;
}

[1,2,5,6,4,"1",2].unique();

function randomArr(num,min,max){
    var result = [];
    while(num--){
        result.push(Math.floor(Math.random()*(max-min)) + min +1);
    }
    return result;
}

var arr = randomArr(20000,1,20000);

console.log(arr.unique());

六、快速排序的实现

方法一(尽量不用js数组方法)：

function quickSort(arr){
    qSort(arr,0,arr.length - 1);
}
function qSort(arr,low,high){
    if(low < high){
        var partKey = partition(arr,low,high);
        qSort(arr,low, partKey - 1);
        qSort(arr,partKey + 1,high);
    }
}
function partition(arr,low,high){
    var key = arr[low];  //使用第一个元素做为分类依据
    while(low < high){
        while(low < high && arr[high] >= arr[key])
            high--;
        arr[low] = arr[high];
        while(low < high && arr[low] <= arr[key])
            low++;
        arr[high] = arr[low];
    }
    arr[low] = key;
    return low;
}

方法二(使用js数组方法)：

function quickSort(arr){
   if(arr.length <= 1) return arr;
   var index = Math.floor(arr.length/2);
   var key = arr.splice(index,1)[0];
   var left = [],right = [];
   arr.forEach(function(v){
       v <= key ? left.push(v) : right.push(v);
   });
   return quickSort(left).concat([key],quickSort(right));
}

另外要知道，快速排序的平均时间复杂度O(nlogn),最坏状况是有序的状况，时间复杂度为n的平方，另外快速排序是不稳定的。

七、生成一个二维或者多维的数组，使用for循环来赋值 

function to2Arr(x,y,r){
    var resArr = new Array(y);
    var sArr = new Array(x);
    for (var i = 0; i < x; i++){
        sArr[i] = r;
    }
    for (var j = 0; j < y; j++){
        resArr[j] = sArr;
    }

    console.log(resArr);
    return resArr;
}
to2Arr(5,5,1);//行数、列数、初始值 

以下的三维数组：

function to3Arr(x,y,z,r){
    var resArr = new Array(y);
    var sArr = new Array(x);
    var res3deg = new Array(z);
    for (var i = 0; i < x; i++){
        sArr[i] = r;
    }
    for (var j = 0; j < y; j++){
        resArr[j] = sArr;
    }
    for(var k = 0;k < z; k++){
        res3deg[k] = resArr;
    }
    console.log(resArr);
    console.log(res3deg);
    return res3deg;
}
to3Arr(5,5,5,1);

以下生成一个数组乘积的二维数组：

function fn(n,arr){
    var arr2deg = new Array();
    for(var i=0;i<n;i++){
        arr2deg[i] = new Array();
        for(var j=0;j<n;j++){            
            arr2deg[i][j] = arr[i]*arr[j];
        }
    }
    return arr2deg;
}
fn(4,[1,2,3,4]);

八、对数组进行循环的时候，若是不知道须要循环几回就把for方法放在一个函数中，而后使用for来调用

以下这般：

function func(n,arr,m,maxlen){
    var res = arr;
    for(var i=0;i<m;i++){
        _do(res,maxlen);
    }

    function _do(arrCur,maxlen){
        for(var j=0;j<n;j++){
            for(var k=0,len=arrCur.length;k<len;k++){
                if(k-j<=maxlen && j-k<=maxlen){
                    res.push(arr[j]*arrCur[k]);
                }
            }
        }
        console.log(res);
        res = res.slice(len);
        console.log(res)
    }

    function getMax(arrays){ //获取数组最大值
        return arrays.reduce(function(pre,cur,index,array){  
            return Math.max(pre,cur);  
        });  
    } 

    return getMax(res);

}

func(7,[2,3,40,5,6,-8,9],3,4);