数组操作

所谓数组,属性值为隐式索引值的对象也。

截取

截取

返回选定的数组片段,参数为负值即为倒数

1
arry.slice(0, 10); //截取前十位元素

截去|替换

会改变原数组,参数 1 为起始位置,参数 2 为删除个数,参数 3 为新替换元素

1
2
let arr = [1, 2, 3];
arr.splice(1, 1, "xixi"); // [1, "xixi", 3]

掐头

1
arry.shift(); //删除并返回第一个元素

去尾

1
arry.pop(); //删除并返回末尾元素

强行剪切

通过指定长度强制删除数组元素

1
2
3
let arr = [1, 2, 3, 4, 5];
arr.length = 3;
console.log(arr); //[1, 2, 3]

追加

头部追加

1
arr.unshift(value);

末尾追加

1
2
3
arr[arr.length] = value;

arr.push(value);

遍历

极速遍历

1
2
3
[1, 2, 3, 4, 5]
.map(e => e * 100) // [100,200,300,400,500]
[(1, 2, 3, 4, 5)].forEach(e => console.log(e * 100)); // 100 200 300 400 500

必要遍历

有一项满足条件则整体合格

1
2
3
4
5
6
7
[1, 2, 3, 4, 5]
.some(e => {
return e > 5;
}) //false
[(1, 2, 3, 4, 5)].some(e => {
return e > 4;
}); //true

充分遍历

有一项不满足条件则整体不合格

1
2
3
4
5
6
7
[1, 2, 3, 4, 5]
.every(e => {
return e > 1;
}) //false
[(1, 2, 3, 4, 5)].every(e => {
return e > 0;
}); //true

打乱重组

打乱

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 打乱重组
randomArray (length) {
var i, index, temp
let arr = [length]
for (i = 1; i <= length; i++) {
arr[i - 1] = i
}
for (i = 1; i <= length; i++) {
index = parseInt(Math.random() * (length - i)) + i
if (index !== i) {
temp = arr[i]
arr[i] = arr[index]
arr[index] = temp
}
}
return arr
}

重组

1
2
3
4
5
6
7
8
9
10
resortArray (oraginList) {
let randomIndex = this.randomArray(oraginList.length)
var targetList = []
for (let index = 0; index < randomIndex.length; index++) {
const element = randomIndex[index] - 1
targetList.push(oraginList[element])
}
console.log(targetList)
return targetList
}

去重

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
let arr = [1, 2, 3, 1, 4, 2, 2, 3];

for (let i = 0; i < arr.length; i++) {
const element = arr[i];
console.log(i);
for (let j = i + 1; j < arr.length; j++) {
const element = arr[j];
console.log("--", j);
if (arr[i] == arr[j]) {
arr.splice(j, 1);
j--;
}
}
}

console.log(arr); // [1,2,3,4]

其他

拼接合并(新返)

1
2
3
let arr = [1, 2, 3, 4, 5];
let arrn = [7, 9];
arr.concat(arrn); //[1, 2, 3, 4, 5, 7, 9]

反转

1
2
let arr = [1, 2, 3, 4, 5];
arr.reverse(); //[5, 4, 3, 2, 1]

排序

默认 unicode 编码顺序,可以用回调函数创建排序规则

默认

1
2
let arr = [2, 1, 3, 4, 5];
arr.sort(); //[1,2,3,4,5]

自定义规则

1
2
3
4
5
6
7
8
9
let arr = [2, 1, 3, 4, 5];
// 升序
arr.sort((a, b) => {
a - b;
}); // [1, 2, 3, 4, 5]
// 降序
arr.sort((a, b) => {
b - a;
}); // [5, 4, 3, 2, 1]

串串(新返)

将数组的项以某种形式连接为字符串

1
[1, 2, 3].join("-"); // '1-2-3'

筛选(新返)

依据条件生成新数组

1
2
3
[1, 2, 3].filter(e => {
return e > 1;
}); //[2,3]

检测

其中一个满足条件即可

1
2
3
[1, 2, 3].some(e => {
return e > 2;
}); // true

NodeList 转数组

1
let array = [...NodeList];

对象=>数组

键名转数组

1
2
Object.keys({ a: "xixi", b: "haha", c: "gaga" });
//["a", "b", "c"];

键值转数组

1
2
Object.values({ a: "xixi", b: "haha", c: "gaga" });
// ["xixi", "haha", "gaga"]