JS-数组的常用方法

遍历数组

for

for(let i = 0; i < arr.length; i++){
    console.log(arr[i]);
}

forof

for(let value of arr){
    console.log(value);
}

forEach

// 每次调用都会将当前遍历到的元素和当前遍历到的索引和当前被遍历的数组传递给这个函数
arr.forEach(function (currentValue, currentIndex, currentArray) {
	console.log(currentValue);
});

---

索引

indexOf()

从左往右查找, 找到返回索引, 找不到返回-1

let arr = [3, 2, 6, 7, 6];
let index1 = arr.indexOf(6);
console.log(index1); // 2

lastIndexOf()

从右至左查找, 找到返回索引, 找不到返回-1

includes()

从左往右查找, 找到返回true, 找不到返回false

let arr = [3, 2, 6, 7, 6];
let result = arr.includes(6);
console.log(result); // true

findIndex()

定制版的indexOf, 找到返回索引, 找不到返回-1

let arr = [3, 2, 6, 7, 6];
let index = arr.findIndex(function (currentValue, currentIndex, currentArray) {
    // console.log(currentValue, currentIndex, currentArray);
    // if(currentValue === 6){
    if(currentValue === 10){
        return true;
    }
});
console.log(index);		// false

find()

find方法返回索引, find方法返回找到的元素
find方法如果找到了就返回找到的元素, 如果找不到就返回undefined

let arr = [3, 2, 6, 7, 6];
let value = arr.find(function (currentValue, currentIndex, currentArray) {
    // console.log(currentValue, currentIndex, currentArray);
    // if(currentValue === 6){
    if(currentValue === 10){
        return true;
    }
});
console.log(value);		// undefined

---

数组的头尾操作

pop()

数组的pop方法可以删除数组中的最后一条数据, 并且将删除的数据返回
只能删除最后一项，无法删除多项,

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

push()

push方法可以在数组的最后新增一条数据, 并且会将新增内容之后数组当前的长度返回

let arr = [1, 2, 3, 4, 5];
let res1 = arr.push('a');
let res2 = arr.push('a', 'b', 'c');
console.log(res1);		// 6
console.log(res2);		// 9

shift()

数组的shift方法可以删除数组中的最前面一条数据, 并且将删除的数据返回

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

unshift()

unshift方法和push方法一样, 可以接收1个或多个参数, 并且会将新增内容之后数组当前的长度返回

let arr = [1, 2, 3, 4, 5];
let res = arr.unshift('a', 'b', 'c');
console.log(res);		// 8

总结 : push 尾插 , pop 尾删 , unshift 头插 , shift 头删

---

清空数组

let arr1 = [1, 2, 3, 4];
arr1.length = 0;	// []
arr1 = [];			// []
arr1.splice(0);		// []
arr1.splice(0, arr1.length);	// []

let arr = [12, 34, 23, 56, 67, 78];
for (let i = arr.length - 1; i >= 0; i--) {
    arr.splice(arr.length - 1, 1)
}
console.log(arr);	//[]

let arr = [12, 34, 23, 56, 67, 78];
for (let i = 0; i < arr.length; i++) {
    delete arr[i];
}
console.log(arr);	// [empty × 6]

---

转为字符串

let str = arr.join(分隔符);

let arr2 = [1, 2, 3, 4];
let res = arr2.join('*');
console.log(res); 	// 1*2*3*4

---

数组的合并与拆分

concat()

concat()方法就是合并两个数组
concat()的参数非常灵活，可以是数组变量、数组字面量、散的值

let arr3 = [1, 2, 3, 4];
let arr4 = ['a', 'b', 'c'];
let res = arr3.concat(arr4);
console.log(res);		    // [1, 2, 3, 4, "a", "b", "c"]


let arr1 = [1, 2, 3, 4, 5];
let arr2 = ['a', 'b', 'c', 'd'];
arr = arr1.concat(arr2, ["张三", "李四"], "王麻子");
console.log(arr);   // [1, 2, 3, 4, 5, "a", "b", "c", "d", "张三", "李四", "王麻子"]

