javascript-数组方法

  数组原型提供的方法非常之多，主要分为三种，一种是会改变原数组值的，一种是不会改变自身值的，另外一种是遍历方法。

一、改变原数组

1.Array.prototype.pop
说明：删除数组中最后一个元素，并且 返回这个元素

var arr = ['apple', 'banana', 'orange'];
var name = arr.pop();
name; //'orange'
arr;// ['apple', 'banana']

2.Array.prototype.push
说明：向数组添加 一个或多个元素,并且返回数组新的长度

var arr = ['a'];
arr.push('b');//2
arr.push(...['c', 'd']);//4
arr;//(4) ['a', 'b', 'c', 'd']

3.Array.prototype.shift
说明：删除数组的第一个元素，并且返回这个元素
 

var arr = ['apple', 'banana', 'orange'];
var item = arr.shift();
arr;//(2) ['banana', 'orange']
item// 'apple'

4.Array.prototype.splice 
说明：方法用新元素替换旧元素的方式来修改数组

var arr = [10,2,0,3,5]
arr.splice(1)//=》 [2, 0, 3, 5]
arr//=》[10] 原数组改变
var arr = [1,2,3,4,5]
arr.splice(3,1,'a','b','c')//=》从索引为‘3’的位置开始删除一个元素，并添加"a", "b", "c"
arr//=》 [1, 2, 3, "a", "b", "c", 5]

5.Array.prototype.reverse
说明：将数组内元素的位置颠倒，该方法返回对该数组的引用

var arr1 = [10,20,30]
var arr2 = arr.reverse()//=》[30, 20, 10]
arr1//=》 [30, 20, 10] 原数组会改变
arr1 === arr2; //true

6.Array.prototype.sort  （原数组会改变）
说明：对数组的元素进行排序，并返回这个数组

var arr = ['a','g','l','c','b']
arr.sort()//=》 ["a", "b", "c", "g", "l"]
var arr = [56,3,36,2,1,19,22];
arr.sort()//=》 [1, 19, 2, 22, 3, 36, 56]  10以内的数会从小到达排列，超过10就需要用下面的方法，这就涉及到 元素存储的码值问题
arr.sort(function(a,b){
  return a-b
})
//=》 [1, 2, 3, 19, 22, 36, 56]
arr//=》原数组也会改变 [1, 2, 3, 19, 22, 36, 56]
arr.sort(new Function('a','b','return b-a'));此方法也可以完成排序！！！
var arr =['abble', 'Banana','Cat', 'dog']
arr.sort(); // => ["Banana", "Cat", "abble", "dog"]
arr.sort(function(s, t){
 var a = s.toLowerCase();
 var b = t.toLowerCase();
 if (a < b) return -1;
 if (a > b) return 1;
 return 0;
})// => ["abble", "Banana", "Cat", "dog"]

二、不会改变原数组

1.Array.prototype.join（原数组不变）
说明：将数组中所有的元素链接成一个字符串，默认为逗号链接

var arr = [10,20,30]
arr.join('*')//=>转换成字符串输出连接符用‘*’     "10*20*30"
//其他使用
function repeatString(str,n){
  return new Array(n+1).join(str)
}
repeatString('%^',5)//=》传入要重复的字符串和次数两个参数"%^%^%^%^%^"

2.Array.prototype.contact 数组拼接（原数组不变）
说明：将传入的数组或元素与原数组合并，组成一个新的数组并返回

var arr = [10,20,30]
arr.concat(10,20)//=》 [10, 20, 30, 10, 20]
arr//=》 [10, 20, 30] 原数组未改变
arr.concat([1,2],20)//=》 [10, 20, 30, 1, 2, 20] 若有一个参数为数组，则把数组扁平化
arr.concat([1,2,[3,4]])//=》[10, 20, 30, 1, 2, [3,4]]若只有一个参数且为数组，数组中还存在数组，则数组中的数组不能扁平化

3.Array.prototype.slice （原数组不变）
说明：将数组中一部分元素浅复制存入新的数组对象

var arr = [10,2,0,3,5]
arr.slice(1)//=》 [2, 0, 3, 5] 取出索引为‘1’之后的所有元素
arr//=》 [10, 2, 0, 3, 5] 原数组未改变
arr.slice(2,4)//=》[0, 3]取出索引从‘2’-‘4’的元素（左闭右开）
arr.slice(-4,-2)//=》[2, 0]  参数支持负数（可把数组的长度加上负数，就是正数的索引值）
arr.slice(1,3)//=》 [2, 0]  

三、遍历方法

