要特别留意的是，有一些操作会修改当前数组，而某一些不会修改当前数组，返回一个新数组。

一、添加或者删除元素

1.在起始位置添加或者删除一个元素（unshift、shift）----- 修改原数组

const arr = ['a', 'b', 'c']
arr.unshift('d') //  返回4，arr为['d', 'a', 'b', 'c']
arr.shift() //  返回'd', arr为['a', 'b', 'c']

2.在末尾处添加或者删除一个元素（push、pop）----- 修改原数组

const arr = ['a', 'b', 'c']
arr.push('d') //  返回4，arr为['a', 'b', 'c', 'd',]
arr.pop() //  返回'd', arr为['a', 'b', 'c']

3.在末尾处添加多个元素（concat）----- 不修改原数组

const arr = ['a', 'b', 'c']
arr.concat('d', 'e', 'f') //  返回['a', 'b', 'c', 'd', 'e', 'f']，arr为['a', 'b', 'c']
arr.concat(['d', 'e', 'f']) //  返回['a', 'b', 'c', 'd', 'e, 'f'']，arr为['a', 'b', 'c']
arr.concat(['d', 'e'], 'f') //  返回['a', 'b', 'c', 'd', 'e', 'f']，arr为['a', 'b', 'c']

// concat 只会拆分传给它的数组，不会拆分传给它的数组里的数组元素
arr.concat([['d', 'e'], 'f']) //  返回['a', 'b', 'c', ['d', 'e'], 'f']，arr为['a', 'b', 'c']

4.从任意位置添加或者删除多个元素（splice）----- 修改原数组

第一个参数是起始修改位置的下标，第二个参数是需要删除的元素个数（不想删除就传0），其他参数就是要增加到数组里的元素。

const arr = [1, 5, 7]

arr.splice(1, 0, 2, 3, 4)  
// 分析一下, 第一个元素告诉我们index为1，第二个元素告诉我们不是删除操作，所以：在index为1的位置前，加入2, 3, 4
// 返回[]， arr为 [1, 2, 3, 4, 5, 7]

arr.splice(5, 0, 6)  
// 分析一下, 第一个元素告诉我们index为5，第二个元素告诉我们不是删除操作，所以：在index为5的位置前，加入6
// 返回[]， arr为 [1, 2, 3, 4, 5,  6, 7]

arr.splice(1, 2)  
// 分析一下, 第一个元素告诉我们index为1，第二个元素告诉我们是删除操作，删除2个元素，没有第三个元素告诉我们没有增加操作，所以：从index为1开始，连续删除2个元素
// 返回[2, 3]， arr为 [1, 4, 5,  6, 7]

arr.splice(2, 1, 'a', 'b')  
// 分析一下, 第一个元素告诉我们index为2，第二个元素告诉我们是删除操作，删除1个元素，有第三第四个元素，所以：从index为2开始，连续删除1个元素，再加入'a', 'b'
// 返回[5]， arr为 [1, 4, 'a', 'b', 6, 7]

这里要注意的是，删除元素是从index位置开始的，而添加元素是添加到index的前面

---

二、分割或者替换数组

1.获得子数组（slice） ----- 不修改原数组

第一个参数是子数组的起始位置，第二个参数是终止的位置（省略则到数组末尾）。
下标位置也可以用负数来表示倒数的元素（从-1开始，正数的是从0开始的）。

const arr = [1, 2, 3, 4, 5]
arr.slice(3)  // 截取从index为3到末尾，所以：返回[4, 5]，arr为 [1, 2, 3, 4, 5]
arr.slice(2, 4)  // 截取从index为2开始到4之前，所以：返回[3, 4]，arr为 [1, 2, 3, 4, 5]
arr.slice(-2)  // 截取从倒数第2个开始到末尾，所以：返回[4, 5]，arr为 [1, 2, 3, 4, 5]
arr.slice(1, -2)  // 截取从index为1到倒数第二个之前，所以：返回[2, 3]，arr为 [1, 2, 3, 4, 5]
arr.slice(-2, -1)  // 截取从倒数第2个开始到倒数第1个之前，所以：返回[4]，arr为 [1, 2, 3, 4, 5]

这里要注意的是，截取到第二个参数之前，不包括第二个参数位置的当前元素

2.数组内的分割和替换（copyWithin） ----- 修改原数组

ES6引入的新方法，将数组中一串有序的元素到这个数组的另外一个位置，会覆盖掉原来的内容。
第一个参数是目标位置，第二个参数是复制内容的开始参数，第三个参数是复制内容的结束参数（如果省略就到末尾）。
下标位置也可以用负数来表示倒数的元素（从-1开始，正数的是从0开始的）。

const arr = [1, 2, 3, 4]
arr.copyWithin(1, 2)  // 目标index为1，复制内容为从index为2的开始，到结尾，所以arr为[1, 3, 4, 4]
arr.copyWithin(2, 0, -2)  // 目标index为2，复制内容为从index为0的开始，到index为-2之前，所以arr为[1, 3, 1, 3]
arr.copyWithin(0, -3, -1)  // 目标index为0，复制内容为从index为-3的开始，到index为-1之前，所以arr为[3, 1, 1, 3]

