-
概念:使用单独的变量名来存储一系列的值
-
作用:就是一个容器,将多个数据保存起来
声明数组的方法
- 字面量的方法
var arr = []
- 构造函数方法
var arr = new Array()
如果参数是一个数值:代表的是数组的长度
如果是多个数值,则是数组的内容
var arr = new Array(1,2,4,5,6)
数组的取值
- 利用数组的下角标 例如:arr[0]
- 数组里面的下标都是连续的
数组的遍历
- 根据数组的下标从开始往后扫描,直到结束
- for循环
var arr = [1,2,4,54,34]
for (var i = 0;i<arr.length;i++) {
console.log(arr[i])
}
- for in 循环 (常用来遍历对象)
for (key in arr){
console.log(arr[key])
}
数组的api
- push():在数组最后面添加数据,数组长度会增加 会改变原数组
- pop:从数组最后取出一个数据,数组长度会减少 会改变原数组
- unshift:和push相反,从数组最前面添加数据 会改变原数组
- shift:和pop相反,从数组最前面取出一个数据 会改变原数组
- reverse:反转 改变原数组
- sort:对数组进行排序 ,参数为一个回调函数,
- 无参数时:按照ascii码排序,从第一位开始比 arr.sort()
- 有参数时:arr.sort(function(){}) 对数字进行大小排序,需往sort方法内传入回调函数。
var arr = [12,92,41,1,24]
arr.sort(function(a,b) {
return a-b // 从小到大排 正序
// return b-a // 从大到小排 倒叙
})
console.log(arr)
- concat 数组连接(拼接)不会对原数组造成影响
var arr1 = [1,23,35,3]
var arr2 = [43,53]
var newArr = arr1.concat(arr2)
console.log(newArr) // [1,23,35,3,43,53]
- join 将数组分割成字符串,按照所填的字符 不会对原数组造成影响
var arr1 = ["roy","wang","hello"]
arr1.join("*")
console.log(arr1.join("*")) // roy*wang*hello
- arr.toString() 将数组转换为字符串 不会对原数组造成影响
var arr = ["hello",'roywang']
arr.toString()
console.log(arr.toString()) // hello,roywang
- arr.slice(start,end) 按照下标截取 截取数组的一段 不操作原数组
- 从start开始 end(不包括end),返回数组的一段
- start和end都不写时,返回整个数组arr,常用来快速复制数组
var arr = ["today","is","sunny","I","am","happy"]
var arr2 = arr.slice(0,3)
console.log(arr2) // ["today", "is", "sunny"]
- arr.splice(start,deleteCount,arr) 操作原数组
- 从start开始 删除几个 arr新插入的数组元素
- 从数组中移除一个或多个元素,如果必要,在所移除元素的位置上插入新元素
var arr1 = ["today","is","sunny","I","am","happy"]
arr1.splice(1,3)
console.log(arr1) // (3) ["today", "am", "happy"]
var arr1 = ["today","is","sunny","I","am","happy"]
arr1.splice(1,3,'newData')
console.log(arr1) // ["today", "newData", "am", "happy"]
冒泡排序
9 8 11 6 5
第一轮:
8 9 11 6 5
8 9 11 6 5
8 9 6 11 5
8 9 6 5 11
第二轮:
8 9 6 5
8 6 9 5
8 6 5 9
第三轮:
8 6 5
6 8 5
6 5 8
第四轮:
6 5
5 6
var arr = [12, 32, 43, 23, 5, 46, 45, 26]
function bubbleSort(arr) {
// 确定循环次数
for (var i = 0; i < arr.length - 1; i++) {
// 每一轮 数值比较
for (var j = 0; j < arr.length - i - 1; j++) {
// 谁大谁往后排
if (arr[j] > arr[j + 1]) {
var temp = arr[j]
arr[j] = arr[j + 1]
arr[j + 1] = temp
}
}
}
return arr
}
console.log(bubbleSort(arr))
选择排序
arr = [6,5,1,3,2]
6,5,1,3,2
第一轮:
5,6,1,3,2
1,5,6,3,2
1,5,6,3,2
1,6,5,3,2
第二轮:
6,5,3,2
5,6,3,2
3,6,5,2
2,6,5,3
第三轮:
6,5,3
5,6,3
3,6,5
第四轮
6,5
5,6
var arr = [12, 32, 43, 23, 5, 46, 45, 26]
function chooseSort(arr) {
// 确定循环几轮
for (var i = 0; i < arr.length - 1; i++) {
// 每一轮都和第一个比较
for (var j = i + 1; j < arr.length; j++) {
// 谁小谁放前面
if (arr[j] < arr[i]) {
var temp = arr[i]
arr[i] = arr[j]
arr[j] = temp
}
}
}
return arr
}
console.log(chooseSort(arr))
快速排序
var arr = [12, 132, 43, 23, 15, 46, 45, 26]
function quickSort(arr) {
// 递归结束条件
if (arr.length <= 1) {
return arr
}
// 取中间的值以及中间的下标
var midIndex = parseInt(arr.length / 2),
midValue = arr[midIndex],
leftArr = [],
rightArr = [];
// 遍历arr数组,每一个值和中间的值相比较,大的放右侧,小的放左侧
for (var i = 0; i < arr.length; i++) {
if (i == midIndex) { // 如果是中间下标,直接跳出本次循环,不用中间值比较
continue
}
if (arr[i] <= midValue) {
leftArr.push(arr[i])
} else {
rightArr.push(arr[i])
}
}
// 利用递归处理左右数组
var res = quickSort(leftArr).concat(midValue).concat(quickSort(rightArr))
return res
}
console.log(quickSort(arr))
二维数组
var arr = [[1,2,8],[4,3,2],[3,5,7]]
console.log(arr[0][0]) // 1
for(var i = 0;i<arr.length;i++) {
for(var k = 0;k<arr[i].length;k++) {
console.log(arr[i][k]) // 1,2,8,4,3,2,3,5,7
}
}
值传递和引用传递
- 值传递传递的是基本数据类型的数据,数据不会发生改变,原理:因为常量不可改变
- 引用传递:传递的是对象(数组、对象) 原理:对象存储在堆空间里,自身可以发生改变
基本数据类型:string,number,boolean,null,undefined==>存储在栈
引用类型:object 对象==》存储在堆
ES5新增数组方法
- indexOf
arr.indexOf(v)
返回数组中v第一次出现的下标
arr.indexOf(v,m) 从第m的下标开始查找,返回v所在的arr中的下标 如果出现两个参数 后面参数代表从那个下标查找
如果不存在返回 -1
var arr = [1,2,3,4,5,6,2,7,8]
console.log(arr.indexOf(2)) // 1
console.log(arr.indexOf(2,3)) // 6
console.log(arr.indexOf(9)) //-1
var arr = [1, 2, 3, 4, 5, 6, 2, 7, 8]
// indexOf实现数组去重
function noRepeate(arr) {
var tempArr = []
for (var i = 0; i < arr.length; i++) {
if (tempArr.indexOf(arr[i]) == -1) {
tempArr.push(arr[i])
}
}
return tempArr
}
console.log(noRepeate(arr))
- lastIndexOf(v)
返回数组中v最后一次出现得下标
如果油两个参数arr.lastIndexOf(v,m)从第m得下标开始向前查找,返回v所在arr中得下标,如果没有就返回-1
var arr = [1, 2, 3, 4, 5, 6, 2, 7, 8]
console.log(arr.lastIndexOf(2)) // 6
console.log(arr.lastIndexOf(2, 3)) // 1
console.log(arr.lastIndexOf(9)) //-1
以下方法,参数都是回调函数:
- forEach遍历数组 (forEach没有返回值,要用一个变量接收)
arr.forEach(function(value,index,arr){
console.log(value) // 把数组值都遍历出来了
console.log(index) // 把数组索引遍历出来
console.log(arr) // 把数组本身打印出来
})
- map
var arr = [1, 23, 42, 453, 3]
var arr2 = arr.map(function (value, index, arr) {
// 把数组中的每一项加1,然后映射到一个新数组,不影响原数组
return value + 1
})
console.log(arr2) // [2, 24, 43, 454, 4]
- reduce
// 不改变原数组
arr.reduce(function(acc,value,index,arr){
// 参数1:累加器
// 参数2:数组的值
// 参数3:数组索引
// 参数4:源数组
return acc + value // 累加
return acc * value // 累乘
return acc / value // 累除
return acc - value // 累减
})
var arr = [1,232,42,5]
var res = arr.reduce(function(acc,value){
return acc + value // 累加
})
console.log(res) // 280
- filter
arr.filter(function(vale,index,arr){
return 过滤条件
})
var arr = [1,232,42,52,3234,22,4,5]
var res = arr.filter(function(value,index,arr){
return value>22
})
console.log(res) // [232, 42, 52, 3234]