1.Array.prototype.forEach()
说明：指定数组的每一项都执行一次传入的函数，返回值为undefined
参数说明：val:当前正在被处理的元素，index：当前元素索引，arrobj：数组本身

var arr = [1,2,3,4,5,6,7,89,9,10]
arr.forEach((val,index,arrobj)=>{
  console.log(index+' :'+val+'|', arrobj === arr)
})
 0 :1| true
 1 :2| true
 2 :3| true
 3 :4| true
 4 :5| true
 5 :6| true
 6 :7| true
 7 :89| true
 8 :9| true
 9 :10| true

2.Array.prototype.map()
说明：该方法创建一个数组，结果是该数组每个元素执行一次提供的函数的返回值
参数说明：val:当前正在被处理的元素，index：当前元素索引，arr：数组本身

var arr1 = [1, 3, 5, 7];
var arr2 = arr1.map(val => val * 2)
arr2   //=》[2, 6, 10, 14]
原数arr1组不改变//=》 [1, 3, 5, 7]
var arr3 = arr1.map((val, index, arr) => {
  console.log(val, indx, arr )
})
 1 0  [1, 3, 5, 7]
 3 1  [1, 3, 5, 7]
 5 2  [1, 3, 5, 7]
 7 3  [1, 3, 5, 7]

3.Array.prototype.filter()
说明：该方法创建一个数组，包含通过所提供函数实现的测试的所有元素
参数说明： item  :当前正在被处理的元素，index：当前元素索引，arr：数组本身

var arr = []
arr.filter((item,index) => {
    return index % 2 === 0 || item >= 10// 返回索引值可以对2取余或者那一项大于等于10的
})
// 结果 [1, 30, 9, 65, 5]

4.数组判断Array.prototype.every()
说明：该方法测试数组内所有元素是否满足指定函数的测试，都满足返回true，有一个不满足返回false
参数说明： item  :当前正在被处理的元素，index：当前元素索引，arr：数组本身

var arr = [1,2,3,4,5,6,7,89,9,10]
arr.every(item => {
 return item > 5
})
//=》结果是false，因为需要数组的元素都满足大于5
arr.every(item => {
 return item < 100
})
//=》结果是true，数组的所有项都小于100

5.Array.prototype.some()
说明：该方法测试数组内是否有元素满足了提供函数的测试，如果有一个满足就返回true，所有元素都没有通过回调函数的测试返回值才会为false。
参数说明： item  :当前正在被处理的元素，index：当前元素索引，arr：数组本身

arr.some(item => {
  return item > 50
})//=》true，只要有一项满足，就是true

6.Array.prototype.reduce()/Array.prototype.reduceRight()
说明：方法对数组中的每个元素执行一个reducer函数(升序执行)，将其结果汇总为单个返回值。
参数说明：

Accumulator (acc) (累计器)，

Current Value (cur) (当前值) ，

Current Index (idx) (当前索引) ，

Source Array (src) (源数组)

var arr = [1,2,3,4,5,6,7,89,9,10]
arr.reduce((acc,cur) => {
// 该方法可以指定第二个参数，该参数是第一次遍历acc的值，若不传则是数组的第一个值
  return acc + cur //acc存的是上一次遍历相加的结果
});
136//=》求数组的和
// reduceRight/和reduce的遍历方向是相反的reduceRight从右到左

７.Array.prototype.indexof()/Array.prototype. lastIndexof  ()
说明：方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1

var arr = [1,2,3,4,5,6,7,89,9,10]
arr.indexOf(1)//=》0
arr.indexOf(89)//=》7返回给定元素索引
arr.indexOf(100)//=》-1 元素不存在返回-1
arr.indexOf(3,4)//-1 第二个参数代表开始检索的位置
arr.indexOf(3,-2)//=》-1 索引位置也可以是负数
lastIndexof/和indexof   的遍历方向是相反的lastIndexof从右到左

８.Array.prototype.find()
说明：方法返回数组中满足提供的测试函数的第一个元素的值
参数说明：item  :当前正在被处理的元素，index：当前元素索引，arr：数组本身

const arr1 = [5, 12, 8, 130, 44];
const found = arr1.find(item => item >  10);
console.log(found);//12

9.Array.prototype.flat()
说明：方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。
参数说明：depth:指定要提取嵌套数组的结构深度，默认值为 1
 

var deepArr = [1,2,[3,4,[5, 6,[7,8]]]];
deepArr.flat();// [1, 2, 3, 4, Array(3)]
deepArr.flat(Infinity);//[1, 2, 3, 4, 5, 6, 7, 8]