数组（Array)
concat: 有返回值，返回拼接后的数组；不修改原数组
参数不一定都是数组
var oriArr = [1, 2, 3, 4]
var num = 100
var str = 'abc'
var appenArr = [5, 6, 7]
var comArr = oriArr.concat(num, str, appenArr)
console.log(comArr) // [ 1, 2, 3, 4, 100, 'abc', 5, 6, 7 ]
console.log(oriArr) // [ 1, 2, 3, 4 ]
slice：有返回值，返回删除的的数组；不修改原数组
slice(删除的位置，下一个保留的位置）
var oriArr = [10, 11, 20, 16]
var sliceArr = oriArr.slice(2, 3)
console.log(sliceArr) // [ 20 ]
console.log(oriArr) // [ 10, 11, 20, 16 ]
push/pop
forEach：没有返回值，不会修改原数组
var oriArr = [10, 11, 20, 16];
var forArr = [];
oriArr.forEach((item)=>{
forArr.push(item*2);
})
console.log(oriArr);//[10, 11, 20, 16]
map：有返回值，返回映射后的结果（参数1不return就是undefined）；不修改原数组
var oriArr = [10, 11, 20, 16];
var mapArr = oriArr.map((item)=>{
if(item>15)
return item;
})
filter：有返回值，返回过滤后的结果（参数1不返回就是过滤）; 不修改原数组
var oriArr = [10, 11, 20, 16];
var filterArr = oriArr.filter((item)=>{
if(item>15)
return item;
})
console.log(filterArr)//[20, 16]
reduce：reduce(function, initialValue)有返回值,返回计算结果；不修改原数组
其中function右四个参数function(total, currentValue, currentIndex, arr)
当不传入initailValue，arr[0]会当成初始值，执行n-1次
当传入initialValue，会执行n次数
var oriArr = [10, 11, 20, 16];
var reduArr = oriArr.reduce((pre,next)=>{
return pre-next;
})
console.log(reduArr);//-37
let arr = [1, 3, 9]
function noPassValue() {
return arr.reduce(function (prev, next) {
console.log('prev:', prev)
console.log('next:', next)
return prev + next
})
}
function passValue() {
return arr.reduce(function (prev, next) {
console.log('prev:', prev)
console.log('next:', next)
return prev + next
}, 0)
}
console.log('No Additional parameter:')
console.log(noPassValue())
console.log('----------------')
console.log('With 0 as an additional parameter:')
console.log(passValue())
splice: splice(index,howmany,item1,.....,itemX)有返回值，返回删除的数组，不是修改后的原数组；修改原数组
splice(删除的位置，删除的个数，...要添加的元素)
var oriArr = [10, 11, 20, 16]
var spliceArr = oriArr.splice(2, 1, 12)
console.log(spliceArr) // [ 20 ]
console.log(oriArr) // [ 10, 11, 12, 16 ]
reverse: 有返回值，返回颠倒后的数组；修改原数组
var oriArr = [10, 11, 20, 16]
var reverseArr = oriArr.reverse()
console.log(reverseArr) // [ 16, 20, 11, 10 ]
console.log(oriArr) // [ 16, 20, 11, 10 ]
join: 有返回值，返回拼接后的字符串；不修改原数组
参数可选，是分隔符，如果不写就是逗号
var oriArr = [10, 11, 20, 16]
var joinStr = oriArr.join('|')
console.log(joinStr) // 10|11|20|16
console.log(oriArr) // [ 10, 11, 20, 16 ]
字符串（String）
concat:有返回值，返回拼接后的字符串；不修改字符串
var oriStr = 'brynn'
var num = 100
var str = 'abc'
var appenArr = [5, 6, 7]
var comArr = oriStr.concat(num, str, appenArr)
console.log(comArr) // brynn100abc5,6,7
console.log(oriStr) // brynn
slice：有返回值，返回删除的的字符串；不修改原字符串
slice(删除的位置，下一个保留的位置）
var oriStr = 'brynn'
var sliceStr = oriStr.slice(2, 3)
var sliceStr2 = oriStr.slice(-2)
console.log(sliceStr2) // nn
console.log(sliceStr) // y
console.log(oriStr) // brynn
split:返回字符串数组；不修改原来的字符串
split(分隔符，数组的最大长度)
var oriStr = 'brynnbrynnbry'
var sliceStr = oriStr.split('n', 3)
console.log(sliceStr) // [ 'bry', '', 'bry' ]
console.log(oriStr) // brynnbrynnbry
indexOf: 返回搜索字串从指定位置起第一次相对于整个字符串出现的位置；返回值为-1则不存在
var str = 'Hello world!'
const index = str.indexOf('wo', 3)
console.log(index)// 6
match:
var oriStr = 'bryNn'
var arrMatch = oriStr.match(/n/gi)
console.log(arrMatch) //[ 'N', 'n' ]
var arrMatch = oriStr.match(/n/)
console.log(arrMatch) //[ 'n', index: 4, input: 'bryNn', groups: undefined ]
replace
var oriStr = 'bryNn'
var arrMatch = oriStr.replace(/n/gi, 'm')
console.log(arrMatch) //brymm
search:
var oriStr = 'bryNn'
var arrMatch = oriStr.search(/n/gi)
console.log(arrMatch) // 3
