6种数组扁平化+数组去重+判断为数组的方法

数组方法简介

map: 遍历数组，返回回调返回值组成的新数组
forEach: 无法break，可以用try/catch中throw new Error来停止
filter: 过滤
some: 有一项返回true，则整体为true // every:有一项返回false，则整体为false
join: 通过指定连接符生成字符串
push / pop:末尾推入和弹出，改变原数组， 返回推入/弹出项
unshift / shift: 头部推入和弹出，改变原数组，返回操作项
sort(fn) / reverse: 排序与反转，改变原数组
concat: 连接数组，不影响原数组， 浅拷贝 //
slice(start, end): 返回截断后的新数组，不改变原数组
splice(start, number,value…): 返回删除元素组成的数组，value为插入项，改变原数组
indexOf / lastIndexOf(value,fromIndex): 查找数组项，返回对应的下标
reduce / reduceRight(fn(prev, cur)，defaultPrev): 两两执行，prev 为上次化简函数的return值，cur为当前值(从第二项开始)

数组扁平化

普通递归

/* ES6 */
const flatten = (arr) => {
  let result = [];
  arr.forEach((item, i, arr) => {
    if (Array.isArray(item)) {
	  result = result.concat(flatten(item));
	  // result.push(...flatten(ele))
    } else {
      result.push(arr[i])
    }
  })
  return result;
};

tostring

/* ES6 */
const flatten = (arr) => arr.toString().split(',');

reduce

function flatten(arr){
  return arr.reduce(function(prev, cur){
    return prev.concat(Array.isArray(cur) ? flatten(cur) : cur)
  }, [])
}

some + 展开运算符

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

some + [].concat.apply

/* ES6 */
const flatten = (arr) => {
  while (arr.some(item => Array.isArray(item))){
    arr = [].concat.apply([], arr);
  }
  return arr;
}

Array.prototype.flat

 arr.flat(Infinity)

数组去重

原地去重（性能很好）

function removeDuplicates(nums) {
  if (nums.length === 0) {
    return 0;
  }
  
  let slow = 0;
  
  for (let fast = 1; fast < nums.length; fast++) {
    if (nums[fast] !== nums[slow]) {
      slow++;
      nums[slow] = nums[fast];
    }
  }
  
  return slow + 1;
}

// 示例用法
const nums = [1, 1, 2, 2, 2, 3, 4, 4, 5];
const length = removeDuplicates(nums);
console.log("去重后的数组：", nums.slice(0, length));
console.log("数组长度：", length);

利用对象的 key 唯一

function fn(arr) {
    let obj = {};
    let newArr = [];
    arr.forEach(item => {
        if (!obj[item]) {
            obj[item] = true;
            newArr.push(item);
        }
    })
    return newArr;
}

Array.filter + Array.indexOf

let newArr = arr.filter((item, index) => arr.indexOf(item) === index);  

Array.reduce + Array.includes

let newArr = arr.reduce((accu, cur) => {
    return accu.includes(cur) ? accu : accu.concat(cur);  // 1. 拼接方法
    // return accu.includes(cur) ? accu : [...accu, cur]; // 2. 扩展运算
}, []);

for循环 + Array.includes

let newArr = []
for (var i = 0; i < arr.length; i++) {
  if (!newArr.includes(arr[i]))  newArr.push(arr[i])
}

//等同于 forEach 写法
arr.forEach( item => !newArr.includes(item) ? newArr.push(item) : '')

new Set + 扩展运算符 || Array.from

let newArr = [...new Set(arr)];      // [1, 2, 4, null, "3", "abc", 3, 5]

let newArr = Array.from(new Set(arr));      // [1, 2, 4, null, "3", "abc", 3, 5]

let newStr = [...new Set('ababbc')].join('')  //  'abc'

new Map

let map = new Map();
let newStr = [];

for (let i = 0; i < arr.length; i++) {
    if (!map.has(arr[i])) {
        map.set(arr[i], true);
        newStr.push(arr[i]);
    }
}

判断是否为数组

var a = [];
// 1.基于instanceof
a instanceof Array;
// 2.基于constructor
a.constructor === Array;
// 3.基于Object.prototype.isPrototypeOf
Array.prototype.isPrototypeOf(a);
// 4.基于getPrototypeOf
Object.getPrototypeOf(a) === Array.prototype;
// 5.基于Object.prototype.toString
Object.prototype.toString.apply(a) === ‘[object Array]’;
// 6.ES6 (原理同第五点)
Array.isArray(a); // => true
Array.isArray({0: ‘a’, length: 1}); // => false