5.21array学习
* 11.数组
* 12.关联(hash)数组
* 13.数组API
* 14.二维数组
数组
多个变量的集合，起一个统一的名字——用法
连续保存多个数据的引用类型的对象——存储
为什么使用数组：
程序=数据结构+算法
好的数据结构可以极大提高程序的执行效率！
何时使用：程序中都是用数组集中管理多个数据
创建： 5种
- var arr=[]; 创建空数组
- var arr=[值1,值2,...]; 创建同时初始化数组元素
- var arr=new Array(); 创建空数组
- var arr=new Array(n); 创建n个空元素的数组
- var arr=new Array(值1,值2,...);创建同时初始化数组元素
数组是引用类型对象：按值传递
原始类型的值，赋值后，相互不影响
引用类型的对象，赋值后，依然引用同一个对象
任何修改，都会影响对方。
null：主动释放一个对象
建议：使用完较大的对象后，都要主动释放
var arr = [1,2,3];
var arr1 = arr;
console.log(arr); //1 2 3
console.log(arr1); //1 2 3
//由于数组是引用类型对象 所以改变任意一个 都会使元数组发生改变
arr[0] = 10;
console.log(arr); //10 2 3
console.log(arr1); //10 2 3
/*arr1[0] = 100 ;
console.log(arr); //100 2 3
console.log(arr1); */ //100 2 3
console.log(null == undefined); //true
console.log(null === undefined); //false null和undefined 类型是不一样的
/**
* undefined 是从null里衍生出来的 null是给程序员用的
*/
//length属性 数组中的遍历用的比较多
/**数组的length属性固定套路：2个
1. 获得最后一个元素值: arr[arr.length-1]
2. 向数组末尾追加一个新元素：arr[arr.length]=新值;
*
* 遍历数组: 依次对数组中每个元素执行相同操作
//三要素：
1. 条件: 下标i<数组长度
2. 变量: 下标i 从0开始，每次++
for(var i=0;i<arr.length;i++){
当前元素：arr[i]
}
*/
var arr2 = [1,2,3,,1,2];
var sum = 0;
for(var i=0;i<arr2.length;i++){
if(arr2[i]===undefined){
continue;
}
sum += arr2[i];
}
console.log(sum);
关联（hash）数组
如何创建
1种：
- 先创建空数组: var arr=[];
- 再向数组中添加元素: arr[key]=value;
强调：key必须是字符串
length属性无效！
使用：arr[key]
关联数组优点：快速精确查找！不需要遍历！和数据量无关！
如何遍历hash数组：
for(var key in hashArr){//反复取出每个key放入变量key中
key中获取的仅是元素的下标名称
当前元素的值: hashArr[key]
}
var hash = [];
hash['a'] = '鹿晗';
hash['b'] = '李晨';
hash['c'] = 'baby';
console.log(hash.length); //length属性无效
for (var key in hash){
console.log(key+':'+hash[key]);
}
数组API
- 数组 to 字符串
var str=arr.toString(); 返回数组中元素的内容，用逗号分隔
var str=arr.join("连接符"); 可自定义连接符
var str = [1,2,3,4,5];
console.log(str.toString());
console.log(str.join('=='));
var joins = ['h','e','l','l','o'];
console.log(joins.join(''));
2.拼接数组：concat
var newArr=arr1.concat(arr2,值1,值2,......)
强调：concat不修改原数组，总是返回一个新数组
var arrCon = [1,2,3];
var arrCon1 = [7,8,9];
var arrCon2 = arrCon.concat(4,5,6,arrCon1); //concat不修改原数组所以需要用变量接住
console.log(arrCon2);
3.获取子数组：slice
var subArr=arr.slice(starti,endi+1);
starti: 开始位置的下标
endi: 结束位置的下标,含头不含尾
slice支持负数参数，如果参数为负，则自动用length-参数
var arrSlice = [1,2,3,7,8,9];
var arrSlice1 = arrSlice.slice(1,3);
var arrSlice2 = arrSlice.slice(-3,-1);
console.log(arrSlice1); // 2 3
console.log(arrSlice2); // 7 8
4.splice: 删除 插入 替换 --> 直接修改原数组对象
-
删除: arr.splice(starti,n)
从starti位置开始，删除n个元素 -
插入: arr.splice(starti,0,新值1,新值2,......)
在starti位置插入新值1,新值2,......
原starti位置及其之后的元素，被向后顺移 -
替换: arr.splice(starti,n,新值1,新值2,......)
新元素的个数和n不一定相等
数组会自动调整元素的位置和长度
//删除
var arrSplice = [1,2,3,4,5];
var deletes = arrSplice.splice(0,2);
console.log(arrSplice); //3 4 5
console.log(deletes); //1 2
//插入
arrSplice.splice(1,0,1,1,1);
console.log(arrSplice); // 3 1 1 1 4 5
//替换
arrSplice.splice(1,3,0,0,0);
console.log(arrSplice); // 3 0 0 0 4 5
/**
* 5.颠倒数组中所有元素的位置：arr.reverse();
*/
var arrReverse = [1,2,3];
arrReverse.reverse();
console.log(arrReverse); //3 2 1
/**
* 6.数组的sort方法
* sort方法：默认将每个元素转为字符串，再按升序排列
* 1. 定义比较器函数：专门比较任意两值大小的函数
规定：两个参数（a , b），
必须返回数字：如果a>b，就要返回正数
如果a<b，就要返回负数
如果a=b，就要返回0
2. 将比较器函数对象作为参数传入sort方法中
*/
var arrSort = [3,5,1,4,9,6];
function compare(a,b){
if(a > b){
return 1;
}else if(a == b){
return 0;
}else{
return -1;
}
}
arrSort.sort(compare);
console.log(arrSort); //1 3 4 5 6 9
/**
* 7.栈和队列
* 结尾出入栈：
入栈: arr.push(新值); ==>arr[arr.length]=新值;
出栈: var last=arr.pop();
无论出入栈都不影响已有元素的位置——效率高
* 开头出入栈：
入栈: arr.unshift(新值);
出栈: var first=arr.shift()
每次出入栈都会影响所有剩余元素的位置发生顺移——低
* 队列：只能从一端进入，必须从另一端出
何时使用：只要先到的先得
FIFO：
结尾入队列：arr.push(新值);
开头出队列：var first=arr.shift();
*/
//结尾出入栈
var arrPush = [1,2,3];
arrPush.push(4);
console.log(arrPush); // 1 2 3 4
arrPush.pop();
console.log(arrPush); // 1 2 3
//开头出入栈
var arrUnshi = [1,2,3];
arrUnshi.unshift(0);
console.log(arrUnshi); // 0 1 2 3
arrUnshi.shift();
console.log(arrUnshi); // 1 2 3
//队列
var queue = [1,2,3];
queue.push(4);
queue.shift();
console.log(queue); // 2 3 4
冒泡排序
var examplearr=[8,94,15,88,55,76,21,39];
function sortarr(arr){
for(var i=0;i<arr.length-1;i++){
for(var j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
var temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr;
}
sortarr(examplearr);
console.log(examplearr);
在以后的笔试当中可能需要我们手写冒泡排序
二维数组
数组的元素又引用了另一个子数组
何时使用：保存横行竖列的二维数据
保存上下级关系的数据
如何创建：2步：
- 创建一个空数组：var data=[];
- 设置数组中每个元素再引用另一个小数组
data[0]=[0,0,0,0];
访问二维数组中任意位置的元素：data[r][c]
***二维数组行下标r不能越界，越界就报错
遍历二维数组：固定套路：
外层循环遍历行，内层循环遍历当前行的中的列
for(var r=0;r<data.length;r++){
for(var c=0;c<data[r].length;c++){
当前元素：data[r][c]
}
}
var twoArr = [[1,2],[3,4],[5,6]];
console.log(twoArr[0][0]); //1
console.log(twoArr[0][1]); //2
console.log(twoArr[1][1]); //4
//遍历
for(var r=0;r<twoArr.length;r++){
for(var c=0;c<twoArr[r].length;c++){
console.log(twoArr[r][c]);
}
}
网友评论