js03_常用数组操作方法总结（全）

前言：每次需要用到数组方法时，总是需要去百度，因为一些方法在一段时间不用就忘记了，所以来做个总结，方便自己以后查找，顺便加深一下记忆。

创建 / 声明数组

方式一：
var array = [3, 5, 2];     // [3,5,2]
方式二：
var array = Array(4,5,2);  // [4,5,2]

改变原数组的方法：

ES5: push() / pop() / shift() / unshift() / reverse() /  sort()
	 splice(改变原数组) - slice(不改变原数组)
ES6: copyWithin() / fill()

一、数组的增删 - 均改变原数组

1. push() / pop() / unshift() / shift()

定义： 增/删原数组中的最后/前一个元素

语法： arr.push(obj)

参数： obj - 要添加的对象

返回值：

• 增加的返回数组新的长度
• 删除的返回删除的元素

//push
var a = [1,2,3]
var b = a.push('末尾')
console.log(a)  // [1,2,3,'末尾'] 
console.log(b)  // 4 (新数组长度)
//pop
var a = [1,2,3]
var b = a.pop()
console.log(a) // [1,2]
console.log(b) // 3
//unshift
var a = [2,3,4]
var b = a.unshift(0,1)
console.log(a)  // [0,1,2,3,4]
console.log(b)  // 5 (新数组长度)
//shift
var a = [1,2,3]
var b = a.shift()
console.log(a) // [2,3]
console.log(b) // 1

2. splice()

定义： 向原数组中删除 + 添加项目

语法：arr.splice(index,howmany,item1,…,itemX)

参数： (若只设置一个参数，则从该位置开始删除后面所有值)

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

返回值： 如果有元素被删除，返回被删除的所有项(数组形式)；若没有删除，则返回空值

删除元素：

var a = [1, 2, 3, 4, 5, 6, 7];
var b = a.splice(0, 3); // 从数组下标0开始，删除3个元素
console.log(a); // [4,5,6,7]
console.log(b); // [1,2,3]

var c = a.splice(-1, 3); // 从最后一个元素开始删除3个元素，因为最后一个元素，所以只删除了7
console.log(a);  // [4,5,6]
console.log(c);  // [7]

删除并添加：

var a = [1, 2, 3, 4, 5, 6, 7];
var b = a.splice(0,3,'添加'); // 从数组下标0开始，删除3个元素，并添加元素'添加'
console.log(a); // ['添加',4,5,6,7]
console.log(b); // [1,2,3]

var c = [1, 2, 3, 4, 5, 6, 7];
var d = c.splice(-2,3,'添加1','添加2'); // 从数组最后第二个元素开始，删除3个元素，并添加两个元素'添加1'、'添加2'
console.log(c); // [1,2,3,4,5,'添加1','添加2']
console.log(d); // [6,7]

不删除只添加

var a = [1, 2, 3, 4, 5, 6, 7];
var b = a.splice(0,0,'添加1','添加2'); 
console.log(a); // ['添加1','添加2',1,2,3,4,5,6,7]
console.log(b); // [], 没有删除元素，返回空数组

var c = [1, 2, 3, 4, 5, 6, 7];
var d = c.splice(-1,0,'添加1','添加2'); // 在最后一个元素的前面添加两个元素
console.log(c); // [1,2,3,4,5,6,'添加1','添加2',7] 
console.log(d); // [] 没有删除元素，返回空数组

splice用法小结：

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

---

二、数组的排序 - 均改变原数组

1. reverse()

定义： 颠倒原数组中元素的顺序

参数： 无

返回值： 返回颠倒后的数组

var a  = [1,2,3,4,5]
console.log(a.reverse())  // [5,4,3,2,1]
console.log(a)  // [5,4,3,2,1]

2. sort ()

定义： 对原数组元素进行排序(ASCII码)

语法： sort(function(a,b){})

