JavaScript中的数组基础精讲

作者:日期:2017-11-23 17:15:50 点击:221

珠峰JavaScript免费课视频下载地址:https://pan.baidu.com/s/1eRV4C2Q

数组的基础结构

数组也是对象数据类型的 typeof [] ->'object'

数组也有属性名,只不过属性名是数字,我们把数字属性名称之为它的索引:数组是以数字作为索引,索引从零开始,有一个length属性代表数组的长度

Alt text

类数组:类似于数组,但是不是数组
1、通过getElementsByTagName获取的元素集合是类数组
2、函数中的实参集合arguments也是类数组

Alt text

Alt text

循环数组中的每一项

Array.prototype.aa = 100;
 
//=>FOR循环操作
for (var i = 0; i < ary.length; i++) {
console.log(ary[i]);
}
 
//=>FOR IN循环操作
for (var key in ary) {
//key:属性名(数组中的属性名是索引)
console.log(ary[key]);
}
 
//=>FOR循环只能遍历到数组私有的一些属性,而FOR IN循环可以把一些自定义的公共属性也能遍历到

数组中的常用方法

数组中有很多常用方法 console.dir(Array.prototype)

1、方法的意义和作用
2、方法的形参
3、方法的返回值
4、通过此方法,原来的数组是否发生了改变

实现数组的增加、修改、删除

var ary = [12,23,34];
 
//=>增加
/*
* 1、push:向数组的末尾追加新内容
* 参数:一到多个,任何数据类型都可以,想要给数组末尾追加什么,直接传递到push方法中即可,传递多个用逗号隔开
* 返回值:新增后数组的长度
* 原有数组改变了
*/
 
/*
* 2、unshift:向数组开头追加新内容
* 参数:需要追加的内容(可以是多个任何数据类型的值)
* 返回值:新增后数组的长度
* 原来数组改变了
*/
 
/*
* 3、把数组当做一个普通的对象,使用对象键值对的操作,给其设置新的属性(索引)
* ary[ary.length]=xxx 向数组的末尾追加了新的内容
*/
 
//=>删除
/*
* 1、pop:删除数组最后一项
* 参数:无
* 返回值:被删除的那一项内容
* 原有数组改变了
*/
 
/*
* 2、shift:删除数组第一项
* 参数:无
* 返回值:被删除那一项的内容
* 原有数组改变了
* 使用shift删除第一项之后,后面每一项的索引都要向前进一位(导致后面项的索引发生改变)
*/
 
/*
* 3、把数组当做普通的对象操作
* delete删除:`delete ary[索引]`删除指定索引这一项(当前项被删除后,原有数组其它项的索引不会改变;当前数组的length也不会改变;)
*
* ary.length--:删除数组最后一项
*/
 
//=>splice:数组中内置的方法,可以实现数组的增加、修改、删除
/*
* splice实现删除
* splice(n,m):从索引n开始删除m个(m不写是删除到数组的末尾)
* 返回值:被删除的内容(以一个新数组保存)
* 原有数组改变了
* -> splice(0) 清空数组
* -> splice() 一项都不删除,返回一个新的空数组
* -> splice(0,1) 删除第一项
* -> splice(ary.length-1) 删除最后一项
*
* splice实现修改
* splice(n,m,x):在原有删除的基础上,用x代替删除的内容
*
* splice实现增加
* splice(n,0,x):在修改的基础上,我们一项都不删除,把x插入到索引n的前面
* -> ary.splice(0,0,x) 向数组开头追加新的内容
* -> ary.splice(ary.length,0,x) 向数组末尾追加新元素
*/

数组的查询

/*
* slice:数组的查询
* 参数:slice(n,m) 从索引n开始找到索引为m处(不包含m)
* 返回值:把找到的部分以一个新数组返回
* 原来的数组不变
*
* -> slice(n) 从索引n开始找到末尾
* -> slice(0) / slice() 数组克隆,克隆一份和原来数组一模一样的新数组
* -> slice支持负数索引,如果传递的索引为负数,浏览器解析的时候是按照 总长度+负数索引 来处理的
* ...
*/

