javaScript中数组的常用方法

一、创建数组的两种方法：

(1) var arr1 = [1,2];
(2) var arr2 = new Array(1,2);

创建空数组方法：

    var arr3 = [];
    var arr4= new Array();

注：方法(2)创建数组时，当参数为一个时候会创建长度为该值的数组，参数均为undefined;其中空数组[]为假值。

var arr5 = new Array(3);//[undefined,undefined,undefined];
[] == false;//true

ES6中提供的新方法Array.of()可以将一组值，转换为数组，若想创建一个单元素数组，如下：

Array.of(3);// [3]

二、Array对象为JavaScript内置对象，具有以下属性：

属性	描述
constructor	返回对创建此对象的数组函数的引用。
length	返回数组中元素的个数
prototype	向对象添加属性和方法。

arr1.construtor;//function Array(){...}

三、Array对象是JavaScript中内置对象，实际上为构造函数，因此通过创建的新数组会继承Array中的属性和方法，下面说下Array中的方法。

方法	描述
push	向数组的末尾添加元素，并返回数组长度
pop	删除数组最后一元素，并返回该元素
unshift	向数组开头插入元素，并返回数组新长度
shift	删除数组的第一个元素，并返回该元素
concat	用于连接两个或多个数组，参数可以是具体数值，也可是数组
join	将数组转化为字符串，参数即为字符串间分隔符
reverse	将数组元素颠倒
slice	选取数组中一个连续片段，不改变原数组，arr.slice(start,end)包含从 start 到 end（不包括该元素）的 arr中的元素,end为可选参数，默认到数组末尾
splice	删除或向数组中添加元素，改变原数组，并返回删除元素，若并未删除元素，则返回空数组，共三个参数，第一个参数为要删除/添加元素的起始位置，第二个参数为要删除元素的个数，第三个为要添加的元素（可选参数）
sort	对数组进行排序，默认按字符编码进行排序，参数为函数（该方法在后续数组排序处会进行详细说明）

补充ES6中新增方法：Array.of()、Array.from(),数组实例的copyWithin、find、findIndex、fill、entires、keys、values、includes
详见大神写的http://es6.ruanyifeng.com/#docs/array

四、 还有一类对象具有length属性但并没有数组的方法，这类对象就是类数组对象，常见的类数组对象有arguments，因此我们可以将类数组对象转换为数组对象，实现方法如下：

var arr5 = Array.prototype.slice.call(arguments);(ES5)
var arr6 = Array.from(arguments);(ES6)

五、对数组对象的常见操作
1.判断一个变量是否为数组对象,有以下常见方法

    1.Object.getPrototypeOf('arr') === Array.prototype;
    2.Object.prototype.toString.apply(value) === '[object Array]'
    3.arr instanceof Array === true;
    4.Array.isArray('arr') === true;
    5.Array.prototype.isPrototypeOf(arr) === true;
    6.obj.constructor==Array||[]

2.遍历数组

1.for循环
var len = arr.length;
for(var i;i < len;i ++){
    arr[i]
}
2.forEach
var newarr1 = arr.forEach(function(item,index,input){
    //item为数组中元素，index为数组arr下表，input为当前数组
})
3.map
var newarr2 = arr.forEach (function(item,index,input){
    //item为数组中元素，index为数组arr下表，input为当前数组
    return ...//相比于forEach多了一个返回，但同样不改变原数组状态，且在回调函数中this指向window
})
4.ES6中for...of对键、值得遍历
for (var index of ['a', 'b'].keys()) {
  console.log(index);
}
for (var elem of ['a', 'b'].values()) {
  console.log(elem);
}
for (var [index, elem] of ['a', 'b'].entries()) {
  console.log(index, elem);
}

3.数组排序

3.1冒泡排序

function bubble(arr){
    if(arr == null || arr.length <= 1){return}
    for (var i = 0,len = arr.length;i < len; i++){
        for (var j = len - 1; j > i; j--){
            if(arr[j]<arr[j-1]){
                arr[j] += arr[j-1];
                arr[j-1] = arr[j] - arr[j-1];
                arr[j] =arr[j] - arr[j-1];
            }
        }
    }
    return arr;
}

Array对象内置方法sort的原理即为冒泡排序，也可传入参数，参数为比较函数，例如：function (a,b){return a-b}

3.2选择排序

function selectSort(arr){
    if(arr == null || arr.length <= 1){return}
    for (var i = 0, len = arr.length; i < len; i++){
        var minIndex = i;
        for (var j = i + 1; j < len; j++){
            if (arr[j] < arr[minIndex]){
                minIndex = j;
            }
        }
        if (minIndex != i){
            arr[i] += arr[minIndex ];
            arr[minIndex ] = arr[i] - arr[minIndex ];
            arr[i] = arr[i] - arr[minIndex ];
        }
    }
    return arr;
}

3.3插入排序

function insertSort(arr){
    if (arr == null||arr.length <= 1){return}
    for (var i = 0,len = arr.length;i < len;i++){
        var j =i ,target = arr[i];
        while (j > 0 && target <arr[j-1]){
            arr[j] = arr[j-1];
            j--;
        }
        arr[j] = target;
    }
    return arr;
}

3.4快速排序（去重）

function quickSort(arr){
    if(arr == null ||arr.length <= 1){return arr;}
    var left = [],right = [],pivot = arr[0];
    for (var i = 1,len = arr.length;i < len;i++){
        if (arr[i] < pivot){
            left.push(arr[i]);
        }
        if (arr[i] > pivot){
            right.push(arr[i]);
        }
    }  
    return quickSort(left).concat(pivot,quickSort(right))
}
注：若不去重，可将if (arr[i] > pivot)改成else

3.5计数排序

function countSort(arr){
    if (arr == null || arr.length <=1){return}
    var len = arr.length, Result = [], Count = [],
        min = max =arr[0];
    for (var i =0; i < len; i++){
        Count[arr[i]] = Count[arr[i]] ? Count[arr[i]]+1 : 1;
        min = min < arr[i] ? min : arr[i];
        max = max > arr[i] ? max : arr[i];
    }
    for (var j = min; j < max; j++){
        Count[j+1] = (Count[j+1] || 0) + (Count[j] || 0)
    }
    for (var k = len - 1; k >= 0; k--){
        Result[Count[arr[k]]-1] = arr[k];
        Count[arr[k]]--;
    }
    return Result;
}

4.数组中迭代方法
forEach()、 map()、every()、filter()、some()，前两种方法在遍历数组中介绍过，下面我们讨论下后3种方法。
4.1 every()：对数组中的每一项运行给定函数。如果函数对每一项都返回true，则返回true。

var arr7 = [2,4,6,8,10];
var arr8 = arr7.every(function(item,index,input){
    return item%2 == 0
});
arr8;//true

4.2 filter():对数组中的每一项运行给定函数。返回该函数会返回true的项组成的数组。

var arr9 = [1,2,3,4,6,8,10];
var arr10 = arr8.filter(function(item,index,input){
    return item%2 == 0
});
arr10;//[2,4,6,8,10]

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

var arr11 = [1,2,3,3];
var arr12 = arr11.some(function(item,index,input){
    return item == 3
});
arr12;//true

以上总结了常用的数组的方法，感谢阅读。。。