参数： 可选（无参数默认升序排序），规定排序顺序的比较函数。比较函数的两个参数：sort的比较函数有两个默认参数，要在函数中接收这两个参数，这两个参数是数组中两个要比较的元素，通常我们用 a 和 b 接收两个将要比较的元素：

• 若比较函数返回值<0，那么a前b后;
• 若比较函数返回值=0，那么a 和 b 相对位置不变；
• 若比较函数返回值>0，那么a后b前；

返回值： 返回排序后的数组

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

// 字符串排列 看起来很正常
var a = ["Banana", "Orange", "Apple", "Mango"];
console.log(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];

情况2：有比较函数，两个参数：

• 若比较函数返回值<0，a前b后
• 若比较函数返回值=0，那么a 和 b 相对位置不变；
• 若比较函数返回值>0，a后b前

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

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

// 升序排序: a-b
// - a<b时，a-b<0，a前b后，升序排序
// - a>b时，a-b>0，a后b前，升序排序
array.sort(function(a,b){
 return a-b;
});
console.log(array); // [1,3,4,4,8,10,20,25];

// 降序排序：b-a
// - a>b时，b-a<0，a前b后, 降序排序
// - a<b时，b-a>0，a后b前, 降序排序
array.sort(function(a,b){
 return b-a;
});
console.log(array); // [25,20,10,8,4,4,3,1];

数组多条件排序：

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}]

自定义比较函数：

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"}]

---

三、数组剪切、合并 - 均不改变原数组

1. slice()

定义： 返回从startIndex开始(包括)，到endIndex(不包括)之间的元素组成的数组，且原数组不会被修改。

语法: arr.slice(startIndex, endIndex);

参数：

• startIndex(可选): 索引数值，正负皆可，从该索引处开始提取原数组中的元素，默认为0
• endIndex(可选): 索引数值(不包括)，正负皆可，在该索引处前结束提取原数组元素，默认值为数组末尾(包括最后一个元素)。

返回值： 返回剪切的新数组

var a = [1,2,3]
var b = a.slice(0,1) 
var c = a.slice()   // 不填参数则表示剪切整个数组 
console.log(a) // [1,2,3] 
console.log(b) // [1]
console.log(c) // [1,2,3]    
console.log(a===c)  // false // 注意 a !== c 
 
// 负数表示从后往前数
var d = a.slice(-1,-2)   
console.log(d) // []   从左向右截取，所以说为[]
 
var e = a.slice(-1)  
console.log(e)  // [3]

2. concat()

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

语法： var newArr = oldArr.concat(arrayX,arrayX,…,arrayX)

参数： arrayX（必须）：该参数可以是具体的值，也可以是数组对象。可以是任意多个。

返回值： 返回新数组

var a = [1,2,3]
var b = [4,5]
var c = a.concat(b)
 
console.log(a) // [1,2,3]
console.log(b) // [4,5]
console.log(c) // [1,2,3,4,5] 

补充：
ES6 扩展运算符 … 合并数组：

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

---

四、数组的查找/ 筛选 - 均不改变原数组

1. indexOf() / lastIndexOf()

定义： 查找数组中是否存在指定元素

语法: array.indexOf ( searchElement , fromIndex )

参数：

• searchElement(必须): 被查找的元素
• fromIndex(可选): 开始查找的位置(不能大于等于数组的长度，返回-1)，接受负值，默认值为0若其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。

返回值：

• indexOf 存在：返回指定元素的第一个索引
• lastIndexOf 存在：返回指定元素的最后一个索引（从数组后面往前查找）
• 不存在：返回 -1

注意： indexOf()不能识别NaN

//indexOf()
var a = [1,2,4,3,4,5]
console.log(a.indexOf(4))  // 2
console.log(a.indexOf(4,3)) // 4

