数组判断
星月 3/25/2022 js
# 数组判断
var arr = []
arr instanceof Array
Array.prototype.isPrototypeOf(arr)
arr.constructor === Array
Object.prototype.toString.call(arr) === "[object Array]"
Array.isArray(arr)
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
# 数组转化
var set = new Set([1, 2])
// 类数组对象以及部署了遍历器接口的对象
Array.from(set)
[...set]
// 只能转化类数组对象 (arguments和Nodelist)
Array.prototype.slice.call(arguments)
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
# 数组去重
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
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# 数组扁平化
flat(Infinity)
var arr = [1, 2, [3, [4, 5]]]
arr.flat(Infinity)
1
2
3
2
3
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)
}
1
2
3
4
5
6
7
2
3
4
5
6
7
递归
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
}
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
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)
}, [])
}
1
2
3
4
5
6
2
3
4
5
6
[].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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# reduce 实现 map
Array.prototype.map = function (fn) {
let result = []
this.reduce((total, current, index) => {
result.push(fn(current))
}, [])
return result
}
1
2
3
4
5
6
7
2
3
4
5
6
7
# 数组乱序
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]]
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
# 常用方法
var arr = [2, 7, 0, 6, 1, 4, 8, 3]
arr.sort((a, b) => a - b) // 递增
arr.sort((a, b) => b - a) // 递减
1
2
3
2
3