将两个数组进行拼接

/*
* concat:将多个数组拼接在一起
* 参数:要拼接的内容(把内容放在原数组的后面),可以是一个数组,也可以是一些数据值
* 返回:拼接后的新数组
* 原有数组不变
*
* -> concat() 什么都没有拼接,相当于把原有数组克隆一份一模一样的新数组出来
*/

Alt text

把数组转换为字符串的

/*
* 1、toString:实现把数组转化为字符串(转换后的字符串以逗号分隔每一项)
* 参数:无
* 返回值:转换的字符串
* 原有数组不变
*/
 
/*
* 2、join:把数组按照指定的分隔符转换为字符串,和字符串中的split相对应
* 参数:指定的链接符
* 返回值:转换后的字符串
* 原有数组不变
*/

Alt text

//=>已知数组中的每一项都是数字,想实现数组求和,我们如何实现?
//1、循环实现
var total=null;
for(var i=0;i<ary.length;i++){
total+=ary[i];
}
 
//2、利用join
var total = eval(ary.join('+')); //->evel:把字符串变为JS表达式执行

实现数组中每一项的排序和排列

/*
* 1、reverse:把数组中的每一项倒过来排列
* 参数:无
* 返回值:排序后的数组
* 原有数组改变
*/
 
/*
* 2、sort:实现数组的排序
* 参数:无或者回调函数
* 返回值:排序后的数组
* 原有数组改变
*
* 不传递参数的情况下:可以给10以内的数字进行升序排列,但是超过10的就无法处理了(多位数只识别第一位)
*
* ary.sort(function(a,b){
* return a-b; //->升序
* return b-a; //->降序
* });
*/

验证数组中是否包含某一项

/*
* indexOf / lastIndexOf:获取当前项在数组中第一次或者最后一次出现位置的索引
* 数组中的这两个方法在IE6~8下不兼容
* 字符串中的这两个方法兼容所有的浏览器
*
* 如果当前数组中并没有这一项,返回的索引是-1,我们根据这一点可以验证数组中是否包含这一项
*/
if(ary.indexOf(12)>-1){
//->数组中包含12
}
 
Array.prototype.myIndexOf = function myIndexOf(value){
var result = -1;
for(var i=0;i<this.length;i++){
if(value===this[i]){
result = i;
break;
}
}
return result;
}
ary.myIndexOf(12)

遍历数组中每一项的方法

//=>以下方法在IE6~8下都不兼容
 
/*
* forEach:遍历数组中的每一项
*/
ary.forEach(function(value,index){
//=>数组中有多少项,当前回调函数执行多少次;每一次传递进来的value就是当前遍历数组这一项的值,index就是遍历这一项的索引
});
 
/*
* map:遍历数组中的每一项,在forEach的基础上,可以修改每一项的值
*/
ary.map(function(value,index){
//=>数组中有多少项,当前回调函数执行多少次;每一次传递进来的value就是当前遍历数组这一项的值,index就是遍历这一项的索引
return xxx; //=>RETURN后面返回的结果就是把当前遍历的这一项修改为xxx
});
 
filter
find
reduce
every
...
 

数组去重

方案一:
遍历数组中的每一项,拿每一项和它后面的项依次比较,如果相同了,则把相同的这一项在原来数组中删除即可

var ary = [1, 2, 2, 2, 3, 2, 1, 2, 3, 2, 2, 3, 4, 3, 2, 2, 3];
 
//=>ARY.LENGTH-1:最后一项的后面没有内容了,我们不需要再比较
for (var i = 0; i < ary.length - 1; i++) {
var cur = ary[i];//=>当前遍历的这一项(索引i)
 
//=>把拿出的这一项和后面的每一项进行比较
//->i+1:把当前项和它后面项比较,当前项索引是i,后一项索引是i+1
for (var j = i + 1; j < ary.length; j++) {
//ary[j]:作比较的那一项
if (cur === ary[j]) {
//=>本次作比较的这一项和当前项相同,我们需要在原有数组中把作比较的这一项删除掉(作比较这一项的索引是j)
ary.splice(j, 1);
}
}
}
console.log(ary);