//lastIndexOf()
var a = ['OB',4,'Koro1',1,2,'Koro1',3,4,5,'Koro1']; // 数组长度为10
a.lastIndexOf('Koro1',4));  // 从下标4开始往前找 返回下标2
a.lastIndexOf('Koro1',100); // 大于数组的长度 查找整个数组 返回9
a.lastIndexOf('Koro1',-11); // -1 数组不会被查找
a.lastIndexOf('Koro1',-9); // 从第二个元素4往前查找，没有找到 返回-1

使用场景 - 数组去重：

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

var array = [2,4,4,2,3,6,5,11,23,11];
var newArr = []
for(var i = 0; i < array.length; i++) {
    if(newArr.indexOf(array[i]) == -1) {
        newArr.push(array[i])
    }
}
console.log(newArr) //[2, 4, 3, 6, 5, 11, 23]

去重方法补充：

// ES6去重
function dedupe(array) {
  return Array.from(new Set(array));
}

dedupe([1, 1, 2, 3]) // [1, 2, 3]

2. some() / every()

定义：

• some检测数组中的是否有满足判断条件的元素
• every检测数组所有元素是否都符合函数定义的条件

语法： arr.some(function(currentValue, index, arr), thisValue)

参数：

• function(必须)：数组中每个元素需要调用的函数。
  • 回调函数的参数：
  1. currentValue(必须)，数组当前元素的值
  2. index(可选)，当前元素的索引值
  3. arr(可选)，数组对象本身
• thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined

返回值：

• some()
  • 如果有一个元素满足条件，则表达式返回true, 剩余的元素不会再执行检测。
  • 如果没有满足条件的元素，则返回false。
• every()
  • 如果有一个元素不满足，则整个表达式返回 false，且剩余的元素不会再进行检测。
  • 如果所有元素都满足条件，则返回 true。

//some()
var a = [1,2,3,4,5]
var b = a.some(function(current,index,array){
       return current > 4
})
var c = a.some(function(current,index,array){
       return current > 5
})
console.log(b)  // true 
console.log(c)  // false 

// 查找数组中是否有一个元素大于 10
function isBigEnough(element, index, array) {
 return (element >= 10); //数组中是否有一个元素大于 10
}
let result = [2, 5, 8, 1, 4].some(isBigEnough); // false
let result = [12, 5, 8, 1, 4].some(isBigEnough); // true

//every
var a = [1,2,3,4,5]
var b = a.every(function(current,index,array){
       return current < 6
})
var c = a.every(function(current,index,array){
       return current < 3
})
console.log(b)  // true 
console.log(c)  // false 
// 接受箭头函数写法 
[12, 5, 8, 130, 44].every(x => x >= 10); // false
[12, 54, 18, 130, 44].every(x => x >= 10); // true

3 filter()

定义： 用于对数组进行过滤。创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素
语法： arr.filter(function(currentValue,index,arr), thisValue)
参数：

• function(必须)：数组中每个元素需要调用的函数。
  回调函数的参数：
  1. currentValue(必须)，数组当前元素的值
  2. index(可选)，当前元素的索引值
  3. arr(可选)，数组对象本身
• thisValue(可选)：对象作为该执行函数时使用，传递给函数，用作“this”的值，若省略了thisValue，“this”的值为：“undefined”

//返回数组nums中所有大于5的元素。
const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const res = nums.filter((num) => {
  return num > 5;
});
console.log(res);  // [6, 7, 8, 9, 10]
//对数组进行过滤，筛选出年龄大于 18岁的数据
const arr = [{name: 'tom1',age: 23},{name: 'tom2',age: 42},{name: 'tom3',age: 17},]
const res = arr.filter(item => item.age > 18);
console.log(res);  //[{name: 'tom1',age: 23},{name: 'tom2',age: 42}]
console.log(arr);

4. ES6 - find() / findIndex()

定义：

• find()定义：用于找出第一个符合条件的数组成员，并返回该成员，如果没有符合条件的成员，则返回undefined。
• findIndex()定义：返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。

语法： arr.find(function(currentValue, index, arr), thisArg)

参数：

