数组
-
含义：有序的数据集合，是js中一种复杂的数据类型
-
创建数组
- 字面量
- var 数组名 = []
- 内置构造函数
- var 数组名 = new Array()
- 字面量
-
添加数据
- 下标的方式
- 数组名[下标] = 数据
- 空数据也会占据长度
- 两个方法添加数据
- 数组名.push(数据)
- 数组名.unshift(数据)
- 下标的方式
-
获取数据
- 下标的方式
- 数组名[下标]
- 下标范围 [0, 数组长度-1]
- 如果越界访问得到的是undefined
- 两个方法获取
- 数组名.pop()
- 数组名.shift()
- 下标的方式
-
取出数组里面所有的数据（遍历数组）
- for循环
- 利用for循环生成数组的下标
- 再利用生成的下标获取数组里面的数据
for(var i=0;i<数组.length;i++){ console.log(i) // 数组下标 console.log(数组[i]) // 取出每一项数据 }
- for循环
-
冒泡排序
- 双重for循环
- 外层循环代表总共需要比较次数 总共需要比较数组的长度-1（因为后面的排好之后剩下的一个数就不需要比较）
- 内层循环代表每一次的比较 每一次拿相邻的两个数进行比较 如果满足条件 交换两个数的位置
-
查找数组里面是否包含某一项
- 数组.indexOf(数据)
- 如果数组里面有这一项数据 返回这一项数据对应的下标
- 如果数组里面没有这一项数据 返回固定值 -1
- 数组.indexOf(数据)
-
反转数组
- 数组.reverse()
- 反转会改变原数组
-
修改数组里面某一项数据
- 找到对应的下标，重新赋值就可以修改
-
删除数组里面某一项数据
- delete 数组[下标] 这种会清空对应下标的数据，不会改变数组的长度
- 数组.splice(下标， 删除的个数)
- 数组.splice(下标, 删除的个数, 新数据, 新数据...) 了解
-
数组排序
- 冒泡排序法
- 排序会改变原数组
- 数组.sort()
- 默认sort的排序规则是按照字符串的比较规则
- 字符串比较规则 从左往右 每一位相比，如果某一位得出结果就直接不比 如果相等就继续比较右一位
- 如果需要sort排序按照数学的方式比较 需要自定义sort的排序规则
-
自定义sort的排序规则
- sort函数可以接收一个参数， 这个参数是一个函数
- 这个传入的函数可以接收两个形参 a b
- a代表后一项 b代表前一项
- sort函数底层也是用冒泡排序算法实现的
- 如果需要交换位置 不需要我们自己去交换
- 只需要返回一个小于0的数，sort函数就会自动给你交换两个数的位置
数组.sort(function(a, b){ // 实现从小到大 if(b>a) return -1 // 实现从大到小 if(b<a) return -1 }) // 从小到大 数组.sort(function(a, b){ return a-b }) // 从大到小 数组.sort(function(a, b){ return b-a }) -
二维数组
- 数组里面每一项数据都是一个数组
-
数组的拼接
- 把两个或者多个数组组合成一个数组
- var 新数组 = 数组.concat(数组01,数组02,数组03...)
- 拼接不会改变原数组，会返回一个拼接后的新数组
遍历数组的方法
- forEach方法
数组.forEach(function(item, index){ console.log(item) // 就是数组的每一项 console.log(index) // 就是数组的下标 }) - map方法
- 映射
- 一般使用map方法是希望将原数组里面每一项数据进行改变，得到一个改变后的新数组
var 新数组 = 数组.map(function(item, index){ console.log(item) // 就是数组的每一项 console.log(index) // 就是数组的下标 return 计算后的数据 // 此处不写返回 得到的新数组里面每一项都是undefined }) - filter方法
- 过滤
- 一般使用filter方法希望保留数组里面某些项数组或者去除某些项数据，返回一个过滤后的新数组
var 新数组 = 数组.filter(function(item, index){ console.log(item) // 就是数组的每一项 console.log(index) // 就是数组的下标 return 条件 // 此处可以返回一个条件 如果条件为true 就会保留这一项数据 // 如果条件为false 就会去除这一项数据 }) - some方法
- 某些
- 判断数组里面是否具有某个条件的数据,返回的是一个布尔值
var 布尔值 = 数组.some(function(item, index){ console.log(item) // 就是数组的每一项 console.log(index) // 就是数组的下标 return 条件 }) - every方法
- 每一个
- 判断数组里面是否每一项都满足这个条件，返回的也是一个布尔值
var 布尔值 = 数组.every(function(item, index){ console.log(item) // 就是数组的每一项 console.log(index) // 就是数组的下标 return 条件 })
实例
（以下代码均为课程实例）
（1）遍历数组
<script>
var list = [10, 23, true, false, undefined, '哈哈哈']
console.log(list)
// 将数组里面每一项数据取出
// 利用for循环生成数组的下标范围 [0, list.length-1]
// for(var i=0;i<=list.length-1;i++){
// console.log(i)
// // 根据下标取获取每一项数组
// console.log(list[i])
// }
for(var i=0;i<list.length;i++){
console.log(i)
// 根据下标取获取每一项数组
console.log(list[i])
}
</script>
（2）数组求和
<script>
var scoreLists = [90, 80, 45, 34, 25, 66, 80, 70]
// 求数组的平均数
var sum = 0
for(var i=0;i<scoreLists.length;i++){
// console.log(scoreLists[i]) // 数组每一项数据
sum += scoreLists[i] // 将每一项进行累加
}
console.log(sum/scoreLists.length)
// 如何找出最高分和最低分
</script>
（3）冒泡排序法-最大值
<script>
// 从小到大 将相邻的两个数据进行比较 如果前一个数大于后一个 交换两个数的位置
var scoreLists = [90, 80, 45, 34, 25, 66, 80, 70]
console.log(scoreLists)
// 此处-1是以为最后一次比较不需要拿最后一项和undefined比较
for(var i=0;i<scoreLists.length - 1;i++){
// 比较相邻的两项
if(scoreLists[i]>scoreLists[i+1]){
// 交换位置
var temp = null
temp = scoreLists[i]
scoreLists[i] = scoreLists[i+1]
scoreLists[i+1] = temp
}
}
// 一轮比较结束 最大的数就在最后一位
console.log('最高分', scoreLists[scoreLists.length - 1])
</script>
（4）冒泡排序法-最小值
<script>
// 从大到小 将相邻的两个数据进行比较 如果前一个数小于后一个 交换两个数的位置
var scoreLists = [90, 80, 45, 34, 25, 66, 80, 70]
console.log(scoreLists)
// 此处-1是以为最后一次比较不需要拿最后一项和undefined比较
for(var i=0;i<scoreLists.length - 1;i++){
// 比较相邻的两项
if(scoreLists[i]<scoreLists[i+1]){
// 交换位置
var temp = null
temp = scoreLists[i]
scoreLists[i] = scoreLists[i+1]
scoreLists[i+1] = temp
}
}
// 一轮比较结束 最小的数就在最后一位
console.log(scoreLists)
console.log('最低分', scoreLists[scoreLists.length - 1])
</script>
（5）冒泡排序法-优化版
<script>
// 从小到大 将相邻的两个数据进行比较 如果前一个数大于后一个 交换两个数的位置
var scoreLists = [90, 80, 45, 34, 25, 66, 80, 70];
console.log(scoreLists);
for (var j = 0; j < scoreLists.length - 1; j++) {
// 每一次内循环都可以少一次
// 因为每一次比较都可以确定一个数的位置 这样就可以少比较一次
for (var i = 0; i < scoreLists.length - 1 - j; i++) {
// 比较相邻的两项
if (scoreLists[i] > scoreLists[i + 1]) {
// 交换位置
var temp = null;
temp = scoreLists[i];
scoreLists[i] = scoreLists[i + 1];
scoreLists[i + 1] = temp;
}
}
}
console.log(scoreLists);
</script>
（6）冒泡排序法
<script>
// 从小到大 将相邻的两个数据进行比较 如果前一个数大于后一个 交换两个数的位置
var scoreLists = [90, 80, 45, 34, 25, 66, 80, 70]
console.log(scoreLists)
/* 第一轮比较 */
// 此处-1是以为最后一次比较不需要拿最后一项和undefined比较
for(var i=0;i<scoreLists.length - 1;i++){
// 比较相邻的两项
if(scoreLists[i]>scoreLists[i+1]){
// 交换位置
var temp = null
temp = scoreLists[i]
scoreLists[i] = scoreLists[i+1]
scoreLists[i+1] = temp
}
}
// 一轮比较结束 最大的数就在最后一位
console.log(scoreLists)
/* 第二轮比较 */
// 此处-1是以为最后一次比较不需要拿最后一项和undefined比较
for(var i=0;i<scoreLists.length - 2;i++){
// 比较相邻的两项
if(scoreLists[i]>scoreLists[i+1]){
// 交换位置
var temp = null
temp = scoreLists[i]
scoreLists[i] = scoreLists[i+1]
scoreLists[i+1] = temp
}
}
// 第二轮比较结束 第二大的数就在最后2位
console.log(scoreLists)
/* 第三轮比较 */
// 此处-1是以为最后一次比较不需要拿最后一项和undefined比较
for(var i=0;i<scoreLists.length - 3;i++){
// 比较相邻的两项
if(scoreLists[i]>scoreLists[i+1]){
// 交换位置
var temp = null
temp = scoreLists[i]
scoreLists[i] = scoreLists[i+1]
scoreLists[i+1] = temp
}
}
// 第3轮比较结束 第3大的数就在最后3位
console.log(scoreLists)
/* 第4轮比较 */
// 此处-1是以为最后一次比较不需要拿最后一项和undefined比较
for(var i=0;i<scoreLists.length - 4;i++){
// 比较相邻的两项
if(scoreLists[i]>scoreLists[i+1]){
// 交换位置
var temp = null
temp = scoreLists[i]
scoreLists[i] = scoreLists[i+1]
scoreLists[i+1] = temp
}
}
// 第4轮比较结束 第4大的数就在最后3位
console.log(scoreLists)
/* 第5轮比较 */
// 此处-1是以为最后一次比较不需要拿最后一项和undefined比较
for(var i=0;i<scoreLists.length - 5;i++){
// 比较相邻的两项
if(scoreLists[i]>scoreLists[i+1]){
// 交换位置
var temp = null
temp = scoreLists[i]
scoreLists[i] = scoreLists[i+1]
scoreLists[i+1] = temp
}
}
// 第5轮比较结束 第5大的数就在最后5位
console.log(scoreLists)
/* 第6轮比较 */
// 此处-1是以为最后一次比较不需要拿最后一项和undefined比较
for(var i=0;i<scoreLists.length - 6;i++){
// 比较相邻的两项
if(scoreLists[i]>scoreLists[i+1]){
// 交换位置
var temp = null
temp = scoreLists[i]
scoreLists[i] = scoreLists[i+1]
scoreLists[i+1] = temp
}
}
// 第6轮比较结束 第6大的数就在最后6位
console.log(scoreLists)
/* 第7轮比较 */
// 此处-1是以为最后一次比较不需要拿最后一项和undefined比较
for(var i=0;i<scoreLists.length - 7;i++){
// 比较相邻的两项
if(scoreLists[i]>scoreLists[i+1]){
// 交换位置
var temp = null
temp = scoreLists[i]
scoreLists[i] = scoreLists[i+1]
scoreLists[i+1] = temp
}
}
// 第7轮比较结束 第7大的数就在最后7位
console.log(scoreLists)
</script>
（7）冒泡排序法01
<script>
// 从小到大 将相邻的两个数据进行比较 如果前一个数大于后一个 交换两个数的位置
var scoreLists = [90, 80, 45, 34, 25, 66, 80, 70]
console.log(scoreLists)
/* 比较的次数是数组的长度-1次 */
for(var j=1;j<=scoreLists.length-1;j++){
/* 每一次比较 */
// 此处-1是以为最后一次比较不需要拿最后一项和undefined比较
for(var i=0;i<scoreLists.length - 1;i++){
// 比较相邻的两项
if(scoreLists[i]>scoreLists[i+1]){
// 交换位置
var temp = null
temp = scoreLists[i]
scoreLists[i] = scoreLists[i+1]
scoreLists[i+1] = temp
}
}
}
console.log(scoreLists)
</script>
（8）查找数组是否包含某一项数据
<script>
var scoreLists = [90, 80, 90, 45, 90, 34, 45, 33, 80, 25, 66, 80, 70]
// 如果有 返回这个数据对应在数组里面下标
// 如果有两个数据 只会返回第一项的下标
var index = scoreLists.indexOf(45)
console.log(index)
// 如果没有这一项数据 返回固定值-1
var index2 = scoreLists.indexOf(46)
console.log(index2)
var index3 = scoreLists.indexOf('哈哈哈哈')
console.log(index3)
</script>
（9）反转数组
<script>
var scoreLists = [90, 80, 45, 34, 25, 66, 80, 70]
scoreLists.reverse()
// 反转会改变原数组
console.log(scoreLists)
</script>
