JavaScript 常用数组方法

1，复制数组

1) Array.from

var arr = [1,2,4];
var arr2 = [];
arr2 = Array.from(arr);
arr.push(5);
console.log(arr, arr2);
//  [1, 2, 4, 5]  [1, 2, 4]

2) Array.of()

var arr = [1,2,4];
var arr2 = [];
arr2 = Array.of(...arr); //展开操作符（...）会把arr数组里的值都展开成参数
arr.push(3);
console.log(arr, arr2);
//  [1, 2, 4, 3] [1, 2, 4]

3) slice()

var arr = [1,2,3];
var a = arr.slice();
arr.push(4);
console.log(a); // [1,2,3]

2，类数组转数组

Array.prototype.slice.call(arrayLike);
Array.prototype.slice.apply(arrayLike);
Array.from(arguments);
[...arguments];

常见类数组有：arguments对象，DOM方法返回的列表等。

3，扁平化n维数组

function flatten(arr) {
　　while(arr.some(item => Array.isArray(item))) {
　　　　arr = [].concat(...arr);
　　}
　　return arr;
}

4，去重

// ES6
Array.from(new Set([1,2,3,3]));
[... new Set([1,2,3,3])];
// ES5
Array.prototype.distinct = function(){
    var arr = this, result = [], i, j, len = arr.length;
    for(i = 0; i < len; i++){
        for(j = i + 1; j < len; j++){
            if(arr[i] === arr[j]){
                j = ++i;
            }
         }
         result.push(arr[i]);
    }
    return result;
}
[1,2,3,3,4,4].distinct();

5,排序

arr.sort(); // 默认升序
arr.sort((a, b) => b - a); // 降序

// 冒泡排序1 （j与j+1对比）
var arr = [22,5,4,666,45,29];
var flag = false;
for(var i=0;i<arr.length-1;i++){
　　for(var j=0;j<arr.length-1-i;j++){
　　　　if(arr[j]>arr[j+1]){
　　　　　　//升序
　　　　　　//把较大的值赋给temp
　　　　　　var temp = arr[j];
　　　　　　arr[j] = arr[j+1];
　　　　　　arr[j+1] = temp;
　　　　　　flag = true;
　　　　}
　　}
　　if(flag){
　　　　flag = false;
　　}else{
　　　　break;
　　}
}

// 冒泡排序2
function bubleSort(arr) {
    let len = arr.length;
    for(let outer = len; outer >= 2; outer--) {
        for(let inner = 0; inner <= outer - 1; inner++) {
            if(arr[inner] > arr[inner + 1]) {
            　　// 升序
　　　　　　　　[arr[inner], arr[inner + 1]] = [arr[inner + 1], arr[inner]];
　　　　　　　}
　　　　  }
　　}
　　return arr;
}

// 选择排序 (选择i,与之对比)
function selectSort(arr) {
　　let len = arr.length;
　　for(let i = 0; i < len; i++) {
　　　　for(let j = i; j < len; j++) {
　　　　　　if(arr[i] > arr[j]) {
　　　　　　　　[arr[i], arr[j]] = [arr[j], arr[i]];
　　　　　　}
　　　　}
　　}
　　return arr;
}

6,最大值

Math.max(...[1,2,3]);
Math.max.apply(this, [1,2,3]);
[1,2,3].reduce( (prev, cur, curIndex, arr) => {
　　return Math.max(prev, cur);
}, 0);

7,求和

// reduce
[1,2,3].reduce((prev, cur) => {
　　return prev + cur ;
}, 0);

// slice截取数组，再递归求和。
function sum(arr) {
　　var len = arr.length;
　　if(len === 0) {
　　　　return 0;
　　} else if (len === 1) {
　　　　return arr[0];
　　} else {
　　　　return arr[0] + sum(arr.slice(1));
　　}
}

8,判断数组中是否包含某个值

arr.includes(item); // true/ false
arr.indexOf(item); // -1 或者索引
arr.find(item => item === 3); // 存在则返回item，否则undefined
arr.findIndex(item => item === 3); // 存在则返回索引，否则-1

9,数组随机排序

普通：

var arr = [1,2,3,4,5,6,7,8,9,10];
arr.sort(function(a,b) {
　　return Math.random() > 0.5 ? -1 : 1
});

这样其实并不是完全随机，因为sort是依次比较的，前面的数字插到后面的概率越来越小。

对同一组a、b的值，comparefn(a, b)需要总是返回相同的值。

而Math.random() > 0.5并不满足这个条件。

优化：随机交换

function shuffle(arr) {
　　var i, j;
　　for(i = arr.length - 1; i > 0; i--){
　　　　j = Math.floor(Math.random() * (i + 1));
　　　　[arr[i], arr[j]] = [arr[j],arr[i]]
　　}
　　return arr;
}

以上。

JavaScript 常用数组方法

猜你喜欢