• function(必须)：数组中每个元素需要调用的函数。
  回调函数的参数：

  1. currentValue(必须)，数组当前元素的值
  2. index(可选)，当前元素的索引值
  3. arr(可选)，数组对象本身

• thisValue(可选)：当执行回调函数时this绑定对象的值，默认值为undefined

注意： 这两个方法都可以识别NaN，弥补了indexOf的不足。

// find
let a = [1, 4, -5, 10].find((n) => n < 0); // 返回元素-5
let b = [1, 4, -5, 10, NaN].find((n) => Object.is(NaN, n)); // 返回元素NaN

// findIndex
let a = [1, 4, -5, 10].findIndex((n) => n < 0); // 返回索引2
let b = [1, 4, -5, 10, NaN].findIndex((n) => Object.is(NaN, n)); // 返回索引4

// find
var a = [1,2,3,4]
// b在下面需要使用，则一般用find
var b = a.find(function(ele,index,array){
    return ele == 1
})
 
var c = 3
var d = b + c
console.log(a) // [1,2,3,4]
console.log(b) // 1
console.log(d) // 4
 
// 若只需判断元素是否存在
// 若果是简单数组(非对象数组)，则一般使用Array.includes(value)方法
// 如果为对象数组，则可以使用Array.some()方法
 
var a = [1,2,3]
console.log(a.includes(1))  // true
 
var a = [{"name": "xiaoming" },{"name": "xiaohong"}]
console.log(a.some(function(ele){
    return ele.name == 'xiaoming'
}))                            // true

// findIndex
var a = [1,2,3,4]
var b = a.findIndex(function(ele,index,array){
    return ele === 2
})
var c = a.indexOf(2)  
 
console.log(a)  // [1,2,3,4]
console.log(b)  // 1
console.log(c)  // 1

5. ES6 - includes()

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

语法： array.includes( searchElement , fromIndex )

参数：

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

• fromIndex(可选): 默认值为0，参数表示搜索的起始位置，接受负值。

  • 若正值超过数组长度，数组不会被搜索，返回false。
  • 若负值绝对值超过数组长度，重置从0开始搜索。

注意：

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

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

let a=['OB','Koro1',1,NaN];

a.includes(NaN); // true 识别NaN
a.includes('Koro1',100); // false 超过数组长度 不搜索
a.includes('Koro1',-3); // true 从倒数第三个元素开始搜索 
a.includes('Koro1',-100); // true 负值绝对值超过数组长度，搜索整个数组

---

五、数组的格式化 - 均不改变原数组 !important

1. forEach()

定义： 按升序为数组中含有效值的每一项执行一次回调函数。

语法： array.forEach(function(currentValue, index, arr), thisValue)

参数：

• function(必须)：数组中每个元素需要调用的函数。
  回调函数的参数：
  1. currentValue(必须)，数组当前元素的值
  2. index(可选)，当前元素的索引值
  3. arr(可选)，数组对象本身
• thisValue(可选)：当执行回调函数时this绑定对象的值，默认值为undefined

返回值： 总是返回 undefined值，即使你return了一个值。

注意： 无法中途退出循环，只能用return退出本次回调，进行下一次回调。

var array = ['a', 'b', 'c', 'e'];
array.forEach((a)=> {
  console.log(a);
});

2. map()

定义： 创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果

语法： let new_array = arr.map(function(currentValue, index, arr), thisValue)

参数：

• function(必须)：数组中每个元素需要调用的函数。
  回调函数的参数：
  1. currentValue(必须)，数组当前元素的值
  2. index(可选)，当前元素的索引值
  3. arr(可选)，数组对象本身
• thisValue(可选)：对象作为该执行函数时使用，传递给函数，用作“this”的值，若省略了thisValue，“this”的值为：“undefined”

返回值： 以数组形式返回原数组每个元素经过回调函数后的结果。

var a = [1,2,3,4,5]
// 参数同filter方法
var b = a.map(function(currentValue,index,array){
    return currentValue + 1
})
 