这里要注意的是，复制内容截取到第三个参数之前，不包括第三个参数位置的当前元素

---

三、用指定值填充数组

1.填充数组（copyWithin） ----- 修改原数组

ES6引入的新方法，将一个固定值付给数组中任意位置。与数组构造器搭配使用更佳哦。
下标位置也可以用负数来表示倒数的元素（从-1开始，正数的是从0开始的）。

const arr = new Array(5).fill(1)  // arr被初始化为[1, 1, 1, 1, 1]
arr.fill('a')  // arr为['a', 'a', 'a', 'a', 'a']
arr.fill('b', 1)  // arr为['a', 'b', 'b', 'b', 'b']
arr.fill('c', 2, 4)  // arr为['a', 'b', 'c', 'c', 'b']
arr.fill(5.5, -4)  // arr为['a', 5.5, 5.5, 5.5, 5.5]
arr.fill(0, -3, -1)  // arr为['a', 5.5, 0, 0, 5.5]

---

四、数组元素排序

1.倒序数组（reverse） ----- 修改原数组

const arr = [1, 2, 3, 4, 5]
arr.reverse()  // arr为[5, 4, 3,  2, 1]

2.正序数组(sort) ----- 修改原数组

const arr = [5, 4, 3,  2, 1]
arr.sort()  // arr为[1, 2, 3, 4, 5]

3.按照指定排序函数来排序(sort) ，可用于对象数组！----- 修改原数组

const arr = [{ name:  'Suzanne' }, { name:  'Jim' }, { name:  'Trevor' }, { name:  'Amanda' }]
arr.sort()  // arr没有变化

arr.sort( (a, b) => a.name > b.name)  // arr按照元素name属性的字母顺序排序，大于号为正序
// arr为[{name: "Amanda"}, {name: "Jim"}, {name: "Suzanne"}, {name: "Trevor"}]

arr.sort( (a, b) => a.name[1] < b.name[1] )  // arr按照元素name属性的第二个字母的字母顺序排序，小于号为倒序
// arr为[{name: "Suzanne"}, {name: "Trevor"}, {name: "Amanda"}, {name: "Jim"}]

---

五、搜索元素

1.返回跟所要查找的内容完全相同的第一个元素的下标（indexOf、lastIndexOf）

第一个元素是匹配的内容，第二个元素查找起始的位置的下标。
如果没有找到，则会返回 -1。

const arr = [1, 5, 'a', 5]
arr.indexOf('a') // 返回2
arr.indexOf(5) // 返回1
arr.indexOf(5, 2) // 返回3
arr.indexOf(9) // 返回-1
arr.lastIndexOf('a') // 返回2
arr.lastIndexOf(5) // 返回3
arr.lastIndexOf(9) // 返回-1

2.通过指定函数来查找内容相同的第一个元素的下标(findIndex、findLastIndex)

const arr = [ { id: 5, name: 'Judth'}, { id: 7, name: 'Francis'} ]
arr.findIndex( o => o.id === 5 ) // 返回0
arr.findIndex( o => o.name === 'Francis' ) // 返回1
arr.findIndex( o => o.id === 3) // 返回-1
arr.findIndex( o => o.name === 'asdsadas' ) // 返回-1

3.通过制定函数来查找内容相同的元素（find）

find方法的第一个参数是搜索函数，第二个参数则为绑定this的对象。
搜索函数第一个参数为数组的每一个元素，第二个参数为每一个元素对应的下标，第三个元素是数组本身。
返回值为找到的元素。

const arr = [1, 17, 16,  5, 4, 16, 10, 3, 47]
arr.find( (x, i) => i > 2 && Number.isInteger(Math.sqrt(x)))  // return 4

4.查找某个元素是否在数组中存在（some）

一旦找到符合条件的元素，就会返回true，否则返回false。

const arr = [5, 7, 12, 15, 17]
arr.some(x => x % 2 === 0)  // return true; 12是偶数
arr.some(x => Number.isInteger(Math.sqrt(x))  // return false; 没有平方数

5.查找是否每个元素都符合（every）

const arr = [4, 6, 16, 36]
arr.every(x => x % 2 === 0)  //return true; 没有奇数
arr.every(x => Number.isInteger(Math.sqrt(x))  // return false; 6不是平方数

---

六、得到想要的新数组

1.一一映射（map） ---- 不修改原数组

const items = ['Widget', 'Gadget']
const prices = [9.25, 22.95]
// 这里要把对象用小括号包围，如果没有箭头函数会把{}里的内容当做程序块
const cart = items.map((x, i) => ({ name: x, price: prices[i]})) 
// cart为[{name: "Widget", price: 9.25}, {name: "Gadget", price: 22.95}]

2.过滤，删除不需要的元素（filter） ---- 不修改原数组

const arr = [5, 8, 4, 13]
const filters = arr.filter(x => x%2 !== 0)  // return [5, 13]；删除了不是偶数的元素