JavaScript 数组

用来存储一系列相关数据的一种数据类型

创建数组

字面量方式 ----- [1,2,3,4,5,6];
实例化构造函数 ----- new Array(1,2,3,4,5,6);
组成数组的元素可以是任意的数据类型包括数组本身；

new Array(n): n 表示数组的长度

内容操作

获取（查询）下标 arr[0]; 如果某个下标没有对应内容会得到 undefined
修改/添加 arr[0]=100;

内容遍历

for 循环 while(){}

过滤数组

let gradeArr=[98,85,65,32,89,100,65,45,65,91]

使用 filter 方法：这是最直观的方法，filter 方法创建一个新数组，新数组包含通过所提供函数实现的测试的所有元素。

let passedGrades = gradeArr.filter(function (grade) {return grade >= 60 // 假设及格分数线是60
})
// 使用箭头函数简化
let passedGrades = gradeArr.filter(grade => grade >= 60)

使用 for 循环：传统的方法，遍历数组并将符合条件的元素添加到新数组中。

let passedGrades = []
for (let i = 0; i < gradeArr.length; i++) {if (gradeArr[i] >= 60) {passedGrades.push(gradeArr[i])}
}

使用 forEach 方法：类似于 for 循环，但是是数组的内置方法。

let gradeArr = [98, 85, 65, 32, 89, 100, 65, 45, 65, 91]
let passedGrades = []
gradeArr.forEach(function (grade) {if (grade >= 60) {passedGrades.push(grade)}
})

使用 reduce 方法：reduce 方法对数组中的每个元素执行一个由您提供的“reducer”回调函数，结果是单个输出值，在这里可以累积所有符合条件的元素。

let gradeArr = [98, 85, 65, 32, 89, 100, 65, 45, 65, 91]
let passedGrades = gradeArr.reduce(function (acc, grade) {if (grade >= 60) {acc.push(grade)}return acc
}, [])

使用 for…of 循环：ES6 引入的新循环语法，可以直接遍历数组的值。

let gradeArr = [98, 85, 65, 32, 89, 100, 65, 45, 65, 91]
let passedGrades = []
for (let grade of gradeArr) {if (grade >= 60) {passedGrades.push(grade)}
}

查找

let gradeArr=[98,85,65,32,89,100,65,45,65,91]

使用 find 方法：这个方法返回数组中满足提供的测试函数的第一个元素的值。如果没有找到符合条件的元素，则返回 undefined。

let foundGrade = gradeArr.find(function (grade) {return grade === 65 // 假设我们要找的成绩是65
})
// 使用箭头函数简化：let foundGrade = gradeArr.find(grade => grade === 65)

使用 indexOf 方法：这个方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。

let index = gradeArr.indexOf(65) // 找到65的索引

使用 findIndex 方法：与 find 类似，但是返回的是数组中找到的元素的索引，而不是元素本身。如果没有找到，则返回-1。

let index = gradeArr.findIndex(grade => grade === 65)

使用 includes 方法：这个方法用来判断数组是否包含一个指定的值，根据情况返回 true 或 false。

let isPresent = gradeArr.includes(65) // 判断65是否在数组中

使用 for 循环：传统的方法，遍历数组并检查每个元素是否满足条件。

