数组
2022-08-16 本文已影响0人
5cc9c8608284
数组
数组用于存放多个数据
创建一个数组
1.构造函数创建数组
(1)new Array(长度)
长度:数组里面的数据总数，长度一定是一个非负整数
var arr=new Array(20);//创建了一个长度为20的数组
console.log(arr);//[empty × 20]
(2)new Array(数据，数据，数据.....)
创建一个数组，并初始化其每一项的值
数组项：数组其中的一项数据
var arr=new Array(1,2,3,4,5);//创建一个长度为5的数组，数据项分别是1，2，3，4，5
2.字面量创建数组
[数据，数据，数据....]
创建一个数组，并初始化其每一项的值
var arr=[1,2,3,4,5,6];//创建一个长度为5，数据项分别为1,2,3,4,5,6的数组
数组里面可以存放任意类型的值，比如对象，函数,null,undefined等
var arr=[1,'qqq',true,null,undefined,{x:1,y:2}]
认识数组的本质
- length属性:数组的长度,会自动变化，值为最大下标加1
连续下标的取值范围:0-length-1,如果给length直接赋值，会导致数组可能被截断，实际开发中，不要给length赋值
- 数字、字符串属性：叫做下标，也叫索引，相当于数组中每个数据的编号
下标
通常情况下，下标是连续的
下标不连续的数组，叫做稀松数组
var arr=new Array(20);
arr[20]=111
console.log(arr);//长度为21的稀松数组
var a1=[1,2,3,4,5,6];
a1[10]='abc'
console.log(a1);//长度为11的稀松数组
var a2=[,,,,];//长度为4的稀松数组
console.log(a2.length);//数组的最后一个逗号会被忽略,比如[1,2,3,],最后一个逗号就会被js忽略掉
数组的常见操作
添加数组项
(1)数组[长度]=数据:向数组末尾添加一个数据
var arr=[1,2,3,4,5];
arr[5]=6;
console.log(arr);//1,2,3,4,5,6
arr[arr.length]=7
console.log(arr);//1,2,3,4,5,6,7
(2)数组.push(数据)：向数组末尾添加数据
var arr=[1,2,3,4,5];
arr.push(6);//添加一个数据
console.log(arr);//[1, 2, 3, 4, 5, 6]
arr.push(7,8,9,10);//添加多个数据
console.log(arr);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
(3)数组.unshift(数据):向数组起始位置添加数据，会导致数组每一项的下标向后移动
var arr=[1,2,3];
console.log(arr);//[1, 2, 3]
arr.unshift(0);
console.log(arr);//[0, 1, 2, 3]
arr.unshift(-2,-1);
console.log(arr);//[-2, -1, 0, 1, 2, 3]
(4)数组.splice(下标,0,添加的数据)：从指定下标位置开始，删除0个，然后在该位置插入添加的数据，如果下标超过范围，则按照范围的边界进行处理
var arr=[1,2,3];
arr.splice(1,0,'abc','def');
console.log(arr);// [1, 'abc', 'def', 2, 3]
删除数组项
(1)delete 数组[下标]:这种做法不会导致数组其他的属性发生变化，因此，该做法会导致产生稀松数组，所以不推荐使用该做法.
var arr=[1,2,3];
delete arr[1];
console.log(arr);// [1, empty, 3]
(2)数组.pop()：删除数组的最后一项，该表达式返回最后一项的数据
var arr=[1,2,3];
let a=arr.pop()
console.log(arr);// [1, 2]
console.log(a);// 3
(3)数组.shift()：删除数组的第一项，该表达式返回第一项的数据
var arr=[1,2,3];
let a=arr.shift()
console.log(arr);// [2, 3]
console.log(a);//1
(4)数组.splice(下标，删除的数量，添加的数据):从指定下标位置开始，删除指定数量的数据，然后在该位置插入添加的数据，如果下标超过范围，则按照范围的边界进行处理，返回一个新数组，该数组记录被删除的数据
var arr=[1,2,3];
let a=arr.splice(1,1,'abc')
console.log(arr);//[1, 'abc', 3]
console.log(a);//[2] 被删除的元素组成的数组
其他操作
- 数组.slice(起始位置下标，结束位置下标)：将起始位置到结束位置之间的数据拿出来，得到一个新的数组，该函数不会改变原数组，注意：结束下标取不到
下标可以取负数，如果是负数，则从数组的末尾开始计算。
如果不写结束下标，则直接取到末尾.
var arr=[1,2,3,4,5,6,7,8];
var a=arr.slice(1);
console.log(arr);//[1, 2, 3, 4, 5, 6, 7, 8]
console.log(a);//[ 2, 3, 4, 5, 6, 7, 8]
- 数组清空
(1)数组.splice(0,数组.length)
var arr=[1,2,3,4,5,6,7,8];
arr.splice(0,arr.length)
console.log(arr);//[]
(2)数组.length=0
var arr=[1,2,3,4,5,6,7,8];
arr.length=0
console.log(arr);//[]
- 查找数组中某一项的下标
(1)数组.indexOf(数据)
从数组中依次查找对应的数据，查找时使用严格相等进行比较，找到第一个匹配的下标返回,如果没有找到则返回-1
var arr=[1,2,3,4,5,6,7,8];
var index=arr.indexOf(7);//从数组里面找7这个数据的下标，把找到的第一个下标返回
console.log(index);//6
var index1=arr.indexOf(9);//从数组里面找9这个数据的下标，把找到的第一个下标返回
console.log(index1);//-1
(2)数组.lastIndexOf(数据)
功能和indexOf类似，只是查找的是最后一个匹配的下标
var arr=[3,1,2,3,4,5,3,6,7,8];
var index=arr.lastIndexOf(3);//从数组里面找3这个数据的下标，把找到的最后一个下标返回
console.log(index);//6
语法补充
in关键字
判断某个属性在对象中是否存在
属性名 in 对象
var arr=[1,3,4,5,6,7,23];
console.log(arr);//arr 默认隐含的属性名为 0，1，2，3，4，5，6依次递增
console.log(3 in arr);//true 这里判断的是属性名 3有没有在数组arr中，而不是值
for-in 循环
for(var prop in 对象){
循环体
}
取出对象的所有属性名，每次循环将其中一个属性名赋值给变量prop,运行循环体
// for-in遍历对象
var obj={
name:'zhangsna',
age:18,
sex:'male'
}
for(let prop in obj){
console.log(prop);//name,age,sex
}
// for-in遍历数组
var arr=[1,3,4,5,6,7,23];
for(var p in arr){
console.log(p,typeof p);//0,1,2,3,4,5,6 string
}
数组应用
数组的本质:对象(引用类型)
案例1
var arr1=[1,3,4,5,6,7,23];//arr1中存放的是地址
var arr2=arr1;//arr2中存放的是和arr1中一样的地址,他们指向同一个对象
arr2[0]=5;
console.log(arr1[0]);//5 5
案例2:如何复制一个数组
// 案例2:如何复制(克隆:产生一个全新的对象，新对象里面的数据和之前的对象的数据一模一样，但并不是之前的对象)一个数组
var arr1=[1,2,3,4,5,6,7];
var arr2=[];
// 方法1
// for(let i=0;i<arr1.length;i++){
// arr2[i]=arr1[i]
// }
// 方法2
// arr2=arr1.map(item=>{
// return item
// })
// 方法3
// arr1.forEach(item=>{
// arr2.push(item)
// })
// 方法4
// for(let prop in arr1){
// arr2[prop]=arr1[prop]
// }
// 方法5
// arr2=[...arr1];
// 方法6
// arr2=[].concat(arr1)
// 方法7
arr2=arr1.slice(0);//这里的0可写可不写 slice方法把原来的数组截取一段，产生一个新的数组并返回 不传参数的话表示截取整个数组 只传一个0也表示从下标为0开始截取 截取到数组的末尾
案例3:对数组求和
// 对数组求和
var arr1=[1,2,3,4,5,6,7];
var sum=0;//记录和
// 方法1
// for(let i=0;i<arr1.length;i++){
// sum+=arr1[i]
// }
// 方法2
// arr1.forEach(item=>{
// sum+=item
// })
// 方法3
// arr1.map(item=>{
// sum+=item
// })
// // 方法4
// arr1.some(item=>{
// sum+=item
// })
// 方法5
arr1.filter(item=>{
sum+=item
})
console.log(sum);//28
案例4:对二维数组进行求和
var arr = [
[1, 2, 34],
[345, 1, 1],
[44, 4, 7]
];
var sum=0;
// 对二维数组进行求和
for(let i=0;i<arr.length;i++){
// console.log(arr[i]);
for(let j=0;j<arr[i].length;j++){
console.log(arr[i][j]);
sum+=arr[i][j]
}
}
console.log(sum);//439
案例5:将数组的每一项进行字符串拼接
var arr=[1,2,3,4,5,6,7,8,9];
// 输出：1,2,3,4,5,6,7,8,9
var str='';
// 方法1(推荐)
// str=arr.join();
// 方法2
// for(let i=0;i<arr.length;i++){
// str+=arr[i]+','
// }
// str=str.slice(0,str.length-1)//截取末尾的逗号
// 方法3
// for(let i=0;i<arr.length;i++){
// str+=arr[i];
// if(i<arr.length-1){
// str+=','
// }
// }
console.log(str,'str');
案例6:拼接数组
var arr1=[1,2,3,4,5,6,7,8,9];
var arr2=['abc','def','ghi'];
//将数组2拼接到数组1的末尾，产生一个新数组，该表达式不会对原数组造成任何影响
// 方法1
var newArr=arr1.concat(arr2);//concat方法 不会改变原数组
// 方法2
// var newArr=[...arr1,...arr2];
// 方法3
// var newArr=[];
// for(let i=0;i<arr1.length;i++){
// newArr.push(arr1[i])
// }
// for(let i=0;i<arr2.length;i++){
// newArr.push(arr2[i])
// }
console.log(newArr);
练习题
- 提示用户输入数组的长度，以及数组每一项的值，然后输出该数组
// 提示用户输入数组的长度，以及数组每一项的值，然后输出该数组
// 方法1
var arr=[];
var length=+prompt('请输入数组的长度');
var i=0;
// 判断边界条件
if(isNaN(length) ||length<0){
console.log('输入有误，请重新输入')
}
while(i<length){
var item=prompt('请输入数组项');
arr.push(item)
i++;
if(item===null) {//点击了取消 或者没有输入任何内容
break;
}
}
console.log(arr,arr.length,'arr');
// 方法2
var arr=[];
let length=+prompt('请输入数组的长度');
if(isNaN(length)||length<0){
console.log('输入的数据有误，请重新输入');
}else{
//输入正确
// 循环，让用户输入数组每一项对应的值
for(let i=0,len=length;i<len;i++){
arr[i]=prompt(`请输入数组的第${i+1}项`)
}
console.log(arr);
}
- 初始化一个数字数组，然后求该数组所有项之和
var arr1=[1,2,3,4,5,6,7];
var sum=0;//记录和
// 方法1
// for(let i=0;i<arr1.length;i++){
// sum+=arr1[i]
// }
// 方法2
// arr1.forEach(item=>{
// sum+=item
// })
// 方法3
// arr1.map(item=>{
// sum+=item
// })
// // 方法4
// arr1.some(item=>{
// sum+=item
// })
// 方法5
arr1.filter(item=>{
sum+=item
})
console.log(sum);//28
- 初始化一个数字数组，然后输出数组中所有的奇数
// 初始化一个数字数组，然后输出数组中所有的奇数
var arr=[1,2,3,4,5,6,7,8,9,10];
for(let i=0;i<arr.length;i++){
if(arr[i]%2!=0){
console.log(arr[i]);
}
}
- 初始化一个数字数组，然后输出数组中所有的素数
// // 初始化一个数字数组，然后输出数组中所有的素数
var arr=[1,2,3,4,5,6,7,8,9,10];
for(var index in arr){
// 判断arr[index]是不是一个素数
let count=0;
for(let i=2;i<arr[index];i++){
if(arr[index]%i==0){
// 不是素数
count++
// console.log('不是素数');
}
}
if(count<=0&&arr[index]>1){
console.log(arr[index],'是素数');
}
}
- 斐波拉契数列是这样一种数列：1 1 2 3 5 8 13 ......
数列前两位为1，第n位=第n-1位+第n-2位
让用户输入斐波拉契数列的长度，在控制台中打印该长度的斐波拉契数列
let n=+prompt('请输入斐波拉契数列的长度');
if(isNaN(n)||n<0){
console.log('输入的数据有误，请重新输入');
}else{
var arr=[];
for(let i=0;i<n;i++){
if(i==0||i==1){
arr[i]=1
}else{
arr[i]=arr[i-1]+arr[i-2]
}
}
console.log(arr);
}
>递归函数实现斐波那契额数列
function fib(n){
if(n==1 || n==2){
return 1;
}
return fib(n-1) + fib(n-2);
}
- 定义一个用户数组，数组的每一项是一个用户对象，用户对象中包含账号和密码，随意初始化一些对象放入数组中。然后提示用户输入账号和密码，判断是否登录成功
let users=[{
account:'test1',
password:'password2'
},
{
account:'test2',
password:123456
},
{
account:'test3',
password:'password3'
},
{
account:'test4',
password:'password4'
},
{
account:'test5',
password:'password5'
},
]
let userAccount=prompt('请输入账号');
let userPassword=prompt('请输入密码');
if(userAccount===null||userPassword===null){
console.log('账号或者密码不能为空，请重新输入');
}
var isLogin=false;
for(let i=0;i<users.length;i++){
if(users[i].account==userAccount&&users[i].password==userPassword){
isLogin=true;
break;
}else{
isLogin=false
}
}
if(isLogin){
console.log('登陆成功');
}else{
console.log('登陆失败');
}
- 初始化一个5*5的二维数组，数组每一项是一个数字，计算对角线之和
// 初始化一个5*5的二维数组，数组每一项是一个数字，计算对角线之和
let arr=[
[1,2,3,4,5],
[6,7,8,9,0],
[1,3,5,7,9],
[2,4,6,8,10],
[1,2,3,1,3],
];
// console.log(arr.length);//5
//便利第一层数组
var sum=0;
for(let i=0;i<arr.length;i++){
for(let j=0;j<arr.length;j++){
if(i==j||i+j==arr.length-1){
sum+=arr[i][j]
}
}
}
console.log(sum);
- 初始化一个数字数组（数据随意），对该数组进行升序排序，然后输出结果
思路提示：
数组的排序有多种算法可以完成，这里介绍其中一种：冒泡排序算法
冒泡排序算法的原理如下：
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
- 针对所有的元素重复以上的步骤，除了已排好序的元素。
// 方法1 sort实现升序排列
var arr=[1,2,3,4,5,6,7,7,7,4,3,2,3,3,3]
function sortArr(arr){
return arr.sort((a,b)=>{
return a-b
})
}
console.log(sortArr(arr));
// 方法2 冒泡排序实现
var arr = [2,23,44,5,8,1];
/*
第1次：排了5次，比较的位置从0~5
2,23,44,5,8,1
2,23,5,44,8,1
2,23,5,8,44,1
2,23,5,8,1,44
*/
/*
第2次：排了4次，比较的位置从0~4
2,23,5,8,1,44
2,5,23,8,1,44
2,5,8,23,1,44
2,5,8,1,23,44
*/
/*
第3次：排了3次，比较的位置从0~3
2,5,8,1,23,44
2,5,1,8,23,44
*/
/*
第4次：排了2次，比较的位置从0~2
2,5,1,8,23,44
2,1,5,8,23,44
*/
/*
第5次：排了1次，比较的位置从0~1
1,2,5,8,23,44
*/
for(let i=0;i<arr.length;i++){
//排了多少次
for(let j=0;j<arr.length-i;j++){
// 比较大小 前面的比后面的打的话 就交换位置
if(arr[j]>arr[j+1]){
let temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
console.log(arr);
- 有一个数组，存放了一些数字，找出出现频率最高的数字
// 有一个数组，存放了一些数字，找出出现频率最高的数字
let arr=[1,2,3,2,2,2,3,4,5,6,7,8,9,0]
let res={};
let max=0,maxEl;
for(let i=0;i<arr.length;i++){
if(!res[arr[i]]){//对象不存在该属性
res[arr[i]]=1
}else{
// 存在属性，对应的值加1
res[arr[i]]++
}
// 寻找出现次数最多的key
for(let prop in res){
if(res[prop]>max){
max=res[prop];
maxEl=prop;
}
}
}
console.log(`出现次数最多的元素为${maxEl},出现次数为${max}`);
10.初始化一个数字数组，求最大值
let arr=[1,2,3,2,2,3,4,5,6,7,8,9,0]
let max=0;
for(let i=0;i<arr.length;i++){
if(arr[i]>max){
//max重新赋值
max=arr[i]
}
}
console.log(max);