数组塌陷问题:我们使用splice删除数组中的某一项后,删除这一项后面的每一项索引都要向前进一位(在原有索引上减一),此时如果我们j++,循环操作的值累加了,我们通过最新j获取的元素不是紧挨删除这一项的元素,而是跳过一项获取的元素

for (var i = 0; i < ary.length - 1; i++) {
var cur = ary[i];
for (var j = i + 1; j < ary.length; j++) {
if (cur === ary[j]) {
ary.splice(j, 1);
j--;//=>先让j--,然后再j++,相当于没加没减,此时j还是原有索引,再获取的时候就是删除这一项后面紧挨着的这一项
}
}
}
for (var i = 0; i < ary.length - 1; i++) {
var cur = ary[i];
for (var j = i + 1; j < ary.length;) {
cur === ary[j] ? ary.splice(j, 1) : j++;
}
}

方案二:
利用indexOf来验证当前数组中是否包含某一项,包含把当前项删除掉(不兼容IE6~8)

var ary = [1, 2, 2, 2, 3, 2, 1, 2, 3, 2, 2, 3, 4, 3, 2, 2, 3];
for (var i = 0; i < ary.length; i++) {
var cur = ary[i];//=>当前项
var curNextAry = ary.slice(i + 1);//=>把当前项后面的那些值以一个新数组返回,我们需要比较的就是后面的这些项对应的新数组
if (curNextAry.indexOf(cur) > -1) {
//=>后面项组成的数组中包含当前这一项(当前这一项是重复的),我们把当前这一项删除掉即可
ary.splice(i, 1);
i--;
}
}
console.log(ary);

方案三:
遍历数组中的每一项,把每一项作为新对象的属性名和属性值存储起来,例如:当前项1 ,对象中存储的 {1:1}

在每一次向对象中存储之前,首先看一下原有对象中是否包含了这个属性(typeof obj[xxx]==='undefined' 说明当前对象中没有xxx这个属性),如果已经存在这个属性说明数组中的当前项是重复的(1-在原有数组中删除这一项 2-不再向对象中存储这个结果),如果不存在(把当前项作为对象的属性名和属性值存储进去即可)

var ary = [1, 2, 2, 2, 3, 2, 1, 2, 3, 2, 2, 3, 4, 3, 2, 2, 3];
var obj = {};
for (var i = 0; i < ary.length; i++) {
var cur = ary[i];
if (typeof obj[cur] !== 'undefined') {
//=>对象中已经存在该属性:证明当前项是数组中的重复项
ary.splice(i, 1);
i--;
continue;
}
obj[cur] = cur;//=>obj[1]=1 {1:1} 存储
}
var ary = [1, 2, 2, 2, 3, 2, 1, 2, 3, 2, 2, 3, 4, 3, 2, 2, 3];
var obj = {};
for (var i = 0; i < ary.length; i++) {
var cur = ary[i];
if (typeof obj[cur] !== 'undefined') {
//ary.splice(i, 1);//=>使用splice会导致后面的索引向前进一位,如果后面有很多项,消耗的性能很大
//=>思路:我们把最后一项拿过来替换当前要删除的这一项,然后再把最后一项删除
ary[i] = ary[ary.length - 1];
ary.length--;
i--;
continue;
}
obj[cur] = cur;
}
Array.prototype.myUnique = function myUnique() {
var obj = {};
for (var i = 0; i < this.length; i++) {
var item = this[i];
if (typeof obj[item] !== 'undefined') {
this[i] = this[this.length - 1];
this.length--;
i--;
continue;
}
obj[item] = item;
}
obj = null;
return this;
};
 
var ary = [12, 23, 13, 23, 12, 12, 12, 13, 23, 2, 31, 14];
console.log(ary.myUnique().sort(function (a, b) {
return a - b;
}));

扩展思路:
首先给数组进行排序,然后相邻两项比较,相同的话,把后一项在数组中去掉 =>相邻比较法

上一篇: JavaScript字符串中常用的方法

下一篇: 关于JS中面向对象的理解