JavaScript中数组的常用方法

join(): 将数组每个元素组起一个字符串，用一个字符隔开每个元素，返回一个新的字符串。（不改变原数组）

let arrJoin = [2, 3, 5, 6] 
console.log(arrJoin.join('.')); //2.3.5.6 
console.log(arrJoin); //[ 2, 3, 5, 6 ]

功能：实现重复字符串

返回一个新创建的空数组，长度为重复字符串次数+1（因为要在两个数组元素之间插入字符串）并使用join函数插入字符串。

function repeatString(str, n) {
  return new Array(n + 1).join(str);
}
console.log(repeatString("abc", 3)); // abcabcabc
console.log(repeatString("Hi", 5)); // HiHiHiHiHi

push(): 可以接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后数组的长度。 （改变原数组）

pop()：不传参，数组末尾移除最后一项，减少数组的 length 值，然后返回移除的项。（改变原数组）

let arrPP = [1, 2, 3, 4]
console.log(arrPP.push('a', 'h')); //5
console.log(arrPP); //Array(6) [ 1, 2, 3, 4, "a", "h" ]
console.log(arrPP.pop()); // h
console.log(arrPP);  //[ 1, 2, 3, 4, "a" ]

shift()：不传参，删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined 。（改变原数组）

unshift():传参，将参数添加到原数组开头，并返回数组的长度 。（改变原数组）

let arrSU = [1, 2, 3, 4]
console.log(arrSU.unshift('a', 'h')); //6 即数组长度
console.log(arrSU); // [ "a", "h", 1, 2, 3, 4 ] ！！！！注意位置
console.log(arrSU.shift()); // a

