三数组
1.数组的声明
-
字面量
var arr = [] -
构造函数
var arr = new Aarry(); 如果参数为一个数值: 代表的数组的长度 如果为多个值,则是数组内容;
2.数组的取值
1.利用数组的下角标: arr[0]
2.数组的下角标都是连续的
3.数组的遍历
遍历方法:
for 循环
for in 循环
for in 常用来遍历对象
4.数组的方法
方法一:
1.push:在数组最后或者多个元素(数组变大),返回添加数组的长度
var arr =[1,2];
arr.push(3) = [1,2,3]
2.pop:从数组最后取出一个元素(数组变小),返回的是数组的最后一个值(取出的数组)
arr.pop(3) =[1,2];
var arr = ["a","b","c"];
var a = arr.pop();
console.log(arr,a);
3.unshift 和push 相反,从数组的第一个位置开始添加数值
arr.unshift(3) =[3,1,2]
4.shift 和pop相反,从数组的第一个位置开始取,返回取出的值(数组长度变小)
5.reverse 反转方法
把数组中的顺序转变一下
var arr =[1,2,3]
arr.reverse()=[3,2,1]
6.sort 排序方法
1.无参数; arr.sort();
不传参数(比较的是ascii码)从第一位开始比较
2.有参数 arr.sort(function(){})
如果想对数字大小进行正序或倒序进行排列,需要往sort函数中传入一个回调函数(sort排序的根据);根据每次返回的值决定left和right的值
案例:
var arr =[1,2,30,25,5,3,90,4,80]
// arr.sort();
arr.sort(function(val1,val2){
return val1-val2;
})
console.log(arr);
案例:
arr.sort(function(a,b){
return a-b;//正序
return b-a//倒序
})
返回<0,不交换a和b的位置;
返回>0,交换a和b的位置
备注:以上6个方法在原数组进行操作,会改变所操作的数组.
方法二:
1.concat 数组连接(拼接)
var arr1 =[1,2,3]
var arr2 =[4,5]
arr1.concat(arr2)
arr =[1,2,3,4,5]
备注:
1.将多个数组连接在一起,返回新的数组
2.不改变原数组
2.join 将数组分割成字符串
arr.join('分隔符');分割符常用 - | & , 空 _
var arr =["a",1]
arr.join('');
注:将数组分割字符串，按照所填的字符不会对原数组造成影响
3.arr.toString() 将数组转化为字符串
注:将数组转成字符串
4.arr.slice(start,end)截取数组的一段
1.从start开始到end(不包含end),返回数组的一段,不操作原数组
2.start和end都不写,返回整个数组arr,常用来快速复制数组
3.按照下标 数组的截取 不包括end不会对原数组造成影响
5.arr.splice(start,deleteCount,arr)
1.从数组中移除一个或多个元素,如果有必要,在移除元素的位置插入新数组
2.返回移除的元素,操作的是原数组.
3.如果deleteCount不写,从start开始到数组结束
4.会产生一个新数组
注:从start开始 删除几个 arr新插入的数组元素。 改变原数组
方法三:(ES5增加)
ES5新增的API:
1.arr.indexOf(value)
a.第一次出现的下标
b.两个参数,后面参数代表从哪个下标开始查找
c.如果不存在,返回的为-1
2.arr.lastIndexOf();
a.从后往前找,返回的也是下标
b.接受两个参数,第二个参数从哪个下标开始
3.arr.forEach(function(value,index,arr)) 遍历数组
value:数组项
index:下标
arr:数组本身
4.arr.map(function(value,index,arr){})
把原数组映射到一个新数组上,不会对原数组造成影响
不会检测空数组
5.arr.reduce(function(acc,value,index,arr){
acc 累计器
value 数组的每一个值
index 下标
arr 数组本身
return acc+value //累加(数组之和)
return acc*value //累乘
return acc/value //累除
return acc-value //累减
})
不改变原数组
6.arr.filter(function(value,index,arr){
//return 过滤条件
})
7.reduce
语法:
arr.reduce(function(prev,cur,index,arr){
...
}, init);
arr 表示原数组；
prev 表示上一次调用回调时的返回值，或者初始值 init;
cur 表示当前正在处理的数组元素；
index 表示当前正在处理的数组元素的索引，若提供 init 值，则索引为0，否则索引为1；
init 表示初始值。
方法四:(ES6新增)
1.includes() 返回的是布尔值
var arr = [1,3,4,6];
console.log(arr.includes(2));
2.Array.of() 将一组数值转成数组
var arr = 1235623;
console.log(Array.of(arr));
3.Array.from() 将伪数组转成数组
var dom = document.getElementsByTagName('*');
var arr = Array.from(dom);
console.log(arr);
4.arr.fill(参数1,参数2,参数3)
参数1:需要填充的数据
参数2:填充开始的下标
参数3:填充结束得下标(不包括)
var arr = [1,2,3,4,5];
var newArr = arr.fill('a',2,4);
5.arr.find(function(value,index,arr){
return value > 3;
})
根据条件返回最近得一个值
var newArr = arr.find(function(val,index,arr){
return val > 3;
})
var newArr = arr.find(function(val,index,arr){
return index > 3;
})
console.log(newArr);
6.arr.findIndex(function(value,index,arr{
return value > 3;
}))
//reduce
var arr = [3,9,4,3,6,0,9];
//求数组之和
const arr1 = arr.reduce((prev,cur)=>{
return prev + cur;
},0)
console.log(arr1);
//求数组最大值
const arr2 = arr.reduce((prev,cur)=>{
return Math.max(prev,cur)
})
console.log(arr2);
//数组去重
let newArr = arr.reduce((prev,cur)=>{
prev.indexOf(cur) == -1 && prev.push(cur);
return prev;
},[])
console.log(newArr);
5.数组排序
// 冒泡排序
var arr =[10,7,8,9,30,20,1];
function bubbleSort(arr){
// 确定循环的次数
for(i = 0 ;i < arr.length - 1; i++){
//确定比较的次数
for(k = 0;k < arr.length - i -1;k++){
//比较相邻两个数,谁大谁往后放
if(arr[k] > arr[k+1]){
var tmp = arr[k];
arr[k] = arr[k+1];
arr[k+1] = tmp;
}
}
}
return arr;
}
//选择排序
var arr =[10,7,8,9,30,20,1];
function chooseSort(arr){
//确定外层循环次数(几轮)
for(var i = 0; i < arr.length - 1; i++ ){
// 确定交换次数
for(var k = i + 1; k < arr.length; k++){
//第一个数依次与后面数进行比较
if(arr[i] > arr[k]){
var tmp = arr[k];
arr[k] = arr[i];
arr[i] = tmp;
}
}
}
return arr;
}
//快速排序
var arr = [10,20,77,30,50,88,190,40];
function quickSort(arr){
if(arr.length <= 1){
return arr;
}
//取中间值以及中间值的下角标,并定义左右的数组
var
midIndex =parseInt(arr.length/2),
midValue = arr[midIndex],
rightArr =[],
leftArr =[];
//遍历数组,都和中间值作比较,大的放在右边数组,小的放在左边数组
for(var i = 0;i < arr.length;i++){
//中间值不和自身做比较,当arr[i]等于中间值时,跳出本次循环;
if(midIndex == i){
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;
}
6.二维数组
//1. 通过循环按行顺序为一个5×5的二维数组a赋1到25的自然数试编程。
var arr =[];
for(i = 0;i < 5;i++){
arr.push([]);
for(k = 0;k < 5;k++){
arr[i].push(k+1+5*i);
}
}
console.log(arr);
7.数组去重
//1.利用indexOf 给数组去重
//逻辑:1.建立一个临时数组,把数组中的每一项和临时数组做比较
// 2.如果临时数组.indexOf(需要去重数组中的元素)为-1,则把该数组值push到临时数组中
// 3.原理:如果为-1,则说明临时数组中没有这个数据
var arr = [1,3,4,2,6,2,3,9,10,5];
function norepeat(arr){
var tempArr = [];
for(var i = 0,k = arr.length; i < k;i++){
if(tempArr.indexOf(arr[i]) == -1){
tempArr.push(arr[i]);
}
}
return tempArr;
}
console.log(norepeat(arr));
//2. 输出数组中没有重复的项
//原理:利用indexOf和lastIndexOf,如果同一个数组值,他们的下标相同,这说明这是一个数,则是不重复的
var arr = [3,3,4,5,4,6,6]
for(var i = 0; i < arr.length; i++){
if(arr.indexOf(arr[i]) == arr.lastIndexOf(arr[i])){
console.log(arr[i]);
}
}
8.数组过滤或求和
//3.把原数组加1,并映射到一个新数组中
var arr = [3,3,4,5,4,6,6];
var arr2 = arr.map(function(value,index,arr){
return value+1;
})
console.log(arr2);
//
console.log(arr.lastIndexOf(3,5));
//4.遍历数组,求数组值的和
var sum = 0;
arr.forEach(function(value,index,arr){
sum += value;
})
console.log(sum);
//5.利用arr.reduce 对数组求和
var arr = [3,3,4,5,4,6,6]
var res = arr.reduce(function(acc,value){
return acc+value;
})
console.log(res);
//6.过滤掉小于5的数组值
var res = arr.filter(function(value,index,arr){
return value >5;
})
console.log(res);