console.log(b) // [2,3,4,5,6]
console.log(a) // [1,2,3,4,5]

PS. forEach与map的区别 !important

forEach与map的区别主要在于map有返回值

//forEach()
var arr = [0,2,4,6,8];
 var newArr = arr.forEach(item=>{
            console.log(item)
            return item/2;
 },this);
 console.log(newArr);
//0 2 4 6 8 undefined

//map()
var arr = [0,2,4,6,8];
 var newArr = arr.map(item=>{
            console.log(item)
            return item/2;
 },this);
 console.log(newArr);
//0 2 4 6 8 [0, 1, 2, 3, 4]

3. reduce() / reduceRight()

reduce的核心思想是将 这一次处理的结果值作为下一次的初始值，继续进行处理，知道处理完所有的数据，拿到一个结果值

定义：

• reduce 为数组中的每一个元素从左到右依次执行回调函数
• reduceRight 为数组中的每一个元素从右到左依次执行回调函数

语法： arr.reduce(function(pre,cur,index,arr),initialVal)
缩写： let result = arr.reduce(callback,[initialVal])

参数：

• function(必须)：数组中每个元素需要调用的函数
  回调函数参数
  1. pre 上一次调用的返回值或者提供的初始值
  2. cur(必需)：当前元素
  3. index(可选)：当前元素的索引
  4. arr(可选)：调用reduce的数组
• initialVal（可选）：reduce调用的初始值

注意: reduce() 对于空数组不会执行回调函数。

// 当没有设置初始值
let arr = [1,3,4,6,7]
let sum = arr.reduce((pre,cur,index)=>{
   console.log(index, cur, pre);
   return pre + cur
})
console.log(sum, '求和')

实例：

// 累加和累乘
let arr3 = [1,3,4,6,7];
let sum3 = arr3.reduce((pre,cur)=> pre+cur)
let multiply = arr3.reduce((pre,cur) => pre*cur)
console.log(sum3) // 21
console.log(multiply) // 504

//数组去重
let arr4 = [1,3,2,5,3,1,2,7,8];
let newArr = arr4.reduce((pre,cur)=>{
  if(!pre.includes(cur)){
    return pre.concat(cur)
  } else {
    return pre
  }
},[]);
console.log(newArr, '数组去重') // [1, 3, 2, 5, 7, 8] , 数组去重

//计算一串字符串每个字符的出现次数
var world = 'hello  world'
var totals = [ ...world ].reduce( ( total, current ) => {
    total[ current ] ? total[ current ]++ : 1;
    return total
}, {} )
 
//totals [" ":1,d:1,e:1,h:1,l:3,o:2,r:1,w:1]

---

六、数组转字符串 - 均不改变原数组

1. join()（与字符串split()方法相反）

定义： 把数组中的所有元素通过指定的分隔符进行分隔放入一个字符串

语法： arr.join(seperator)

参数： seperator(可选)：指定要使用的分隔符，默认使用逗号作为分隔符。

返回值： 返回生成的字符串。

var a = [1,2,3,4,5]
console.log(a.join(','))  // 1,2,3,4,5
console.log(a.join('+'))  // 1+2+3+4+5
console.log(a)  // [1,2,3,4,5]

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

var a= [['OBKoro1','23'],'test'];
console.log(a.join());     // OBKoro1,23,test

var b= [{name:'OBKoro1',age:'23'},'test'];
console.log(b.join());   // [object Object],test
// 对象转字符串推荐JSON.stringify(obj);

2. toString()

定义： 将数组转换为由逗号链接起来的字符串。

参数： 无

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

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

var b= [ 'toString','演示'].toString(); // toString,演示
var a= ['调用toString','连接在我后面']+'啦啦啦'; // 调用toString,连接在我后面啦啦啦

3. toLocaleString()

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

语法： arr.toLocaleString()

参数： 无

