新浦京81707con > 注册购买 > 数组方法,数组操作方法

原标题:数组方法,数组操作方法

浏览次数:146 时间:2019-05-06

JavaScript中数组有各个操作方法,以下通过比世尊验证各个方法的行使:

数组的length质量等于数组中最大的index 1.

数组的长短

Array.length

var arr = [1,2,3];
console.log(arr.length); //3

数组操作方法

要素的增多 / 删除
  • 骨干格局
    直白动用索引增加;
    使用delete删除数组成分;(等同于直接把目的成分替换到undefined,不会变动数首席实施官度,也不会转移别的数据的indexvalue对应提到。
var a = [1,2,3,4];
delet a[2];  
console.log(a); // [1,2,undefined,4]
  • 栈方法
    pop():删除最终四个因素,数老董度 -1;
    push(X):在数组后添日成分X,数CEO度 一.

  • 队列方法
    shift()艺术能够去除数组index最小的要素,并使前面成分index都-一,length也-1,那样使用 shift/push就可以效仿队列了;
    与shift方法对应的又二个unshift方法,用于向数组尾部增多一个要素。

var a=new Array(1,2,3);
a.unshift(4);
console.log(a);//[4, 1, 2, 3]
console.log(a.length);//4
console.log(a.shift());//4
console.log(a); //[1, 2, 3]
console.log(a.length);//3
  • splice方法
    JavaScript提供了2个splice方法用于二次性化解数组增添、删除、替换,又四个参数:
    一,初叶索引;
    2,删除方法推行的次数;
    三,插入的新因素,当然也能够写几个。

splice的率先个参数是相对索引值,而不是绝对于数组索引,第三个参数并不是删除成分的个数,而是删除动作实施稍微次,并不是按数组实际索引移动,而是三番五次运动。同时调动前边成分索引,前边索引不理睬

数组的操作方法

push

在数组最终增添2个成分

var arr=[3,4,5,6]
console.log(arr)   //[3, 4, 5, 6]

arr.push("evenyao")  //字符串需要加"",数字不加
console.log(arr)   //[3, 4, 5, 6, "evenyao"]

 

常用操作
  • join(char):把数组元素使用参数作为链接符链接成一字符串,不会修改原数组的从头到尾的经过

  • slice(start,end):slice方法用于重临数组中一个有的或子数组,假设只写1个参数则赶回参数到数组截止部分,若是参数出现负数,则从数组尾巴部分计数。假若start大于end再次回到空数组,值得注意一点时slice不会改动原数组,而是重返三个新的数组。

  • concat(array):concat方法用于拼接数组,a.concat(b)再次来到1个a和b共同组成的新数组,同样不会修改任何一个原始数组,也不会递归连接数组内部数组

  • reverse():方法用于将数组逆序,与后面差别的是它会修改原数组。
    当数组索引不是接连或以0伊始,结果须求专注。

  • sort:sort方法用于对数组举行排序,当没有参数的时候会按字母表升序排序,如若含有undefined会被排到最终边,对象元素则会调用其toString方法,假设想安分守纪本身定义方式排序,可以传三个排序方法进去,很出色的政策格局,一样sort会改造原数组。
    亟待注意的是:

var a=new Array(7,8,9,10,11);
a.sort();
console.log(a); //[10, 11, 7, 8, 9]

因为依据字母表排序,七就比10大了,那时候大家供给传入自定义排序函数

var a = new Array(7,8,9,10,11);
a.sort(function(v1,v2){
    return v1-v2;
});
console.log(a);//[7, 8, 9, 10, 11]

插入和删除

  • 从数组尾巴部分开端
Array.push(); 从数组的尾部插入

Array.pop(); 从数组的尾部删除,返回值是删除的元素

例子

var arr = [1,2];
console.log(arr.push(5)); //3
console.log(arr); //[1,2,5]
console.log(arr.pop()); //5
console.log(arr); //[1,2]
  • 从数组底部起首
Array.unshift()    数组第一位插入,返回数组长度

Array.shift()   数组第一位删除,返回值是删除的值

例子

var arr = [1,2];
console.log(arr.unshift(5)); //3
console.log(arr); //[5, 1, 2]
console.log(arr.shift()); //5
console.log(arr); //[1,2]
  • 随意地方插入,修改和删除
Array.splice() 一次性解决数组添加/删除(这两种方法一结合就可以达到替换效果)

splice()办法有五个参数

  1. 千帆竞发索引(在数组中的对应索引)
  2. 去除成分的活动,即长度,要是是插入和替换则为0
  3. 布署的新因素,能够四个,也得以不写

splice()方法重回1个由删除成分构成的新数组,未有则赶回空数组

  • 删除
var arr = [1,2,5,6,8,10];
console.log(arr.splice(1,3)); //执行删除操作,[2,5,6]
console.log(arr); //[1,8,10]
  • 插入
var arr = [1,2,5,6,8,10];
console.log(arr.splice(0,0,2,5,6)); //执行插入,返回值为[]
console.log(arr); //[1,2,5,6,8,10]
  • 轮换(先删除再交替)
var arr = [1,2,5,6,8,10];
console.log(arr.splice(1,1,4));//执行替换,返回值为[2]
console.log(arr); //[1, 4, 5, 6, 8, 10]

pop

把数组最终一人抽取来,并赶回,且原来数组爆发变化

var arr=[3, 4, 5, 6, "evenyao"]
console.log(arr)   //[3, 4, 5, 6, "evenyao"]

var value = arr.pop()   //arr.pop()的返回值就是取出的值,但这里是undefined是因为前面有var value
console.log(value)  //"evenyao"
console.log(arr)   //[3, 4, 5, 6]

 

ES5 数组拓展

数组的任何格局

  • Array.join(char)
    把数组成分使用参数作为延续符连接成一个字符串,不会修改原数组内容
var arr = [1,2,3,4,5,6,7,8];
console.log(arr.join("|")); //"1|2|3|4|5|6|7|8"
  • Array.slice(start,end)
    用来重回数组中1个部分或子数组
    • 万一头写四个参数,则赶回参数到数组结束部分
    • 若果参数出现负数,则从数组后面部分计数
    • 假使start>end,重回空数组
    • 不会改造原数组,重回一个新的数组
var arr = [1,2,3,4,5,6,7,8];

console.log(arr.slice(2)); //[3, 4, 5, 6, 7, 8]
console.log(arr.slice(1,3)); //[2, 3]
console.log(arr.slice(3,3)); //[]
console.log(arr.slice(4,3)); //[]
console.log(arr.slice(4,-3)); //[5]
console.log(arr); //[1, 2, 3, 4, 5, 6, 7, 8]
  • Array.concat(array)
    用以拼接数组,a.concat(b)重回3个有a和b共同整合的新数组,不会修改原数组,也不会递归链接数组内部数组
var arr1 = [1,2,3,4,5,6,7,8];
var arr2 = [100,200,300];
console.log(arr1.concat(arr2)); //[1, 2, 3, 4, 5, 6, 7, 8, 100, 200, 300]
console.log(arr2.concat(arr1)); //[100, 200, 300, 1, 2, 3, 4, 5, 6, 7, 8]
  • Array.reverse()
    将数组逆序,会修改原数组
var arr = [1,2,3,4,5,6,7,8];
console.log(arr.reverse()); //[8, 7, 6, 5, 4, 3, 2, 1]
console.log(arr); //[8, 7, 6, 5, 4, 3, 2, 1]
  • Array.sort()
    用以对数组排序
    • 当未有参数的时候会按字母表升序排列,含有undefined会被排到最终,对象元素会调用toString方法
    • 设若根据自定义方式排序,能够传二个排序方法进去
    • 会转移原数组
var arr = [1,5,3,4,8,9,6,10];
console.log(arr.sort(function(v1,v2){
  return v1-v2;
})); //[1, 3, 4, 5, 6, 8, 9, 10]
console.log(arr); //[1, 3, 4, 5, 6, 8, 9, 10]

console.log(arr.sort()); //[1, 10, 3, 4, 5, 6, 8, 9]
console.log(arr); //[1, 10, 3, 4, 5, 6, 8, 9]

shift

把数组第四个人抽取来,并回到,且原来数组发生变化

var arr=["root",3, 4, 5, 6, "evenyao"]
console.log(arr)   //["root",3, 4, 5, 6, "evenyao"]

var value = arr.shift()
console.log(value)  //"root"
console.log(arr)  //[3, 4, 5, 6, "evenyao"]

 

Array.isArray(obj):

用来判定3个目的是还是不是数组;

ES5数组开始展览

  • Array.isArray(obj)
    那是Array对象的2个静态函数,用来判定三个对象是或不是数组
var a = [];
var b = {};
console.log(Array.isArray(a)); //true
console.log(Array.isArray(b)); //false
  • .indexOf(element) / .lastIndexOf(element)
    那三个法子用于查找数组内钦点成分地方,查找到第二个后回去其索引,未有检索到再次来到-1,indexOf从头至尾寻觅,lastIndexOf反向搜索
var arr = [1,8,5,4,1,2,3,4];
console.log(arr.indexOf(2)); //5
console.log(arr.indexOf(6)); //-1
  • .forEach(function(element, index, array))
    遍历数组,参数是一个回调函数
    回调函数有七个参数
    1. 眼下成分
    2. 日前因素的目录
    3. 一切数组
var arr = [1,8,5,4,1,2,3,4];
arr.forEach(function(e,index){
  console.log(e);
});
//1,8,5,4,1,2,3,4
  • .every(function(element, index, array)) / .some(function(element, index, array))
    逻辑推断,回调函数重返多个布尔值
    回调函数有多少个参数

    1. 眼下元素
    2. 最近成分的目录
    3. 任何数组
    • every是怀有函数的各种回调函数都回到true的时候才会回去true,当蒙受false的时候结束实践,再次来到false,类似&&
    • some函数是“存在”有1个回调函数重临true的时候甘休实施并回到true,不然再次回到false,类似||
var arr = [1,8,5,4,1,2,3,4];
console.log(arr.every(function(e,index){
  return e > 5;
})); //false
console.log(arr.some(function(e,index){
  return e > 5;
})); //true
  • .map(function(element))
    遍历数组,回调函数再次来到值组成三个新数组重返,新数组索引结商谈原数组1致,原数组不改变
var arr = [1,8,5,4,1,2,3,4];
console.log(arr.map(function(e){
  return e;
})); //[1, 8, 5, 4, 1, 2, 3, 4]
console.log(arr.map(function(e){
  return e*2;
})); //[2, 16, 10, 8, 2, 4, 6, 8]
console.log(arr); //[1, 8, 5, 4, 1, 2, 3, 4]
  • .filter(function(element))
    回去数组的三个子集,回调函数用于逻辑决断是不是再次来到,重临true则把最近因素参预到重返数组中,false则不加。

    粗略来讲是筛选功用,符合条件的要素到场到重返数组,不相符成分不加。

    新数组只包蕴重回true的值,索引缺失的不包含,原数组保持不改变

var arr = [1,2,3,4,-5,-6,-7,-10];
console.log(arr.filter(function(e){
  return e>0;
})); //[1, 2, 3, 4]
console.log(arr); //[1,2,3,4,-5,-6,-7,-10]
  • .reduce(function(v1,v2),value)/reduceRight(function(v1,v2),value)
    遍历数组,调用回调函数,将数组成分组合成二个值,reduce()从目录最小值开端,reduceRight()反向先导

    reduce()方式有五个参数

    1. 回调函数,将多个值合为三个,重返结果
    2. value初始值,可选
var arr = [1,2,3,4,-5,-6,-7,-10];
console.log(arr.reduce(function(v1,v2){
  return v1 v2;
})); //-18
console.log(arr.reduce(function(v1,v2){
  return v1*v2;
})); //50400
console.log(arr.reduce(function(v1,v2){
  return v1*v2;
},0)); //0

unshift

在数组第二个人新添二个要素

var arr=[3, 4, 5, 6, "evenyao"]
console.log(arr)   //[3, 4, 5, 6, "evenyao"]

arr.unshift("root")  //字符串需要加"",数字不加
console.log(arr)   //["root",3, 4, 5, 6, "evenyao"]

 

.indexOf(element) / .lastIndexOf(element):

那多个章程用于查找数组内钦定成分地方,查找到第八个后回去其索引,未有检索到重临-1,indexOf从头至尾搜索,lastIndexOf反向寻找。

join

把数组成分使用参数作为连接符,链接成字符串,不会修改原数组的内容

var arr=[3, 4, 5, 6, "evenyao"]
console.log(arr.join('-'))   //3-4-5-6-evenyao
console.log(arr)   //[3, 4, 5, 6, "evenyao"]

 

.forEach(function(e,i,array){});

遍历数组,参数为一个回调函数,回调函数有四个参数:

  1. 现阶段因素
  2. 如今成分索引值
  3. 漫天数组
    原数组退换。
var a = new Array(1,2,3,4,5,6);
a.forEach(function(e,i,array){
    array[i]= e   1;
});
console.log(a); //[2, 3, 4, 5, 6, 7]

本文由新浦京81707con发布于注册购买,转载请注明出处:数组方法,数组操作方法

关键词: 新浦京81707con 日记本 知识点

上一篇:一元夺宝网站APP开发,网站系统建设

下一篇:没有了