本文详细介绍了JavaScript数组的概念，包括其有序列表、紧密结构和无序元素的特性。讲解了数组的创建方式，如字面量、实例化、构造函数等。还探讨了数组的length属性、下标、元素以及遍历方法。文章进一步阐述了数组的修改方法，如push、pop、unshift、shift等，并介绍了concat、slice等不改变原始数组的操作。此外，还涉及了数组的排序、去重、查找和转换等高级操作。最后，提到了二维数组、静态方法Array.from和Array.isArray，以及sort()排序算法和错误处理机制。
数组:数据驱动显示
定义：是一个无序元素的紧密结构的有序列表
1.有序列表：排序
2.紧密结构：列表是具备长度的，而且这个长度会自动根据列表内容变化而变化，添加删除消耗性能大，速度慢；
另外，可以遍历有对应的下标，可以根据下标遍历到数组的所有元素。
3.无序元素：意味着元素可以不区分先后顺序，而且不能避免重复
新建数组
1.字面量创建
数组长度不固定（在js中数组长度是可以改变的）
var arr = []
2.实例化创建（构造函数实例化）
var arr = new Array()
3.构造函数创建
var arr = Array()
4.通过对象创建数组
var arr = new Object([])
注意：如果使用实例化创建和构造函数创建数组，参数只有一个，并且是数值的话，那么这个数数值必须是正整数，如果有小数和负整数都会报错，这个正整数就是这个数组的预设长度，里面都放入空元素。则无法通过这种方式创建一个数值元素的数组。
arr. length：数组中元素的个数
下标：每个元素在数组中的位置，从0开始
下标变量：数组对应的下标的存储单元
元素：组成数组的最基本单元，叫做元素或者元，也叫做下标变量的值
可枚举判断：
key和value必须存在：for...in...
可以把数组作为对象枚举遍历时，数组中的下标就变为了对象的key属性，对象key属性就是字符串
注意：数组的长度length是不可枚举属性
for...in...最好不要作为数组遍历方式使用，会遍历到数组的所有属性，包括对象属性
迭代器遍历
for...of...(往返在一个上面改变)
数组复制
var arr = ['a','b',,'c',undefined,'e']
var arr1=[]
for(var i = 0;i < arr.length; i++){
if(!(i in arr)) continue //枚举遍历，看第i项是否有key和value值，是一种判断空元素的方式
arr1[i] = arr[i]
}
给数组尾部添加元素：arr[arr.length] = 值
替换数组的最头部元素：arr[0] = 值
arr.length:是一个可读可写不可删除不可枚举的属性
可写：如果长度比原来多，就在后面添加空属性，否则，将多出来的数据删除
arr,length = 0 清空数组 arr = []清空数组是错误的，会造成内存泄漏
arr.length -- ：删除最后一个元素
注意：如果使用arr.length进行数组的添加和删除，则需要先将arr.length 赋值给一个新的变量，因为添加和删除时，长度在改变
数组的方法：
-
push(数据1 ，数据2，数据3 ...)
function arrPush(arr){
if(!arr || arr.constructor !== Array) throw new Error(arr +' is a not Array')
for(var i = 1; i<arguments.length;i++){
arr[arr.length]=arguments[i]
}
return arr.length
}
-
pop()
function arrPop(arr){
if(!arr || arr.constructor !== Array) throw new Error(arr + ' is a not Array')
if(arr.length===0) return
var item = arr[arr.length-1]
arr.length--
return item
}
-
unshift(数据1 ，数据2，数据3 ...)
function arrUnshift(arr){
if(!arr || arr.constructor !== Array) throw new Error(arr + ' is a not Array')
var len = arguments.length-1
if(!len) return arr.length
for(var i = len+arr.length-1;i>=0;i--){
if(i>=len) arr[i]=arr[i-len]
else arr[i]=arguments[i+1]
}
return arr.length
}
-
shift()
function arrShift(arr) {
if (!arr || arr.constructor !== Array) throw new Error(arr + ' is a not Array')
if (arr.length === 0) return
var item = arr[0]
for (var i = 0; i < arr.length - 1; i++) {
arr[i]=arr[i+1]
}
arr.length--
return item
}
-
fill(要填充的数据，开始索引，结束索引)
function arrFill(arr,value,start,end){
if(!arr || arr.constructor !== Array) throw new Error(arr+' is a not Array')
if(isNaN(start)) start = 0
if(isNaN(end)) end = arr.length
start = Number(start)
end = Number(end)
if(start<0) start = start+arr.length<0 ? 0: start+arr.length
if(end<0) end = end + arr.length < 0 ? 0:end+arr.length
if(end>arr.length) end=arr.length
for(var i = start;i<end;i++){
arr[i]=value
}
return arr
}
-
concat(数据1/数据1，数据2/数组2...)
function arrayConcat(arr){
if (!arr || arr.constructor !== Array) throw new Error(arr + "is not Array!");
var array=[];
for(var i=0;i<arguments.length;i++){
if(arguments[i] && arguments[i].constructor===Array){
for(var j=0;j<arguments[i].length;j++){
array[array.length]=arguments[i][j];
}
}else{
array[array.length]=arguments[i];
}
}
return array;
}
-
slice(开始索引，结束索引)
function arraySlice(arr, start, end) {
if (!arr || arr.constructor !== Array) throw new Error(arr + 'not a Array')
start = ~~start
end=~~end
if (start < 0) start = start + arr.length < 0 ? 0 : start + arr.length
if (end < 0) end = end + arr.length < 0 ? 0 : end + arr.length
if(end > arr.length) end = arr.length
var arr1 = []
for(var i = start; i < end ;i++){
arr1[arr1.length] = arr[i]
}
return arr1
}
-
indexOf(要查找的数据，开始的位置)
function arrayIndexOf(arr,item,start){
if (!arr || arr.constructor !== Array) throw new Error(arr + 'not a Array')
start = ~~start
if(start < 0) start = start + arr.length < 0 ? 0 : start + arr.length
for(var i = start; i < arr.length; i++){
if(!(i in arr)) continue
if(arr[i] === item) return i
}
return -1
}
-
lastIndexOf(要查找的数据，开始的位置)
function arrayLastIndexOf(arr,value,end){
if (!arr || arr.constructor !== Array) throw new Error(arr + 'not a Array')
if(end === undefined) end=arr.length-1
end = ~~end
if(end < 0) end = end+arr.length < 0? 0:end+arr.length
for(var i =end;i>=0;i--){
if(!(i in arr)) continue
if(arr[i] ===value) return i
}
return -1
}
-
splice(开始索引，多少个，数据1，数据2...)
function arraySplice(arr, start, deleteCount) {
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
if (start === undefined) return [];
start = ~~start;
if (start < 0) start = (start + arr.length) < 0 ? 0 : start + arr.length;
if (deleteCount === undefined) deleteCount = arr.length - start;
deleteCount = ~~deleteCount;
if (deleteCount < 0) deleteCount = 0;
if (deleteCount + start > arr.length) deleteCount = arr.length - start;
var arr1 = [];
for (var i = start; i < arr.length; i++) {
if (i < start + deleteCount) arr1[arr1.length] = arr[i];
arr[i] = arr[i + deleteCount];
}
arr.length -= deleteCount;
var len = arguments.length - 3;
if (len <= 0) return arr1;
for (var j = arr.length - 1 + len; j >= start; j--) {
if (j >= start + len) arr[j] = arr[j - len];
else arr[j] = arguments[3 + j - start];
}
return arr1;
}
-
reverse()
function arrayReverse(arr) {
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
var len = ~~(arr.length/2);
for (var i = 0; i < len; i++) {
if (!(i in arr)) continue;
var temp=arr[i]
arr[i]=arr[arr.length-1]
arr[arr.length-1]=temp
}
return arr;
}
-
join()
function arrayJoin(arr,sep){
if (!arr || arr.constructor !== Array) throw new Error(arr + 'not a Array')
if(sep === undefined) sep =','
sep = String(sep)
var str = ''
for(var i = 0 ; i < arr.length ; i++){
if(i === arr.length -1) return str += arr[i]
str += arr[i]+sep
}
}
-
includes(要查找的数据)
function arrayIncludes(arr,value){
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
for(var i = 0; i < arr.length; i++){
if(!(i in arr)) continue
if(value===arr[i]) return true
}
return false
}
-
reduce(function(value,item,index,arr),value的初始值)
function arrayReduce(arr,fn,initValue){
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
var i=0;
if(initValue===undefined){
initValue=arr[0];
i=1;
}
for(;i<arr.length;i++){
initValue=fn(initValue,arr[i],i,arr);
}
return initValue;
}
function arrayReduceRight(arr,fn,initValue){
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
var i=arr.length-1;
if(initValue===undefined){
initValue=arr[arr.length-1];
i--;
}
for(;i>=0;i--){
initValue=fn(initValue,arr[i],i,arr);
}
return initValue;
}
-
forEach(function(item,index,arr){})
function arrayForEach(arr, fn) {
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
for (var i = 0; i < arr.length; i++) {
if (!(i in arr)) continue;
fn(arr[i], i, arr)
}
}
-
map(function(item,index,arr){})
function arrayMap(arr, fn) {
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
var arr1 = [];
for (var i = 0; i < arr.length; i++) {
if (!(i in arr)) continue;
arr1[i]=fn(arr[i], i, arr)
}
return arr1;
}
-
filter(function(item,index,arr){})
function arrayFilter(arr, fn) {
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
var arr1 = [];
for (var i = 0; i < arr.length; i++) {
if (!(i in arr)) continue;
if (fn(arr[i], i, arr)) arr1.push(arr[i]);
}
return arr1;
}
-
every(function(item,index,arr){})
function arrayEvery(arr, fn) {
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
for (var i = 0; i < arr.length; i++) {
if (!(i in arr)) continue;
if (!fn(arr[i], i, arr)) return false;
}
return true;
}
-
some(function(item,index,arr){})
function arraySome(arr, fn) {
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
for (var i = 0; i < arr.length; i++) {
if (!(i in arr)) continue;
if (fn(arr[i], i, arr)) return true;
}
return false;
}
-
find(function(item,index,arr){})
function arrayFind(array,fn){
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
for(var i=0;i<arr.length;i++){
if(!(i in arr)) continue;
if(fn(arr[i],i,arr)) return arr[i];
}
}
-
findIndex(function(item,index,arr){})
function arrayFindIndex(array, fn) {
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
for (var i = 0; i < arr.length; i++) {
if (!(i in arr)) continue;
if (fn(arr[i], i, arr)) return i;
}
return -1;
}
-
flatMap(function(item,index,arr){})
function arrayFlatMap(array,fn){
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
var arr1=[];
for(var i=0;i<arr.length;i++){
if(!(i in arr)) continue;
// arr1=arr1.concat(fn(arr[i],i,arr))
var item=fn(arr[i],i,arr);
if(item && item.constructor===Array){
for(var j=0;j<item.length;j++){
arr1.push(item[j]);
}
}else{
arr1.push(item);
}
}
return arr1;
}
-
flat(要拍平几层)
function flatMap(arr,target){
if(target===undefined) target=[];
for(var i=0;i<arr.length;i++){
if(arr[i] && arr[i].constructor===Array){
flatMap(arr[i],target);
}else{
target.push(arr[i]);
}
}
return target;
}
-
sort()/sort(function(item,index,arr){})
function arraySort(arr,fn){
if (!arr || arr.constructor !== Array) throw new Error(arr + "not is Array");
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[i]=temp
}
}
if(arr[j]===arr[j+1]) i++
}
return arr
}
-
copyWithIn(目标位置，开始索引，结束索引)
数组方法归纳
1.改变原数组：
push(),pop(),unshift(),shift(),splice(),reverse(),sort(),fill(),copyWithin(),
2.不改变原始数组
concat(),slice(),map(),filter(),flat(),flatMap(),
数组元素计数：
var obj={}
for(var i=0;i<arr.length;i++){
if(!(i in arr)) continue
if(!obj[arr[i]]) obj[arr[i]]=0
obj[arr[i]]++
}
数组去重
1.改变原始数组
for(var i=0;i<arr.length;i++){
for(var j=0;j<arr.length;){
if(arr[i]===arr[j]) arr.splice(j,1)
j++
}
}
2.不改变原始数组
var arr1=[]
YYH:for(var i=0;i<arr.length;i++){
for(var j=0;j<arr.length;j++){
if(arr[i]===arr[j]) continue YYH
}
arr1.push(arr[i])
}
var arr2=[]
for(var i=0;i<arr.length;i++){
if(!(~arr2.indexOf(arr1[i]))) arr2.push(arr[i])
//if(arr2.indexOf(arr1[i])===-1) arr2.push(arr[i])
//if(!arr2.includes(arr1[i])) arr2.push(arr[i])
}
3.将两组数据相同的数据取出来
var arr3=[]
for(var i=0;i<arr.length;i++){
if(arr1.includes(arr[i])&&!arr3.include(arr[i])) arr3.push(arr[i])
}
4.将两组数据不同的取出来
//先将数组去重
function difer(arr){
for(var i=0;i<arr.length;i++){
for(var j=0;j<arr.length;){
if(arr[i]===arr[j]) arr.splice(j,1)
j++
}
}
return arr
}
//将数组的用对象的方式保存
function getCountObj(arr){
var obj={}
for(var i=0;i<arr.length;i++){
if(!(i in arr)) continue
if(!obj[arr[i]]) obj[arr[i]]=0
obj[arr[i]]++
}
return obj
}
var newArr=[]
//将两个数组去重后连接起来
arr = difer(arr).concat(difer(arr1))
//将连接起来的数据转换为对象
var obj=getCountObj(arr)
for(var i=0;i<arr.length;i++){
if(!(i in arr)) continue
if(obj[arr[i]]>1) continue
newArr.push(arr[i])
}
try...catch..finally
try不管执行了多少，只要遇到错误，就会执行catch语句，try还是有效，只是不会报错了，而不管报错与否，都会执行finally语句
可以通过try..catch语句来中断forEach()循环
注意：throw必须用在函数里面
数组的静态方法
1.Arrayfrom()
参数1：迭代器
参数2：函数（跟map的功能一致）
2.Array.isArray()：判断某个元素是不是数组
sort()排序
1.冒泡排序
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[i]=temp
}
}
if(arr[j]===arr[j+1]) i++
}
2.选择排序
for(var i=0;i<arr.length;i++){
var min=i;
for(var j=i+1;j<arr.length;j++){
if(arr[j]<arr[min]) min=j
}
if(min!==i){
var temp=arr[min]
arr[min]=arr[i]
arr[i]=temp
}
if(arr[i]===arr[i+1]) i++
}
3.快速排序
function quickSort(arr){
if(arr.length<=1) return arr;
var centerIndex=~~(arr.length/2)
var left=[]
var right=[]
for(var i=0;i<arr.length;i++){
if(i===centerIndex) continue
if(arr[i]<arr[centerIndex]) left.push(arr[i])
else right.push(arr[i])
}
return quickSort(left).concat(arr[centerIndex],quickSort(right))
}
二维数组
二维数组本质上是以数组作为数组元素的数组，即“数组的数组”，类型说明符 数组名 [常量表达式] [常量表达式]。二维数组又称为矩阵，行列数相等的矩阵称为方阵。对称矩阵 a[i] [j] = a[j] [i] [对角矩阵]：n阶方阵[主对角线]外都是零元素
对象数组
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
