数组

数组判断

var arr = []

arr instanceof Array

Array.prototype.isPrototypeOf(arr)

arr.constructor === Array

Object.prototype.toString.call(arr) === "[object Array]"

Array.isArray(arr)

数组转化

var set = new Set([1, 2])

// 类数组对象以及部署了遍历器接口的对象
Array.from(set)

[...set]

// 只能转化类数组对象 (arguments和Nodelist)
Array.prototype.slice.call(arguments)

数组去重

var arr = [1, 2, 2, 4, 9, 6, 7, 5, 2, 3, 5, 6, 5]


// Set
Array.from(new Set(arr))


//缺点： indexOf或者includes都是遍历数组，时间复杂度高
function unique(arr) {
    let newArr = []
    for (let i = 0; i < arr.length; i++) {
        let item = arr[i]
        if (!newArr.includes(item)) {
            newArr.push(item)
        }
    }
    return newArr
}

// 把数组的值放在对象的键值里， 对于 数组中的 1 和 “1” ， 要再一次对比
// 空间复杂度高， 所谓的空间换时间
function unique(arr) {
    let newArr = []
    let obj = {}
    for (let i = 0; i < arr.length; i++) {
        let item = arr[i]
        let type = typeof item
        if (!obj[item]) {
            newArr.push(item)
            obj[item] = [type]
        } else if (!obj[item].includes(type)){
            newArr.push(item)
            obj[item].push(type)
        }
    }
    return newArr
}

// 排序法，先用sort排序再比较
// 相比前两种，时间和空间用的都没那么多
// 缺点：排序了
function unique(arr) {
    arr.sort()
    let newArr = [arr[0]]
    for (let i = 0; i < arr.length; i++) {
        let item = arr[i]
        if (newArr[newArr.length - 1] !== item) {
            newArr.push(item)
        }
    }
    return newArr
}

数组扁平化

flat(Infinity)

var arr = [1, 2, [3, [4, 5]]]

arr.flat(Infinity)

JSON.stringify + 正则 + JSON.parse

var arr = [1, 2, [3, [4, 5]]]

function flat(arr) {
    let str = JSON.stringify(arr).replace(/[\[|\]]/g, '')
    str = `[${str}]`
    return JSON.parse(str)
}

递归

function flatter(arr) {
	let newArr = []
	arr.forEach(item => {
		if (Array.isArray(item)) {
			// newArr.push(...flatter(item))
			newArr = newArr.concat(flatter(item))
		}
		else {
			newArr.push(item)
		}
	})
	return newArr
}

Reduce + 递归

var arr = [1, 2, [3, [4, 5]]]
function flatter(arr) {
	return arr.reduce((prev, next) => {
		return prev.concat(Array.isArray(next) ? flatter(next) : next)
	}, [])
}

[].concat(...arr)

var arr = [1, [2, [3, 4]]];
console.log([].concat(...arr)); // [1, 2, [3, 4]]
// 该操作可以拍平一层

var arr = [1, [2, [3, 4]]];

function flatten(arr) {

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

    return arr;
}

console.log(flatten(arr))

reduce 实现 map

Array.prototype.map = function (fn) {
    let result = []
    this.reduce((total, current, index) => {
        result.push(fn(current))
    }, [])
    return result
}

数组乱序

let arr = [1, 2, 3, 4, 5]
arr.sort(() => {
    return Math.random() - 0.5
})

// 加强版
// 遍历数组，每一项和该项之前的随机项交换位置
function shuffle(arr) {
    for (let i = 0; i < arr.length; i++) {
        let j = ~~(Math.random() * (i + 1));
        [arr[i], arr[j]] = [arr[j], arr[i]]
    }
}

常用方法

var arr = [2, 7, 0, 6, 1, 4, 8, 3]
arr.sort((a, b) => a - b) // 递增
arr.sort((a, b) => b - a) // 递减