[console,log,添加1,参数,定义]javascript:数组详细操作方法及解析合集(9改变8不变12遍历)-阿里云开发者社区

开发者社区> dasein58> 正文

[console,log,添加1,参数,定义]javascript:数组详细操作方法及解析合集(9改变8不变12遍历)

简介:   改变原数组的方法(9个):   1   2   3   4   5   let a=[1,2,3];   ES5:   a.pop()/ a.shift()/ a.push()/ a.unshift()/ a.reverse()/ a.splice()/ a.sort()
+关注继续查看

  改变原数组的方法(9个):

  1

  2

  3

  4

  5

  let a=[1,2,3];

  ES5:

  a.pop()/ a.shift()/ a.push()/ a.unshift()/ a.reverse()/ a.splice()/ a.sort()

  ES6:

  a.copyWithin() / a.fill

  对于这些能够改变原数组的方法,要注意避免在循环遍历中改变原数组的选项,比如: 改变数组的长度,导致遍历的长度出现问题。

  pop() 删除一个数组中的最后的一个元素

  定义: pop() 方法删除一个数组中的最后的一个元素,并且返回这个元素。

  参数: 无。

  1

  2

  3

  let a=[1,2,3];

  let item=a.pop(); // 3

  console.log(a); // [1,2]

  shift() 删除数组的第一个元素

  定义: shift()方法删除数组的第一个元素,并返回这个元素。

  参数: 无。

  1

  2

  3

  let a=[1,2,3];

  let item=a.shift(); // 1

  console.log(a); // [2,3]

  push() 向数组的末尾添加元素

  定义:push() 方法可向数组的末尾添加一个或多个元素,并返回新的长度。

  参数: item1, item2, …, itemX ,要添加到数组末尾的元素

  1

  2

  3

  let a=[1,2,3];

  let item=a.push('末尾'); // 4

  console.log(a); // [1,2,3,'末尾']

  unshift()

  定义:unshift() 方法可向数组的开头添加一个或更多元素,并返回新的长度。

  参数: item1, item2, …, itemX ,要添加到数组开头的元素

  1

  2

  3

  let a=[1,2,3];

  let item=a.unshift('开头'); // 4

  console.log(a); // ['开头',1,2,3]

  reverse() 颠倒数组中元素的顺序

  定义: reverse() 方法用于颠倒数组中元素的顺序。

  参数: 无

  1

  2

  3

  let a=[1,2,3];

  a.reverse();

  console.log(a); // [3,2,1]

  splice() 添加/删除数组元素

  定义: splice() 方法向/从数组中添加/删除项目,然后返回被删除的项目

  语法: array.splice(index,howmany,item1,.....,itemX)

  参数:

  index:必需。整数,规定添加/删除项目的位置,使用负数可从数组结尾处规定位置。howmany:必需。要删除的项目数量。如果设置为 0,则不会删除项目。item1, …, itemX: 可选。向数组添加的新项目。

  返回值: 如果有元素被删除,返回包含被删除项目的新数组。

  eg1:删除元素

  1

  2

  3

  4

  5

  6

  let a=[1, 2, 3, 4, 5, 6, 7];

  let item=a.splice(0, 3); // [1,2,3]

  console.log(a); // [4,5,6,7]

  // 从数组下标0开始,删除3个元素

  let item=a.splice(-1, 3); // [7]

  // 从最后一个元素开始删除3个元素,因为最后一个元素,所以只删除了7

  eg2: 删除并添加

  1

  2

  3

  4

  5

  6

  7

  8

  let a=[1, 2, 3, 4, 5, 6, 7];

  let item=a.splice(0,3,'添加'); // [1,2,3]

  console.log(a); // ['添加',4,5,6,7]

  // 从数组下标0开始,删除3个元素,并添加元素'添加'

  let b=[1, 2, 3, 4, 5, 6, 7];

  let item=b.splice(-2,3,'添加1','添加2'); // [6,7]

  console.log(b); // [1,2,3,4,5,'添加1','添加2']

  // 从数组最后第二个元素开始,删除3个元素,并添加两个元素'添加1'、'添加2'

  eg3: 不删除只添加:

  1

  2

  3

  4

  5

  6

  let a=[1, 2, 3, 4, 5, 6, 7];

  let item=a.splice(0,0,'添加1','添加2'); // [] 没有删除元素,返回空数组

  console.log(a); // ['添加1','添加2',1,2,3,4,5,6,7]

  let b=[1, 2, 3, 4, 5, 6, 7];

  let item=b.splice(-1,0,'添加1','添加2'); // [] 没有删除元素,返回空数组

  console.log(b); // [1,2,3,4,5,6,'添加1','添加2',7] 在最后一个元素的前面添加两个元素

  从上述三个栗子可以得出:

  数组如果元素不够,会删除到最后一个元素为止操作的元素,包括开始的那个元素可以添加很多个元素添加是在开始的元素前面添加的

  sort() 数组排序

  定义: sort()方法对数组元素进行排序,并返回这个数组。

  参数可选: 规定排序顺序的比较函数。

  默认情况下sort()方法没有传比较函数的话,默认按字母升序,如果不是元素不是字符串的话,会调用toString()方法将元素转化为字符串的Unicode(万国码)位点,然后再比较字符。

  1

  2

  3

  4

  5

  6

  // 字符串排列 看起来很正常

  var a=["Banana", "Orange", "Apple", "Mango"];

  a.sort(); // ["Apple","Banana","Mango","Orange"]

  // 数字排序的时候 因为转换成Unicode字符串之后,有些数字会比较大会排在后面 这显然不是我们想要的

  var a=[10, 1, 3, 20,25,8];

  console.log(a.sort()) // [1,10,20,25,3,8];

  比较函数的两个参数:

  sort的比较函数有两个默认参数,要在函数中接收这两个参数,这两个参数是数组中两个要比较的元素,通常我们用 a 和 b 接收两个将要比较的元素:

  若比较函数返回值<0,那么a将排到b的前面;若比较函数返回值=0,那么a 和 b 相对位置不变;若比较函数返回值>0,那么b 排在a 将的前面;

  对于sort()方法更深层级的内部实现以及处理机制可以看一下这篇文章深入了解javascript的sort方法

  sort排序常见用法:

  1、数组元素为数字的升序、降序:

  1

  2

  3

  4

  5

  6

  7

  8

  9

  10

  11

  12

  var array=[10, 1, 3, 4,20,4,25,8];

  // 升序 a-b < 0 a将排到b的前面,按照a的大小来排序的

  // 比如被减数a是10,减数是20 10-20 < 0 被减数a(10)在减数b(20)前面

  array.sort(function(a,b){

  return a-b;

  });

  console.log(array); // [1,3,4,4,8,10,20,25];

  // 降序 被减数和减数调换了 20-10>0 被减数b(20)在减数a(10)的前面

  array.sort(function(a,b){

  return b-a;

  });

  console.log(array); // [25,20,10,8,4,4,3,1];

  2、数组多条件排序

  1

  2

  3

  4

  5

  6

  7

  8

  9

  var array=[{id:10,age:2},{id:5,age:4},{id:6,age:10},{id:9,age:6},{id:2,age:8},{id:10,age:9}];

  array.sort(function(a,b){

  if(a.id===b.id){// 如果id的值相等,按照age的值降序

  return b.age - a.age

  }else{ // 如果id的值不相等,按照id的值升序

  return a.id - b.id

  }

  })

  // [{"id":2,"age":8},{"id":5,"age":4},{"id":6,"age":10},{"id":9,"age":6},{"id":10,"age":9},{"id":10,"age":2}]

  3、自定义比较函数,天空才是你的极限

  类似的:运用好返回值,我们可以写出任意符合自己需求的比较函数

  1

  2

  3

  4

  5

  6

  7

  8

  9

  var array=[{name:'Koro1'},{name:'Koro1'},{name:'OB'},{name:'Koro1'},{name:'OB'},{name:'OB'}];

  array.sort(function(a,b){

  if(a.name==='Koro1'){// 如果name是'Koro1' 返回-1 ,-1<0 a排在b的前面

  return -1

  }else{ // 如果不是的话,a排在b的后面

  return 1

  }

  })

  // [{"name":"Koro1"},{"name":"Koro1"},{"name":"Koro1"},{"name":"OB"},{"name":"OB"},{"name":"OB"}]

  ES6: copyWithin() 指定位置的成员复制到其他位置

  定义: 在当前数组内部,将指定二手域名拍卖平台位置的成员复制到其他位置,并返回这个数组。

  语法:

  array.copyWithin(target, start=0, end=this.length)

  参数:

  三个参数都是数值,如果不是,会自动转为数值.

  target(必需):从该位置开始替换数据。如果为负值,表示倒数。start(可选):从该位置开始读取数据,默认为 0。如果为负值,表示倒数。end(可选):到该位置前停止读取数据,默认等于数组长度。使用负数可从数组结尾处规定位置。

  浏览器兼容(MDN): chrome 45,Edge 12,Firefox32,Opera 32,Safari 9, IE 不支持

  eg:

  1

  2

  3

  4

  5

  6

  7

  // -2相当于3号位,-1相当于4号位

  [1, 2, 3, 4, 5].copyWithin(0, -2, -1)

  // [4, 2, 3, 4, 5]

  var a=['OB1','Koro1','OB2','Koro2','OB3','Koro3','OB4','Koro4','OB5','Koro5']

  // 2位置开始被替换,3位置开始读取要替换的 5位置前面停止替换

  a.copyWithin(2,3,5)

  // ["OB1","Koro1","Koro2","OB3","OB3","Koro3","OB4","Koro4","OB5","Koro5"]

  从上述栗子:

  第一个参数是开始被替换的元素位置要替换数据的位置范围:从第二个参数是开始读取的元素,在第三个参数前面一个元素停止读取数组的长度不会改变读了几个元素就从开始被替换的地方替换几个元素

  ES6: fill() 填充数组

  定义: 使用给定值,填充一个数组。

  参数:

  第一个元素(必须): 要填充数组的值

  第二个元素(可选): 填充的开始位置,默认值为0

  第三个元素(可选):填充的结束位置,默认是为this.length

  1

  2

  3

  4

  ['a', 'b', 'c'].fill(7)

  // [7, 7, 7]

  ['a', 'b', 'c'].fill(7, 1, 2)

  // ['a', 7, 'c']

  不改变原数组的方法(8个):

  ES5:

  join、toLocateString、toStrigin、slice、cancat、indexOf、lastIndexOf、

  ES7:

  includes

  join() 数组转字符串

  定义: join() 方法用于把数组中的所有元素通过指定的分隔符进行分隔放入一个字符串,返回生成的字符串。

  语法:

  array.join(str)

  参数:

  str(可选): 指定要使用的分隔符,默认使用逗号作为分隔符。

  1

  2

  3

  let a=['hello','world'];

  let str=a.join(); // 'hello,world'

  let str2=a.join('+'); // 'hello+world'

  使用join方法或者下文说到的toString方法时,当数组中的元素也是数组或者是对象时会出现什么情况?

  1

  2

  3

  4

  5

  let a=[['OBKoro1','23'],'test'];

  let str1=a.join(); // OBKoro1,23,test

  let b=[{name:'OBKoro1',age:'23'},'test'];

  let str2=b.join(); // [object Object],test

  // 对象转字符串推荐JSON.stringify(obj);

  所以,join()/toString()方法在数组元素是数组的时候,会将里面的数组也调用join()/toString(),如果是对象的话,对象会被转为[object Object]字符串。

  toLocaleString() 数组转字符串

  定义: 返回一个表示数组元素的字符串。该字符串由数组中的每个元素的 toLocaleString() 返回值经调用 join() 方法连接(由逗号隔开)组成。

  语法:

  array.toLocaleString()

  参数:无。

  1

  2

  let a=[{name:'OBKoro1'},23,'abcd',new Date()];

  let str=a.toLocaleString(); // [object Object],23,abcd,2021/5/28 下午1:52:20

  如上述栗子:调用数组的toLocaleString方法,数组中的每个元素都会调用自身的toLocaleString方法,对象调用对象的toLocaleString,Date调用Date的toLocaleString。

  toString() 数组转字符串 不推荐

  定义: toString() 方法可把数组转换为由逗号链接起来的字符串。

  语法:

  array.toString()

  参数: 无。

  该方法的效果和join方法一样,都是用于数组转字符串的,但是与join方法相比没有优势,也不能自定义字符串的分隔符,因此不推荐使用。

  值得注意的是:当数组和字符串操作的时候,js 会调用这个方法将数组自动转换成字符串

  1

  2

  let b=[ 'toString','演示'].toString(); // toString,演示

  let a=['调用toString','连接在我后面']+'啦啦啦'; // 调用toString,连接在我后面啦啦啦

  slice() 浅拷贝数组的元素

  定义: 方法返回一个从开始到结束(不包括结束)选择的数组的一部分浅拷贝到一个新数组对象,且原数组不会被修改。

  注意:字符串也有一个slice() 方法是用来提取字符串的,不要弄混了。

  语法:

  array.slice(begin, end);

  参数:

  begin(可选): 索引数值,接受负值,从该索引处开始提取原数组中的元素,默认值为0。

  end(可选):索引数值(不包括),接受负值,在该索引处前结束提取原数组元素,默认值为数组末尾(包括最后一个元素)。

  1

  2

  3

  4

  5

  6

  let a=['hello','world'];

  let b=a.slice(0,1); // ['hello']

  a[0]='改变原数组';

  console.log(a,b); // ['改变原数组','world'] ['hello']

  b[0]='改变拷贝的数组';

  console.log(a,b); // ['改变原数组','world'] ['改变拷贝的数组']

  如上:新数组是浅拷贝的,元素是简单数据类型,改变之后不会互相干扰。

  如果是复杂数据类型(对象,数组)的话,改变其中一个,另外一个也会改变。

  1

  2

  3

  4

  5

  6

  7

  let a=[{name:'OBKoro1'}];

  let b=a.slice();

  console.log(b,a); // [{"name":"OBKoro1"}] [{"name":"OBKoro1"}]

  // a[0].name='改变原数组';

  // console.log(b,a); // [{"name":"改变原数组"}] [{"name":"改变原数组"}]

  // b[0].name='改变拷贝数组',b[0].koro='改变拷贝数组';

  // [{"name":"改变拷贝数组","koro":"改变拷贝数组"}] [{"name":"改变拷贝数组","koro":"改变拷贝数组"}]

  原因在定义上面说过了的:slice()是浅拷贝,对于复杂的数据类型浅拷贝,拷贝的只是指向原数组的指针,所以无论改变原数组,还是浅拷贝的数组,都是改变原数组的数据。

  cancat

  定义: 方法用于合并两个或多个数组,返回一个新数组。

  语法:

  var newArr=oldArray.concat(arrayX,arrayX,......,arrayX)

  参数:

  arrayX(必须):该参数可以是具体的值,也可以是数组对象。可以是任意多个。

  eg1:

  1

  2

  3

  4

  5

  6

  7

  8

  9

  10

  11

  12

  13

  14

  let a=[1, 2, 3];

  let b=[4, 5, 6];

  //连接两个数组

  let newVal=a.concat(b); // [1,2,3,4,5,6]

  // 连接三个数组

  let c=[7, 8, 9]

  let newVal2=a.concat(b, c); // [1,2,3,4,5,6,7,8,9]

  // 添加元素

  let newVal3=a.concat('添加元素',b, c,'再加一个');

  // [1,2,3,"添加元素",4,5,6,7,8,9,"再加一个"]

  // 合并嵌套数组 会浅拷贝嵌套数组

  let d=[1,2 ];

  let f=[3,[4]];

  let newVal4=d.concat(f); // [1,2,3,[4]]

  ES6扩展运算符...合并数组:

  因为ES6的语法更简洁易懂,所以现在合并数组我大部分采用...来处理,...运算符可以实现cancat的每个栗子,且更简洁和具有高度自定义数组元素位置的效果。

  1

  2

  3

  let a=[2, 3, 4, 5]

  let b=[ 4,...a, 4, 4]

  console.log(a,b); // [2, 3, 4, 5] [4,2,3,4,5,4,4]

  indexOf() 查找数组是否存在某个元素,返回下标

  定义: 返回在数组中可以找到一个给定元素的第一个索引,如果不存在,则返回-1。

  语法:

  array.indexOf(searchElement,fromIndex)

  参数:

  searchElement(必须):被查找的元素

  fromIndex(可选):开始查找的位置(不能大于等于数组的长度,返回-1),接受负值,默认值为0。

  严格相等的搜索:

  数组的indexOf搜索跟字符串的indexOf不一样,数组的indexOf使用严格相等===搜索元素,即数组元素要完全匹配才能搜索成功。

  注意:indexOf()不能识别NaN

  eg:

  1

  2

  3

  4

  let a=['啦啦',2,4,24,NaN]

  console.log(a.indexOf('啦')); // -1

  console.log(a.indexOf('NaN')); // -1

  console.log(a.indexOf('啦啦')); // 0

  使用场景:

  数组去重根据获取的数组下标执行操作,改变数组中的值等。判断是否存在,执行操作。

  lastIndexOf() 查找指定元素在数组中的最后一个位置

  定义: 方法返回指定元素,在数组中的最后一个的索引,如果不存在则返回 -1。(从数组后面往前查找)

  语法:

  arr.lastIndexOf(searchElement,fromIndex)

  参数:

  searchElement(必须): 被查找的元素

  fromIndex(可选): 逆向查找开始位置,默认值数组的长度-1,即查找整个数组。

  关于fromIndex有三个规则:

  正值。如果该值大于或等于数组的长度,则整个数组会被查找。负值。将其视为从数组末尾向前的偏移。(比如-2,从数组最后第二个元素开始往前查找)负值。其绝对值大于数组长度,则方法返回 -1,即数组不会被查找。

  1

  2

  3

  4

  5

  let a=['OB',4,'Koro1',1,2,'Koro1',3,4,5,'Koro1']; // 数组长度为10

  // let b=a.lastIndexOf('Koro1',4); // 从下标4开始往前找 返回下标2

  // let b=a.lastIndexOf('Koro1',100); // 大于或数组的长度 查找整个数组 返回9

  // let b=a.lastIndexOf('Koro1',-11); // -1 数组不会被查找

  let b=a.lastIndexOf('Koro1',-9); // 从第二个元素4往前查找,没有找到 返回-1

  ES7 includes() 查找数组是否包含某个元素 返回布尔

  定义: 返回一个布尔值,表示某个数组是否包含给定的值

  语法:

  array.includes(searchElement,fromIndex=0)

  参数:

  searchElement(必须):被查找的元素

  fromIndex(可选):默认值为0,参数表示搜索的起始位置,接受负值。正值超过数组长度,数组不会被搜索,返回false。负值绝对值超过长数组度,重置从0开始搜索。

  includes方法是为了弥补indexOf方法的缺陷而出现的:

  indexOf方法不能识别NaNindexOf方法检查是否包含某个值不够语义化,需要判断是否不等于-1,表达不够直观

  eg:

  1

  2

  3

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
从零开始定义自己的JavaScript框架(一)
来自:http://www.ituring.com.cn/article/48461   1.1 模块的定义 一个框架想要能支撑较大的应用,首先要考虑怎么做模块化。有了内核和模块加载系统,外围的模块就可以一个一个增加。
721 0
使用OpenApi弹性释放和设置云服务器ECS释放
云服务器ECS的一个重要特性就是按需创建资源。您可以在业务高峰期按需弹性的自定义规则进行资源创建,在完成业务计算的时候释放资源。本篇将提供几个Tips帮助您更加容易和自动化的完成云服务器的释放和弹性设置。
12071 0
《JavaScript启示录》——1.4 用户自定义/非原生对象构造函数
关于构造函数比较复杂的一点就是this值在函数内部的使用方式。请记住,构造函数只是一个饼干模具,在将它与new关键字一起使用时,它会创建一个拥有构造函数内部定义的属性和值的对象。在使用new关键字时,this值的字面意思是基于构造函数内部的语句创建的新对象/新实例。
1035 0
《JavaScript设计模式》——1.10 可以链式添加吗
本节书摘来自异步社区《JavaScript设计模式》一书中的第1章,第1.10节,作者:张容铭著,更多章节内容可以访问云栖社区“异步社区”公众号查看
963 0
JavaScript之函数定义以及类型
今天在网上做到一道面试题,代码如下: var f = function g() { return 23; }; typeof g(); 问:以上代码的输出结果是() A “number” B “undefined” C “function” D Error 我第一反应选择的答案是A/C。
578 0
+关注
780
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载