sort ：排序，排序时，sort()方法会调用每个数组项的 toString()转型方法，然后比较得到的字符串，以确定如何排序。返回的是排序后的数组，同时原数组也排序。(改变原数组）

注意：即使数组中的每一项都是数值， sort()方法比较的也是字符串,！！按照首字母顺序,大写优先

let arrSort = [22, 3, 55, 6]
console.log(arrSort.sort()); // [ 22, 3, 55, 6 ] 
console.log(arrSort); // [ 22, 3, 55, 6 ]
let arrSort2 = ['ba', 'ffz', 'G', 'z', 'd'] 
console.log(arrSort2.sort()); //[ "G", "ba", "d", "ffz", "z" ] sort返回的是排序好的数组
console.log(arrSort2); //[ "G", "ba", "d", "ffz", "z" ]  原数组也排序好

sort()方法可以接收一个比较函数作为参数，以便我们指定哪个值位于哪个值的前面。

比较函数接收两个参数，如果第一个参数应该位于第二个之前则返回一个负数，如果两个参数相等则返回 0，如果第一个参数应该位于第二个之后则返回一个正数。
按数字从小到大排序：

function compare(val1, val2) {
  if (val1 < val2) {
    return -1
  } else if (val1 ===   val2) {
    return 0
  } else {
    return 1
  }
}
console.log(arrSort.sort(compare)); //不用compare()因为不执行，只传函数本身  [ 3, 6, 22, 55 ]

reverse：反转数组，返回的是翻转后的数组，同时原数组也反转（改变原数组）

let arrR = [13, 24, 51, 3];
console.log(arrR.reverse()); //[3, 51, 24, 13]
console.log(arrR); //[3, 51, 24, 13](原数组改变

concat() ：将参数添加到原数组的复制中,可传数组，且会自动分割数组元素，最后返回新的数组（不改变原数组）

这个方法会先创建当前数组一个复制，然后将接收到的参数添加到这个新数组的末尾，最后返回这个新的数组。在没有给 concat()方法传递参数的情况下，它只是复制当前数组并返回。

let arrC = [11, 22, 33, 44]
console.log(arrC.concat([22, 88], 'gg')); //[ 11, 22, 33, 44, 22, 88, "gg" ] 返回新的数组
console.log(arrC); //[ 11, 22, 33, 44 ] 原数组不改变

slice 截取(也可以对字符串操作)

返回从原数组中指定开始下标到结束下标之间的项组成的新数组。slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。

let arrS1 = [1, 2, 3, 4, 5]
let aS1 = arrS1.slice(1) //在只有一个参数的情况下， slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。
console.log(aS1);
let aS2 = arrS1.slice(0, 4) //如果有两个参数，该方法返回起始和结束位置之间的项——但不包括结束位置的项。**（左闭右开）**
console.log(aS2);
let aS3 = arrS1.slice(1, -2) //当出现负数时，将负数加上数组长度的值5来替换该位置的数
console.log(aS3);

splice 可以实现删除，插入，替换 ，返回的是一个新数组，是被删除后的数组，原数组是函数处理后的数组（改变原数组）

删除：可以删除任意数量的项，只需指定 2 个参数：要删除的第一项的位置和要删除的项数。例如， splice(0,2)会删除数组中的前两项
插入：可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、 0（要删除的项数）和要插入的项。例如，splice(2,0,4,6)会从当前数组的位置 2 开始插入4和6。
替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。例如，splice (2,1,4,6)会删除当前数组位置 2 的项，然后再从位置 2 开始插入4和6。

let arrSp = [1, 2, 3, 4]
let asp1 = arrSp.splice(0, 2)
console.log(arrSp); //原数组被改变 [3,4]
console.log(asp1); //被删除的数组[1,2]
let arrSp2 = [2, 3, 3, 3]
console.log(arrSp2);
console.log(arrSp2.splice(0, 1, 3)); // 替换
console.log(arrSp2);

indexOf,lastIndexOf 查找元素所在的数组下标索引，第二个参数可选，表示从哪开始查找（不改变原数组）

indexOf()：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的开头（位置 0）开始向后查找。
lastIndexOf：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的末尾开始向前查找。

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

forEach()：对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值。（不改变原数组）

参数是function类型，function中默认有传参，参数分别为：遍历的数组内容；第对应的数组索引，数组本身。

let arrE = [55, 22, 99, 1, 2, 77]
let arrEnew = arrE.forEach((val, index, arr) => {
  if (val > 50) {
    console.log('>50 indx:' + index);
    let x = val++
    return x //不会改变原数组
  } else {
    console.log('<=50 is arr: ' + arr);
  }
})
console.log(arrE);
console.log(arrEnew); //undefined
let arrE2 = [{ //对对象操作就可以
    a: 0
  },
  {
    b: 1
  },
  {
    c: 2
  }
]
let arrE3 = arrE2.forEach((val) => {
  val.x = 'x'
})
console.log(arrE2);
console.log(arrE3); //undefined

map 指“映射”，对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。（不改变原数组）

let arrMap = [1, 2, 3, 4]
let arrMapNew = arrMap.map((item) => {
  return item * item
})
console.log(arrMapNew); //[ 1, 4, 9, 16 ]

filter “过滤”功能，数组中的每一项运行给定函数，返回满足过滤条件组成的数组。（不改变原数组）

必须要return一个判断条件

var arrFil = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var arr2 = arr.filter(function (x, index) {
  return index % 3  = = = 0 || x >= 8; //return的是条件
});
console.log(arr2); //[1, 4, 7, 8, 9, 10]

every 判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回true。（不改变原数组）

var arrEve = [1, 2, 3, 4, 5];
let arrEve2 = arrEve.every((item) => {
  return item > 0
})
console.log(arrEve2);

some 判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true。（不改变原数组）

var arrSome = [1, 2, 3, 4, 5];
let arrSome2 = arrSome.some((item) => {
  return item > 4
})
console.log(arrSome2);

reduce,reduceRight（不改变原数组）

这两个方法都会实现迭代数组的所有项，然后构建一个最终返回的值。reduce()方法从数组的第一项开始，逐个遍历到最后。
而 reduceRight()则从数组的最后一项开始，向前遍历到第一项。
第一个参数为函数：函数传4 个参数：前一个值、当前值、项的索引和数组对象，第二个参数是初始值

    var arrRe = [1,2,3,4,5]
    let sum = arrRe.reduce((pre,item) => {
      return pre+item
    },100)
    console.log(sum);// 100+1+2+3+4+5
	// 100是1作为item的pre

split 第一个参数：从指定字符串位置作为分割点,第二个参数可选：限制返回最大的数组长度

let str = "aa,bb.cc,ddd;;;"
let str1 = str.split(',')
let str2 = str.split(',',2)
console.log(str1); //[ "aa", "bb.cc", "ddd;;;" ]
console.log(str2); // [ "aa", "bb.cc"]