常见js面试题（数组方法）

一.数组降维    

1. reduce
遍历数组每一项，若值为数组则递归遍历，否则concat。

function flatten(arr) {  
    return arr.reduce((result, item)=> {
        return result.concat(Array.isArray(item) ? flatten(item) : item);
    }, []);
}

2. toString & split

let arr = [[222, 333, 444], [55, 66, 77], {a: 1} ]
arr += '';
arr = arr.split(',');
  
console.log(arr); // ["222", "333", "444", "55", "66", "77", "[object Object]"]

调用数组的toString方法，将数组变为字符串然后再用split分割还原为数组

因为split分割后形成的数组的每一项值为字符串，所以需要用一个map方法遍历数组将其每一项转换为数值型

function flatten(arr) {
    return arr.toString().split(',').map(function(item) {
        return Number(item);
    })
} 

3. join & split

和上面的toString一样，join也可以将数组转换为字符串

function flatten(arr) {
    return arr.join(',').split(',').map(function(item) {
        return parseInt(item);
    })
}

4. 递归

递归的遍历每一项，若为数组则继续遍历，否则concat

function flatten(arr) {
    var res = [];
    arr.map(item => {
        if(Array.isArray(item)) {
            res = res.concat(flatten(item));
        } else {
            res.push(item);
        }
    });
    return res;
}

5. 扩展运算符

es6的扩展运算符能将二维数组变为一维

[].concat(...[1, 2, 3, [4, 5]]);  // [1, 2, 3, 4, 5]

6.Array​.prototype​.flat()

var arr1 = [1, 2, [3, 4]];
arr1.flat(); 
// [1, 2, 3, 4]
  
var arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]
  
var arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]
  
//使用 Infinity 作为深度，展开任意深度的嵌套数组
arr3.flat(Infinity); 
// [1, 2, 3, 4, 5, 6]

---

二.数组去重

1、利用ES6 Set去重（ES6中最常用）

var arr = [1,1,8,8,12,12,15,15,16,16];
function unique (arr) {
  return Array.from(new Set(arr))
}

console.log(unique(arr))
 //[1,8,12,15,16]

2, 利用filter 

var arr = [1, 1, 8, 8, 12, 12, 15, 15, 16, 16];
function unlink(arr) {
    return arr.filter(function (item, index, arr) {
        //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
        return arr.indexOf(item, 0) === index;
    });
}
console.log(unlink(arr));

 3、利用for嵌套for，然后splice去重（ES5中最常用）

//NaN和{}没有去重，两个null直接消失了

双层循环，外层循环元素，内层循环时比较值。值相同时，则删去这个值。

var arr = [1, 1, 8, 8, 12, 12, 15, 15, 16, 16];

function unlink(arr) {
    for (var i = 0; i < arr.length; i++) {    // 首次遍历数组
        for (var j = i + 1; j < arr.length; j++) {   // 再次遍历数组
            if (arr[i] == arr[j]) {          // 判断连个值是否相等
                arr.splice(j, 1);           // 相等删除后者
                j--;
            }
        }
    }
    return arr
}
console.log(unlink(arr));

4、利用indexOf去重

//NaN、{}没有去重
新建一个空的结果数组，for 循环原数组，判断结果数组是否存在当前元素，如果有相同的值则跳过，不相同则push进数组。

var arr = [1, 1, 8, 8, 12, 12, 15, 15, 16, 16];
function unlink(arr) {
    if (!Array.isArray(arr)) {
        console.log('错误！')
        return
    }
    var array = [];
    for (var i = 0; i < arr.length; i++) {    // 首次遍历数组
        if (array.indexOf(arr[i]) === -1) {   // 判断索引有没有等于
            array.push(arr[i])
        }
    }
    return array
}
console.log(unlink(arr));

 5、利用includes

var arr = [1, 1, 8, 8, 12, 12, 15, 15, 16, 16];
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    var array =[];
    for(var i = 0; i < arr.length; i++) {
            if( !array.includes( arr[i]) ) {//includes 检测数组是否有某个值
                    array.push(arr[i]);
              }
    }
    return array
}
console.log(unique(arr))

---

 三.数组排序

1.sort  方法

sort() ：排序

• sort()：只认字符串
• sort(function(){})：可对数字排序

var arr = new Array('1','3','8','55','2','3','5','66');
arr = arr.sort();
console.log(arr.toString())
 // 1,2,3,3,5,55,66,8

2.sort终极

   var arr=[1,1,12,2,3,4,1,3]
        arr.sort(function(a,b){
            return a-b
        })

   console.log([...new Set(arr)]);

/*
 * return b-a; —> 降序排序
 * return a-b; —> 升序排列
 */

3.倒叙   reverse

var array=['我','喜','欢','你'];

    array.reverse(); 

4.冒泡排序

/*
* 总共比较次数为arr.length-1次
* 每次的比较次数为arr.length-1次
* 依次递减
*/
var arr = [10, 20, 40, 60, 60, 0, 30]
 
var temp;//交换变量标识
 
// 两层for分别表示当前项与第二项
for(let i = 0; i < arr.length - 1; i++) {
 for(let j = 0; j < arr.length - 1; j++) {
 
  // 如果当前项大于第二项(后一项)则交换
  if(arr[j] > arr[j+1]) {
   temp = arr[j]
   arr[j] = arr[j+1];
   arr[j+1] = temp;
  }
 }
}
 
// 打印排序后的数组
console.log(arr)//[0, 10, 20, 30, 40, 60, 60]

4.希尔排序

// 希尔排序算法
function xier(arr){
 var interval = parseInt(arr.length / 2);//分组间隔设置
 while(interval > 0){
  for(var i = 0 ; i < arr.length ; i ++){
   var n = i;
   while(arr[n] < arr[n - interval] && n > 0){
    var temp = arr[n];
    arr[n] = arr[n - interval];
    arr[n - interval] = temp;
    n = n - interval;
   }
  }
  interval = parseInt(interval / 2);
 }
 return arr;
}
 
// Array
var arr = [10, 20, 40, 60, 60, 0, 30]
 
// 打印排序后的数组
console.log(xier(arr))//[0, 10, 20, 30, 40, 60, 60]

---