数组的基础结构
数组也是对象数据类型的 typeof [] ->'object'
数组也有属性名,只不过属性名是数字,我们把数字属性名称之为它的索引:数组是以数字作为索引,索引从零开始,有一个length属性代表数组的长度
类数组:类似于数组,但是不是数组
1、通过getElementsByTagName获取的元素集合是类数组
2、函数中的实参集合arguments也是类数组
…
循环数组中的每一项
Array.prototype.aa =
100;
for (
var i =
0; i < ary.length; i++) {
console.log(ary[i]);
}
for (
var key
in ary) {
console.log(ary[key]);
}
数组中的常用方法
数组中有很多常用方法 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(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() 什么都没有拼接,相当于把原有数组克隆一份一模一样的新数组出来
*/
把数组转换为字符串的
* 1、toString:实现把数组转化为字符串(转换后的字符串以逗号分隔每一项)
* 参数:无
* 返回值:转换的字符串
* 原有数组不变
*/
* 2、join:把数组按照指定的分隔符转换为字符串,和字符串中的split相对应
* 参数:指定的链接符
* 返回值:转换后的字符串
* 原有数组不变
*/
var total=
null;
for(
var i=
0;i<ary.length;i++){
total+=ary[i];
}
var total =
eval(ary.join(
'+'));
实现数组中每一项的排序和排列
* 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){
}
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)
遍历数组中每一项的方法
* forEach:遍历数组中的每一项
*/
ary.forEach(
function(value,index){
});
* map:遍历数组中的每一项,在forEach的基础上,可以修改每一项的值
*/
ary.map(
function(value,index){
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];
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);
}
}
}
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--;
}
}
}
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;
}
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[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;
}));