let foundGrade = null
for (let i = 0; i < gradeArr.length; i++) {if (gradeArr[i] === 65) {foundGrade = gradeArr[i]break // 找到后退出循环}
}

使用 forEach 方法：这个方法遍历数组的每个元素，但它不能像 for 循环那样在找到元素后立即停止。

let foundGrade = null
gradeArr.forEach(function (grade) {if (grade === 65 && foundGrade === null) {foundGrade = grade}
})

使用 for…of 循环：ES6 引入的新语法，可以直接遍历数组的值。

let foundGrade = null
for (let grade of gradeArr) {if (grade === 65) {foundGrade = gradebreak // 找到后退出循环}
}

使用 some 方法：这个方法测试数组中是不是至少有一个元素通过了被提供的函数测试。它返回的是一个布尔值。

let exists = gradeArr.some(grade => grade === 65) // 检查是否至少有一个65

判断

let gradeArr=[98,85,65,32,89,100,65,45,65,91]

使用 includes 方法：判断数组是否包含某个特定的值。

let hasGrade = gradeArr.includes(65) // 返回true，因为数组中包含65

使用 some 方法：判断数组中至少有一个元素满足提供的函数。

let hasPassingGrade = gradeArr.some(grade => grade >= 60) // 返回true，如果至少有一个成绩及格（假设60分及格）

使用 every 方法：判断数组中的所有元素是否都满足提供的函数。

let allPassingGrades = gradeArr.every(grade => grade >= 60) // 返回false，因为不是所有成绩都及格

使用 indexOf 方法：查找数组中某个特定值的第一个索引，如果该值存在于数组中，则返回其索引，否则返回-1。

let index = gradeArr.indexOf(65) // 返回2，因为65第一次出现在数组的第三个位置（索引为2）
let hasGrade = index !== -1 // 如果index不等于-1，说明数组中有65

使用 find 方法：查找数组中满足测试函数的第一个元素的值，如果存在这样的元素，则返回该值，否则返回 undefined。

let foundGrade = gradeArr.find(grade => grade === 65) // 返回65，因为数组中存在65
let hasGrade = foundGrade !== undefined // 如果foundGrade不是undefined，则说明数组中有65

传统的循环方法：使用 for、for…of 或 forEach 循环遍历数组并进行条件判断。

let hasGrade = false
for (let i = 0; i < gradeArr.length; i++) {if (gradeArr[i] === 65) {hasGrade = truebreak // 找到后退出循环}
}
// 使用for...of循环：let hasGrade = false
for (let grade of gradeArr) {if (grade === 65) {hasGrade = truebreak // 找到后退出循环}
}

排序

let gradeArr=[98,85,65,32,89,100,65,45,65,91]

默认排序

gradeArr.sort() // 注意：这会按照字符串的顺序进行排序，可能不是数值大小的顺序
gradeArr.sort((a, b) => a - b) //数值升序排序
gradeArr.sort(function (a, b) {return a - b
}) // 数值降序排序
let sortedGrades = gradeArr.map(grade => grade).sort((a, b) => a - b) // 如果你需要保持原数组不变，可以先使用map方法创建数组副本，然后在副本上调用sort。

冒泡排序

for (let i = 0; i < gradeArr.length; i++) {// 内层循环遍历数组，-i的原因是最后i个已经排序好了for (let j = 0; j < gradeArr.length - 1 - i; j++) {// 相邻元素两两对比if (gradeArr[j] > gradeArr[j + 1]) {//  如果当前元素大于它右边的元素，则交换它们let temp = gradeArr[j]gradeArr[j] = gradeArr[j + 1]gradeArr[j + 1] = temp}}
}
console.log(gradeArr)

选择排序

// 选择排序
for (let i = 0; i < gradeArr.length - 1; i++) {//min代表的是最小值所在的位置let min = i // 检查数组其余部分for (let j = i + 1; j < gradeArr.length; j++) {// 如果发现更小的值if (gradeArr[min] > gradeArr[j]) {// 更新最小值的索引min = j}}// 如果最小值不是当前位置，交换这两个值if(min!==i) {let temp = gradeArr[i]gradeArr[i] = gradeArr[min]gradeArr[min] = temp}}
console.log(gradeArr)

插入排序

// 插入排序
for (let i = 1; i < gradeArr.length; i++) {let temp = gradeArr[i]// 当前要插入的元素let j = i - 1// 将当前元素与已排序部分的元素比较，如果当前元素小于已排序部分的元素，则将已排序元素向后移动while (j >= 0 && temp < gradeArr[j]) {// 已排序元素向后移动gradeArr[j + 1] = gradeArr[j]j--}// 将当前元素插入到正确的位置gradeArr[j + 1] = temp
}
console.log(gradeArr)

快速排序

去重

使用 Set 数据结构：Set 是 ES6 中的一种数据结构，它只存储唯一的值。我们可以将数组转换为 Set，然后再将 Set 转换回数组，这样就可以实现去重。

let arr = [1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 8];
let uniqueArr = Array.from(new Set(arr));
console.log(uniqueArr); // [1, 2, 3, 4, 5, 6, 7, 8]

使用 Array.prototype.filter() 方法：我们可以使用 filter 方法对数组进行筛选，只保留第一次出现的元素，过滤掉后续重复的元素。

let arr = [1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 8];
let uniqueArr = arr.filter((value, index, self) => {return self.indexOf(value) === index;
});
console.log(uniqueArr); // [1, 2, 3, 4, 5, 6, 7, 8]

使用对象键值对：我们可以遍历数组，将数组的元素作为对象的键，值可以是任意非重复的值。最后，提取对象的键即可得到去重后的数组。

let arr = [1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 8];
let uniqueArr = Object.keys(arr.reduce((obj, currentValue) => {obj[currentValue] = true;return obj;}, {})
);
console.log(uniqueArr); // ["1", "2", "3", "4", "5", "6", "7", "8"]

使用 Array.prototype.includes() 方法：我们可以遍历数组，使用 includes 方法判断当前元素是否已经存在于结果数组中，如果不存在则添加到结果数组中。

let arr = [1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 8];
let uniqueArr = [];
arr.forEach((value) => {if (!uniqueArr.includes(value)) {uniqueArr.push(value);}
});
console.log(uniqueArr); // [1, 2, 3, 4, 5, 6, 7, 8]