var a=[{name:'OBKoro1'},23,'abcd',new Date()];
console.log(a.toLocaleString()); // [object Object],23,abcd,2019/5/22 下午5:21:14

---

七、ES5 / ES6 - 其他数组方法

1. ES5 - Array.isArray()

JavaScript 弱类型的语言，在类型判断上确实是有比较多的坑，在不使用 ES5 的 Array.isArray() 的情况下，单纯的typeof用来判断数组是不行的。

typeof 1 // number
typeof undefined // undefined
typeof null // object
typeof [] // object
typeof {} //object
typeof function (){} // function

定义： 用来判断一个元素是否为数组

语法：Array.isArray(object)

参数：

• object：需要检测的对象

Array.isArray([])  // true
Array.isArray({})  // false

2. ES6 - Array.from()

定义： 用于通过拥有 length 属性的对象或可迭代的对象来返回一个数组

语法： Array.from(object, mapFunction, thisValue)

注： 是Array.from，是Array的方法

参数：

• object 必需，要转换为数组的对象。
• mapFunction 可选，数组中每个元素要调用的函数。
• thisValue 可选，映射函数(mapFunction)中的 this 对象。

用法：

1. 将传入对象转为数组。用法如下：

// 字符串会被拆分为单字符数组
console.log(Array.from("『全面资源集』")); // ["『", "全", "面", "资", "源", "集", "』"]

// 可以使用from()将集合和映射转换为一个新数组
const m = new Map().set(1, 2)
					.set(3, 4);
const s = new Set().add(1)
					.add(2)
					.add(3)
					.add(4);
console.log(Array.from(m)); // [[1, 2], [3, 4]]
console.log(Array.from(s)); // [1, 2, 3, 4]

// Array.from()对现有数组执行浅复制
const a1 = [1, 2, 3, 4];
const a2 = Array.from(a1);
console.log(a1);          // [1, 2, 3, 4]
alert(a1 === a2); // false

2. 用于数组去重

const arr = [1,781,75,12,2,2,3,5,4,4,6,6,78,48,7,8,7,7,7,7,8]

console.log(Array.from(new Set(arr)))//[1, 781, 75, 12, 2, 3, 5, 4, 6, 78, 48, 7, 8]

3. ES6 - copyWithin() - 改变原数组

定义： 在原数组内部，将指定位置的成员复制到其他位置，并返回这个数组。

语法： arr.copyWithin(target, start = 0, end = this.length)

参数： 三个参数都是数值，如果不是，会自动转为数值。

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

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

copyWithin用法小结：

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

4. ES6 - fill() - 改变原数组

定义： 使用给定值，填充原数组。

语法： arr.fill(value, start, end)

参数：

• value(必须)：要填充数组的值
• start(可选)：填充的开始位置,默认值为0
• end(可选)：填充的结束位置(不包括)，默认是为this.length

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

5. ES6 - keys() & values() & entries()

遍历键名、遍历键值、遍历键名+键值

定义： 三个方法都返回一个新的 Array Iterator 对象，对象根据方法不同包含不同的值。

语法： arr.keys() arr.values() arr.entries()

参数： 无

遍历例子(摘自ECMAScript 6 入门)：

for (let index of ['a', 'b'].keys()) {
 console.log(index);
}
// 0
// 1
 
for (let elem of ['a', 'b'].values()) {
 console.log(elem);
}
// 'a'
// 'b'
 
for (let [index, elem] of ['a', 'b'].entries()) {
 console.log(index, elem);
}
// 0 "a"
// 1 "b"

在for…of中如果遍历中途要退出，可以使用break退出循环。

如果不使用for…of循环，可以手动调用遍历器对象的next方法，进行遍历:

let letter = ['a', 'b', 'c'];
let entries = letter.entries();
console.log(entries.next().value); // [0, 'a']
console.log(entries.next().value); // [1, 'b']
console.log(entries.next().value); // [2, 'c']