slice()

• slice()方法可从已有的数组中返回选定的元素
• arr.slice(a, b) 返回一个新的数组，包含从 a 到 b(不包括该元素)的元素
• slice(a,b)取出了b-a项
• 如果只有开头 slice(a) , 将从下标为a的项目开始截取后面全部

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

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

---

多功能splice()插入、删除、替换

参数1: 从什么位置开始
参数2: 需要删除多少个元素
参数3: 插入或替换的元素

splice()插入

arr.splice(开始位置, 0, 插入的元素);

let arr = [1, 2, 3, 4, 5, 6];
arr.splice(2, 0, 'a', 'b');		// 插入到下标为2
console.log(arr);	  // [1, 2, "a", "b", 3, 4, 5, 6]

splice()删除

arr.splice(开始位置, 需要删除的元素个数);

let arr = [1, 2, 3, 4, 5, 6];
arr.splice(2, 2);			// 从下标2开始删除两项
console.log(arr);           // [1, 2, 5, 6]

splice()替换

arr.splice(开始位置, 需要替换的元素个数, 替换的元素);

let arr = [1, 2, 3, 4, 5, 6];
arr.splice(1, 2, 'a');      // 替换下标为1后边的两项 [1, "a", 4, 5, 6]
arr.splice(1, 2, 'a', 'b');    // [1, "a", "b", 4, 5, 6]

---

逆序reverse();

reverse()方法就是立即让数组倒置：

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

排序sort()

sort函数默认是按照字符顺序排的，隐式将数字转为string
比字符编码顺序

let arr = ['D', 'M', 's', 'h', 9, 97, 31, 3, 2, 23, 1, 15, '张三'];
let res = arr.sort(); 
console.log(res); 	// [1, 15, 2, 23, 3, 31, 9, 97, "D", "M", "h", "s", "张三"]

sort()里面有一个参数，这个参数是一个函数

let arr = ['D', 'M', 's', 'h', 9, 97, 31, 3, 2, 23, 1, 15, '张三'];
let res = arr.sort(function (a, b) {
    //如果a要放在b前面，那么返回负数
    //如果a要放在b后面，那么返回正数
    //如果a和b不区分大小，那么返回0
    if (a < b) {
        return -1;
    } else if (a > b) {
        return 1;
    } else if (a == b) {
        return 0;
    }
});
console.log(res);	     // ["D", "M", "h", "s", 1, 2, 3, 9, 15, 23, 31, 97, "张三"]

• 如果数组中的元素是数值类型
  • a - b; 升序;
  • b - a; 降序

let arr = [3, 4, 2, 5, 1];
arr.sort(function (a, b) {
    return b - a;
});
console.log(arr);	// [5, 4, 3, 2, 1]

• 比较字符串长度

let arr = ["1234", "21", "54321", "123", "6"];
arr.sort(function (str1, str2) {
    // return str1.length - str2.length;
    return str2.length - str1.length;
});
console.log(arr);	// ["54321", "1234", "123", "21", "6"]

• 比较对象中某一属性的值
  

let students = [
    {name: "zs", age: 34},
    {name: "ls", age: 18},
    {name: "ww", age: 22},
    {name: "mm", age: 28},
];
students.sort(function (o1, o2) {
    // return o1.age - o2.age;
    return o2.age - o1.age;
});
console.log(students);

---

filter()

将满足条件的元素添加到一个新的数组中

let arr = [1, 2, 3, 4, 5];
let newArray = arr.filter(function (currentValue, currentIndex, currentArray) {
    // console.log(currentValue, currentIndex, currentArray);
    if(currentValue % 2 === 0){
        return true;
    }
});
console.log(newArray); // [2, 4]

map()

将满足条件的元素映射到一个新的数组中

let arr = [1, 2, 3, 4, 5];
let newArray = arr.map(function (currentValue, currentIndex, currentArray) {
    // console.log(currentValue, currentIndex, currentArray);
    if(currentValue % 2 === 0){
        return currentValue;
    }
});
console.log(newArray); // [undefined, 2, undefined, 4, undefined]