创建数组
- 创建字面量数组：var arr=[]
var arr=[1,5,2,"a",5];
-
创建数组对象：var arr=new Array();
-
参数仅有1个，且这个参数是正整数，则表示新建一个具备该正整数长度的空数组，里面有这个长度的若干空元素。
var arr=new Array{10}; //则表示创建了10个空数组 -
如果是负数或者小数时，则报错。
var arr2=new Array(3.5); -
如果输入的不是数值，是其他类型时，这个数据就会作为该数组的第0个元素，长度为1
-
-
根据对象创建数组：var arr=new Object([])
var arr2=new Array("a");console.log(arr2[0]);//返回a
数组下标
元素和下标
-
下标（索引）：数组和对象一样都是引用数据类型数组中的数据按照顺序排列，从0开始，把这个叫做索引，也叫做下标。
-
元素：把数组中的每个数据叫做元素，或者简称元。
访问元素使用中括号进行访问：数组名[下标]=元素；
var arr=[2,"a",4,10]; //访问数组元素2 console.log(arr[0]);//返回2 //访问数组元素a console.log(arr[1]);//返回a
数组的属性
-
length 设置或返回数组中元素的数目。
var arr=[1,2,3,4,5]; console.log(arr.length);//返回5 -
length 修改数组长度
如果设置为0，表示清空数组
如果设置为3，表示保留到第三位
-
修改数组内容
var arr=[1,2,3,4,5]; arr[arr.length-1]=20; console.log(arr[4]);//返回20 -
添加元素
var arr=[1,2,3,4,5]; arr[arr.length]=4; console.log(arr);//返回[1,2,3,4,5,4]
遍历数组
-
常见于循环中对数组的遍历,比如:for(var i=0;i<arr.length;i++){执行部分}
var arr = [5, 2, 7, , 4, 9, 6]; for (var i = 0; i < arr.length; i++) { console.log(arr[i]); //返回[5, 2, 7, , 4, 9, 6]; }
数组的方法
concat()
-
解释：数组的合并，合并后会返回一个新数组，原来的两个数组不会变化。
-
示例：
//合并两个数组 var arr=[1,2,3,4]; var arr1=[5,6,7,8]; var arr2=arr.concat(arr1); console.log(arr2); //返回数组arr2[1,2,3,4,5,6,7,8] //数组除了可以合并数组，也可以合并元素，将多个元素与原数组合并，返回新数组 var arr3=arr.concat(0,-1,-2); console.log(arr3); //返回数组arr2[1,2,3,4,0,-1,-2] //既可以合并元素，也可以合并数组 var arr4=arr.concat(0,arr1,["A","B"]); console.log(arr4); //返回数组arr4[1,2,3,4,0,5,6,7,8,"A","B"]； //如果直接使用concat，就可以完成数组的复制功能 var arr5=arr.concat(); console.log(arr5===arr);//返回false
join()
-
解释：将数组的每个元素以指定的字符连接形成新字符串返回。
-
示例：
var arr=[1,2,3,4,5]; //将数组合并为字符串返回，默认使用逗号连接 var str=arr.join(); console.log(str);//返回1,2,3,4,5 //在这里join的参数是字符串的连接符 var str=arr.join("|"); console.log(str);//返回1|2|3|4|5 ""作为连接符，会将数组元素首尾相连成为字符串 var str=arr.join(""); console.log(str);//返回1 2 3 4 5 -
重构：
var arr=[1,2,3,4,5]; function joins(arr,connector){ var str=""; for(var i=0;i<arr.length;i++){ if(i===0)str=arr[i]; str+=(connector?connector:",")+arr[i]; } return str; } var a=joins(arr,"|") console.log(a);
pop()
-
解释：删除并返回数组的最后一个元素
-
示例：
var arr=[1,2,3,4,5]; //在尾部删除数组： arr.pop();//pop中没有参数,删除数组的最尾部一个元素 console.log(arr.pop());//删除并返回数组的新长度，返回4 //在尾部删除数组： arr.pop(3);//pop中参数3,删除数组的最尾部3个元素 console.log(arr.pop());//删除并返回数组的新长度，返回2 -
arr.length和arr.pop()：
arr.length–;：等同 速度更快，但是不会返回数组长度
arr.pop();：速度慢，但是会返回数组长度 -
重构：
var arr=[1,2,3,4,5]; function pops(arr,quantity){ return arr.length=arr.length-(quantity?quantity:1); } var a=pops(arr,2) console.log(a);
shift()
-
解释：删除并返回数组的第一个元素
-
示例：
var arr=[1,2,3,4,5]; //在头部删除数组： arr.pop();//pop中没有参数,删除数组的最头部一个元素 //返回数组的新长度： console.log(arr.pop());删除并返回数组的新长度，返回4 var a=arr.pop();console.log(a);//删除并返回数组的新长度，返回4 -
重构：
var arr=[1,2,3,4,5]; function shifts(arr,quantity){ for (var i = 1; i <= quantity; i++) { var len=arr.length; for (var n = 0; n < len; n++) { arr[n] = arr[n + 1]; } } arr.length = arr.length - quantity; return arr; } var a=shifts(arr,1) console.log(a);
push()
-
解释：向数组的末尾添加一个或更多元素，并返回新的长度。
-
示例：
var arr=[1,2,3,4,5]; //在数组的尾部插入新元素： arr.push("a","b"); arr.push(6); arr.push(6,7,8); //返回数组的新长度： console.log(arr.push(6,7,8));//添加并返回8 arr.push(6,7,8);console.log(arr);//返回新数组 var a=arr.push(6,7,8);console.log(a);//添加并返回8 -
重构：
var elemen=["a","ab","b"]; var arr=[1,2,3,4,5]; function pushs(arr,element){ var len=arr.length; for (var i = 0; i < element.length; i++) { arr[len+i]=element[i]; } return arr; } var a=pushs(arr,elemen) console.log(a);
unshift()
-
解释：向数组的开头添加一个或更多元素，并返回新的长度。
-
示例：
var arr=[1,2,3,4,5]; //在数组的头部插入新元素： arr.unshift(0); arr.unshift(-3,-2,-1,0); arr.unshift("a","b"); //返回数组的新长度： console.log(arr.unshift(-3,-2,-1,0););//添加并返回9 var a=arr.unshift(-3,-2,-1,0);console.log(a);//返回9 arr.unshift(-3,-2,-1,0); console.log(arr);//添加并返回新数组 -
重构：
var elemen=["a","ab","b"]; var arr=[1,2,3,4,5]; function unshifts(arr,element){ var len=arr.length+element.length; for(var i=len-1;i>=0;i--){ arr[i]=arr[i-element.length]; } for(var n=0;n<element.length;n++){ arr[n]=element[n]; } return arr; } var a=unshifts(arr,elemen) console.log(a);
slice()
-
解释：按指定位置截取复制数组的内容,返回被截取的内容，原数组不变。
-
示例：
var arr=[1,2,3,4,,5,6,7]; //从第1位开始截取到第4位之前 var arr1=arr.slice(1,4); console.log(arr1);//[2, 3, 4] console.log(arr); //[1, 2, 3, 4, empty, 5, 6, 7] //第二个参数不写，默认截取到尾部 var arr1=arr.slice(1,4);//[2, 3, 4, empty, 5, 6, 7] //第一个参数为0.第二个参数不写时，复制数组 var arr2=arr.slice(0);//[1,2, 3, 4, empty, 5, 6, 7] //第一个参数为负.第二个参数不写时,倒数开始截取到尾部 var arr2=arr.slice(-2);//[6, 7] //第一个参数为负.第二个参数为负,从倒数第三位到倒数第一位 var arr2=arr.slice(-3,-1);//[5, 6]
splice()
-
解释：数组.splice(从什么位置开始,删除多少个元素,要插入的元素);
这个方法可以从指定的位置删除给定数量的元素，并且在这个位置插入需要的元素，并且返回被删除的元素组成的新数组 -
示例：
var arr=[1,2,3,4,5]; //没有任何参数时,返回一个空数组 var arr1=arr.splice(); console.log(arr1);//[] console.log(arr);返回[1,2,3,4,5] //表示并未对arr做任何改变 //第一个参数是0，表示从第0位开始，第二个参数删除多少个没有填，意味着删除到尾部 var arr1=arr.splice(0);//将所有数据转移到新数组 console.log(arr1);//返回[1,2,3,4,5] console.log(arr);//[] //把新数组的数值转给了arr1，表示删除arr所有数值 //从第0位开始删除3个元素，返回到新数组arr1 var arr1=arr.splice(0,3); console.log(arr1);//[1, 2, 3] console.log(arr);//[4, 5] //从第几位开始可以是负数，从后向前数（倒数）,删除3个元素 var arr1=arr.splice(-2，3); console.log(arr1);//[4, 5] console.log(arr);//[1, 2, 3] //从数组的第0位开始，删除1个元素，并且在这个位置插入一个元素 -1,替换 var arr1=arr.splice(0,1,-1); console.log(arr1);//[1] console.log(arr);//[-1, 2, 3, 4, 5] //数组的最后一位替换位0 var arr1=arr.splice(-1,1,0); console.log(arr1);//[5] console.log(arr);//[1, 2, 3, 4, 0] //将数组中第二位开始两位元素替换为10，11 var arr1=arr.splice(2,2,10,11); console.log(arr1);//[3, 4] console.log(arr);//[1, 2, 10, 11, 5] //在数组的第二位插入一个元素-1 var arr1=arr.splice(2,0,-1); console.log(arr1);//[] console.log(arr);//[1, 2, -1, 3, 4, 5]
indexOf
-
解释：数组.indexOf(要查询得元素,从什么位置(下标)开始查询) 返回查询到的下标
如果没找到，则会返回一个-1 -
示例：
//在数组中查找元素4，如果查找到，返回该元素所在的下标，如果没有查找到，则返回-1 var arr=[1,2,3,4,5,6]; var index=arr.indexOf(4); console.log(index); //无法查找到数组里面属性为对象的值 错误示例： var arr=[ {a:1}, {a:2}, {a:3}, {a:4} ]; var index=arr.indexOf({a:1}); console.log(index);//这是错误得，查找不到，引用地址不同，查找的是新对象 -
重构：
var arr=[4,2,3,4,5]; function indexOfs(arr,elem,sub){ var len=arr.length; for(var i=(sub?sub:0);i<len;i++){ if(arr[i]===elem) return i; } } var a=indexOfs(arr,4,2) console.log(a);
lastIndexOf
-
解释：数组.lastIndexOf(要查询得元素,从什么位置(下标)开始查询) 从后向前查找,返回查询到的下标
-
示例：
var arr=[1,3,1,2,3,5,2,3,4,6]; var index=arr.lastIndexOf(3); console.log(index);//返回7 -
重构：
var arr=[4,2,3,4,5]; function lastIndexOfs(arr,elem,sub){ var len=arr.length; for(var i=(sub?sub:0);i>=0;i--){ if(arr[i]===elem) return i; } } var a=lastIndexOfs(arr,4,2) console.log(a);
foreach
-
解释：数组遍历
- 数组.forEach(function(数组中的元素，每个元素对应的下标，数组自身{执行语句;})
- 没有返回值
-
示例：
//遍历 var arr=[2,4,6,,8,3,2]; var arr1=[]; arr.forEach(function(item,index){ arr1[index]=item; }) console.log(arr1); //返回：(7) [2, 4, 6, empty, 8, 3, 2] //会跳过空元素，如果不跳过可以使用arr1[index]： var arr1=arr.forEach(function(item,index,arr){ arr1[index]=item; });
map
-
解释：数组遍历
- 数组.map(function(数组中的元素，每个元素对应的下标，数组自身{执行语句;})
- 会返回一个与原数组长度相等的新数组,没有return时，返回的全是undefined，且数组长度和原数组长度相等。有return时，利用筛选条件，也会返回给新数组和旧数组一样的长度数组，其中不符合项，将有undefined代替。
-
示例：
var arr=[1,3,5,7,2,4,6,8]; var arr1=arr.map(function(item){ if(item>4){ return item; } }); console.log(arr1); //返回(8) [undefined, undefined, 5, 7, undefined, undefined, 6, 8]
sort()
-
解释：对数组的元素进行排序
- 数组.sort(function(后一项,前一项){执行语句;})
- 当return 后一项 - 前一项 时，则从小到大排序
- 当return 前一项 - 后一项 时，则从大到小排序
- 数组.sort(function(后一项,前一项){执行语句;})
-
示例：
var arr=[1,3,5,7,2,4,6,8]; var arr1=arr.sort(function(a,b){ return a-b; }); console.log(arr1); //返回(8) [1,2, 3, 4, 5, 6,7, 8] -
重构：
//从小到大排序 var arr=[4,2,3,4,5]; function sorts(arr){ for(var i=0;i<arr.length-1;i++){ for(var n=0;n<arr.length-1;n++){ if(arr[n]>arr[n+1]){ var item=arr[n]; arr[n]=arr[n+1]; arr[n+1]=item; } } } return arr; } console.log(sorts(arr)); //从大到小排序 var arr=[4,2,3,4,5]; function sorts(arr){ for(var i=0;i<arr.length-1;i++){ for(var n=0;n<arr.length-1;n++){ if(arr[n]<arr[n+1]){ var item=arr[n]; arr[n]=arr[n+1]; arr[n+1]=item; } } } return arr; } console.log(sorts(arr));
some()
-
解释：对数组的每个元素判断是否满足条件，如果都不满足就返回false，如果有一个满足的就返回满足条件的元素，并且不再判断后面的内容.
- 数组.some(function(数组中的元素，每个元素对应的下标，数组自身{执行语句;})
-
示例：
var arr=[1,3,5,7,2,4,6,8]; var bool=arr.some(function(item,index,arr){ return item>5; }); console.log(bool);//返回4 2 -
重构：
var arr=[4,2,3,4,8,1,5]; function somes(arr,fn){ for(var i=0;i<arr.length;i++){ var bool=fn(arr[i],i,arr); if(bool) return arr[i]; } } function fn(item,index,arr){ return item>5; } console.log(somes(arr,fn));
every()
-
解释：对数组的每个元素判断是否满足条件，如果有一个不满足条件就返回为false，全部满足时返回true
- 数组.every(function(数组中的元素，每个元素对应的下标，数组自身{执行语句;})
-
示例：
var arr=[1,3,5,7,2,4,6,8]; var bool=arr.every(function(item,index,arr){ return item>2; }); console.log(bool); //true -
重构：
var arr=[4,2,3,4,8,3,5]; function everys(arr,fn){ for(var i=0;i<arr.length;i++){ if(!fn(arr[i],i,arr)) return false; } return true; } function fn(item,index,arr){ return item>3; } console.log(everys(arr,fn));
reduce()
-
解释：方法对累计器和数组中的每个元素（从左到右）应用一个函数，将其简化为单个值。
-
数组.reduce(回调函数(累积值,元素,下标,数组){执行语句},初始值)；
-
如果reduce没有设置初始值，累计值是数组的第0位元素，遍历从下标1开始
//如果不加return value，则只在下标1累计下标0的元素 var arr=[5,3,4,7,3,5,8,9]; arr.reduce(function(value,item,index,arr){ console.log(value,item,index,arr); });// 5 3 1 (8) [5, 3, 4, 7, 3, 5, 8, 9] undefined 4 2 (8) [5, 3, 4, 7, 3, 5, 8, 9] undefined 7 3 (8) [5, 3, 4, 7, 3, 5, 8, 9] undefined 3 4 (8) [5, 3, 4, 7, 3, 5, 8, 9] undefined 5 5 (8) [5, 3, 4, 7, 3, 5, 8, 9] undefined 8 6 (8) [5, 3, 4, 7, 3, 5, 8, 9] undefined 9 7 (8) [5, 3, 4, 7, 3, 5, 8, 9] //如果加return value，则在1开始的下标接收下标0的元素 var arr=[5,3,4,7,3,5,8,9]; arr.reduce(function(value,item,index,arr){ console.log(value,item,index,arr); return value; });// 5 3 1 (8) [5, 3, 4, 7, 3, 5, 8, 9] 5 4 2 (8) [5, 3, 4, 7, 3, 5, 8, 9] 5 7 3 (8) [5, 3, 4, 7, 3, 5, 8, 9] 5 3 4 (8) [5, 3, 4, 7, 3, 5, 8, 9] 5 5 5 (8) [5, 3, 4, 7, 3, 5, 8, 9] 5 8 6 (8) [5, 3, 4, 7, 3, 5, 8, 9] 5 9 7 (8) [5, 3, 4, 7, 3, 5, 8, 9] //如果加return value+1，则在1开始的下标接收并每行累计下标0+1的元素 var arr=[5,3,4,7,3,5,8,9]; arr.reduce(function(value,item,index,arr){ return value; });// 6 3 1 (8) [5, 3, 4, 7, 3, 5, 8, 9] 7 4 2 (8) [5, 3, 4, 7, 3, 5, 8, 9] 8 7 3 (8) [5, 3, 4, 7, 3, 5, 8, 9] 9 3 4 (8) [5, 3, 4, 7, 3, 5, 8, 9] 10 5 5 (8) [5, 3, 4, 7, 3, 5, 8, 9] 11 8 6 (8) [5, 3, 4, 7, 3, 5, 8, 9] 12 9 7 (8) [5, 3, 4, 7, 3, 5, 8, 9] //如果加return value+item，则在1开始的下标接收累加上一行的item值，但最后一行没累计在内 var arr=[5,3,4,7,3,5,8,9]; arr.reduce(function(value,item,index,arr){ return value+item; });// 8 3 1 (8) [5, 3, 4, 7, 3, 5, 8, 9] 12 4 2 (8) [5, 3, 4, 7, 3, 5, 8, 9] 19 7 3 (8) [5, 3, 4, 7, 3, 5, 8, 9] 22 3 4 (8) [5, 3, 4, 7, 3, 5, 8, 9] 27 5 5 (8) [5, 3, 4, 7, 3, 5, 8, 9] 35 8 6 (8) [5, 3, 4, 7, 3, 5, 8, 9] 44 9 7 (8) [5, 3, 4, 7, 3, 5, 8, 9] -
如果reduce有设置初始值，累计值是初始值，遍历从下标0开始
var arr=[5,3,4,7,3,5,8,9]; var arr1=arr.reduce(function(value,item,index,arr){ return value+1; //value为1，每行+1进行累加 },1); console.log(arr1);//8 var arr=[5,3,4,7,3,5,8,9]; var arr1=arr.reduce(function(value,item,index,arr){ return value+item; // value为0，每行+上一行的item进行累加 },0); console.log(arr1);//8
-
-
-
重构：
var arr=[4,2,3,4,8,3,5]; function reduces(arr,fn,initValue){ var i=0; if(initValue===undefined){ initValue=arr[0]; i=1; } while(i<arr.length){ initValue=fn(initValue,arr[i],i,arr); i++; } return initValue; } var sum=reduces(arr,function(value,item,index,arr){ return value+item; })
filter()
-
解释：方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
- 数组.filter(function(数组中的元素，每个元素对应的下标，数组自身{执行语句;})
- 不会对空数组进行检测。
- 不会改变原始数组。
- 和map的区别在于map会返回一个与原数组长度相同的新数组，意在不会跳空，而filter则会跳空，返回一个由符合条件的元素组成的新数组。
-
示例：
var arr=[1,3,4,7,3,5,8,9]; var arr1=arr.filter(function(item,index,arr){ return item>5; }); console.log(arr1);//[7, 8, 9]
判断数组
Array.isArray()
-
解释：判断元素是否是数组，如果是数组返回true否则返回false
-
示例：
var arr=[1,2,3,4]; var obj={a:1}; console.log(Array.isArray(arr));//true console.log(Array.isArray(obj));//false
toString()
-
解释：可以将数组转换为任意进制字符串，但是对象数组不可以转换
-
示例：
var arr=[1,2,3,4]; var obj={a:1}; console.log(arr.toString());//1,2,3,4 console.log(obj.toString());//[object Object]
constructor
-
解释：属性返回对象的构造函数。
-
示例：
var arr=[1,2,3,4]; var obj={a:1}; console.log(arr.constructor===Array);//true console.log(arr.constructor===Object);//false
对象与数组
关系
- 数组实际上就是来源对象，脱胎于对象，继承于对象。
区别
对象属性名和数组的下标
- 对象属性名：obj的属性名是字符，在对象中属性名填入任何内容都会隐式转换为字符。
- 数组的下标：数组的下标是数字
- 在数组中所有的下标都会隐式转换为number
- 如果不能转换为number的（也就是转换后是NaN的），就会默认添加对象的属性名，但数组的长度，仅记录下标的个数，不包含属性数量，数组不可以使用点语法获取下标变量，但是可以使用点语法取属性。
访问元素
- 对象：可以用点语法和中括号
- 数组：只能用中括号
遍历方式
-
对象：for in 遍历 （浅复制）
- 可以遍历数组，但是遍历不出空元素，数组遍历时，以元素确认
var obj={a:1,b:2,c:3}; for (var prop in obj) { console.log(prop, obj[prop]); //返回：a,1 b,2 c,3 } -
数组：for 遍历 （浅复制）
- for循环是根据下标的数字从0开始循环到最大下标，有序
- for遍历只能遍历数组，以数字下标为顺序遍历
- 可以遍历空元素
var arr = [5, 2, 7, , 4, 9, 6]; for (var i = 0; i < arr.length; i++) { console.log(arr[i]); //返回[5, 2, 7, , 4, 9, 6]; }
二维数组
var arr = [];
for (var i = 0; i < 10; i++) {
// i是外层数组的下标
arr[i] = [];
for (var j = 0; j < 10; j++) {
// j是内层数组的下标
// arr[i]就是内层的数组
// arr[i][j]就是内层数组的第几个下标变量
// arr[i][j]=i*10+j;
arr[i][j] = i * 10 + j;
}
}
返回：
10) [Array(10), Array(10), Array(10), Array(10), Array(10), Array(10), Array(10), Array(10), Array(10), Array(10)]
0: (10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1: (10) [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
2: (10) [20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
3: (10) [30, 31, 32, 33, 34, 35, 36, 37, 38, 39]
4: (10) [40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
5: (10) [50, 51, 52, 53, 54, 55, 56, 57, 58, 59]
6: (10) [60, 61, 62, 63, 64, 65, 66, 67, 68, 69]
7: (10) [70, 71, 72, 73, 74, 75, 76, 77, 78, 79]
8: (10) [80, 81, 82, 83, 84, 85, 86, 87, 88, 89]
9: (10) [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
length: 10
__proto__: Array(0)
对象型数组
var arr=[
{a:1},
{b:2},
{c:3}
]
//遍历
for(var i=0;i<arr.length;i++){
for(var prpo in arr[i]){
console.log(i,prpo,arr[i][prpo]);
}
}
扫一扫
393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
