js数组常见的一些方法

自我学习记录（一直会更新🌺）

常见的方法14种方法：push、pop、unshift、shift、concat、join、slice、splice、reverse、sort、toString、toLocaleString、valueOf、toSource

方法名	说明
push	向数组的末尾添加一个或多个元素，并返回新数组的长度。arrayObject.push(newelement1,newelement2,....,newelementX)
pop	删除并返回数组的最后一个元素。arrayObject.pop()
unshift	向数组的开头添加一个或多个元素，并返回新数组的长度。arrayObject.unshift(newelement1,newelement2,....,newelementX)
shift	单词表明去掉的意思：删除并返回数组的第一个元素。arrayObject.shift()
concat🌺	链接两个或更多的数组，并返回结果。arrayObject.concat(arrayX,arrayX,......,arrayX)
join🌺	把数组的全部元素放入一个字符串。元素经过指定的分隔符进行分隔。 arrayObject.join(分隔符)
slice🌺	从某个已有的数组返回选定的元素。arrayObject.slice(start,end)：start必选，end可选，返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。该方法并不会修改数组，而是返回一个子数组。
splice🌺	删除元素，并向数组添加新元素。arrayObject.splice(index,howmany,item1,.....,itemX)：index（整数，规定添加/删除项目的位置）和howmany（必需。要删除的项目数量。若是设置为 0，则不会删除项目。）必选，item。。。可选。若是从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。若是是添加就返回空数组。
reverse	颠倒数组中元素的顺序。arrayObject.reverse()
sort	对数组元素进行排序。arrayObject.sort(sortby)sortby可选。规定排序顺序。必须是函数。
toString	把数组转换为字符串，并返回结果。
toLocaleString	把数组转换为本地字符串。
valueOf	返回数组对象的原始值
toSource	返回该对象的源代码

其余好用的方法： foreach（）、map（）、filter（）、reduce（）、reduceRight（）、every（）、some（）、indexOf（）、lastIndexOf()、find（）、findIndex（）、includes（）

方法名	说明
foreach（）	循环遍历数组，参数（当前处理元素、数组索引、数组自己），无返回值
map（）	映射 ,其结果是该数组中的每一个元素都调用一个提供的函数后返回的结果，有返回值
filter（）	过滤出知足过滤条件的数组，有返回值
reduce（）	迭代数组的全部项，而后构建一个最终返回的值。reduce()方法从数组的第一项开始，逐个遍历到最后。
reduceRight（）	迭代数组的全部项，而后构建一个最终返回的值。reduceRight()则从数组的最后一项开始，向前遍历到第一项。
every（）	判断数组中的每一项是否都知足条件，只有全部项都知足条件的返回true
some（）	判断数组中是否存在知足条件的项，只要有一项知足就会返回true
indexOf（）	返回要查找的项在数组中出现的第一个索引位置，indexof()是从数组开头查找，若是不存在，则返回-1
lastIndexOf()	返回要查找的项在数组中出现的第一个索引位置，lastIndexOf()是从数组的末尾查找，若是不存在，则返回-1
find（）	方法返回数组中知足提供的测试函数的第一个元素的值。不然返回 undefined。
findIndex（）	方法返回数组中知足提供的测试函数的第一个元素的索引。不然返回-1。
includes（）
instanceof	检测数组
Array.isArray()	检测数组

1.forEach():循环遍历数组，参数（当前处理元素、数组索引、数组自己），无返回值

array.forEach((item, index, array) {
	// do something
}, thisArg)

arr.forEach(item => console.log(item))
复制代码

2.map():映射 ,其结果是该数组中的每一个元素都调用一个提供的函数后返回的结果，有返回值

let array = arr.map(function callback(currentValue, index, array) {
	// do something
}, thisArg)
复制代码

3.filter() 过滤出知足过滤条件的数组，有返回值

var array = arr.filter(function callback(currentValue, index, array) {
	// do something
}, thisArg)
复制代码

4.reduce() 和 5.reduceRight():

这两个方法都会实现迭代数组的全部项，而后构建一个最终返回的值。reduce()方法从数组的第一项开始，逐个遍历到最后。而 reduceRight()则从数组的最后一项开始，向前遍历到第一项。

参数（前一个值，当前值， 索引项， 数组对象） 回调函数第一次执行时，accumulator 和 currentValue 的取值有两种状况：调用 reduce 时提供initialValue，accumulator 取值为 initialValue ，currentValue 取数组中的第一个值；没有提供 initialValue ，accumulator 取数组中的第一个值，currentValue 取数组中的第二个值。

array.reduce(function(accumulator,currentValue,currentIndex,array),initialValue) 复制代码

🌺小试牛刀🌺

1.url中的查询参数解析成字典对象

var newurl = 'http://dev.cekid.com:9018/r/products?store_code=8002&citycode=320100&cityname=%E5%90%88%E8%82%A5%E5%B8%82&cityid=340100&entityid=8029&entityname=%E5%90%88%E8%82%A5%E7%BE%8E%E6%B8%B8'
function parseUrl(url) {
	var arr = url.slice(url.indexOf('?')+1).split('&')
	var newArr = arr.reduce((prev, next) => {
		prev[next.split('=')[0]] = next.split('=')[1]
		return prev
	}, {})
	return newArr
}
parseUrl(newurl)
复制代码

2.二维数组降级

function concatArr(arr) {
	var newArr = arr.reduce((prev, next) => {
		return prev.concat(next)
	}, [])
	return newArr
}
concatArr([[1, 2], [2, 3, 4, 1], [2, 2]])
// [1, 2, 2, 3, 4, 1, 2, 2]
复制代码

3.数组求和

function total(arr) {
	let sum = arr.reduce((prev, next) => {
		prev = prev + next
		return prev
	}, 0)
	return sum
}
total([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) // 55
复制代码

6.every():判断数组中的每一项是否都知足条件，只有全部项都知足条件的返回true

function isNumber (arr) {
	let _arr = arr.every((item) => {
		return typeof(item) === 'number'
	})
	return _arr
}
isNumber([1, 2, 3, 4]) // true
isNumber([1, 2, 'sa', 4]) // false
复制代码

7.some():判断数组中是否存在知足条件的项，只要有一项知足就会返回true

function isNumber (arr) {
	let _arr = arr.some((item) => {
		return typeof(item) === 'number'
	})
	return _arr
}
isNumber(['ww', 'mm', 'sa', 4]) // true
isNumber(['ww', 'mm', 'sa', 'true']) // false
复制代码

8.indexOf() 和 9.lastIndexOf()

两个方法都是返回要查找的项在数组中出现的第一个索引位置，不一样的是indexof()是从数组开头查找，lastIndexOf()是从数组的末尾查找，若是不存在，则返回-1 参数（要查找的项，【能够选的项】查找起点位置index）

arr.indexOf(searchElement)
arr.indexOf(searchElement[, fromIndex = 0])
arr.lastIndexOf(searchElement[, fromIndex = arr.length - 1])

// switch 控制是从数组开始位置查，仍是数组末尾查
function _indexOf(arr, item, index, _switch) {
	return _switch ? arr.indexOf(item, index) : arr.lastIndexOf(item, index)
}

_indexOf([1, 2, 'mm', 3, 2, 'mm', 1], 'mm', 0, true) // 2
_indexOf([1, 2, 'mm', 3, 2, 'mm', 1], 'mm', 6, false) // 5
_indexOf([1, 2, 'mm', 3, 2, 'mm', 1], 'mm', 4, false) // 2
_indexOf([1, 2, 'mm', 3, 2, 'mm', 1], 'mm', 1, false) // -1
复制代码

10.find():方法返回数组中知足提供的测试函数的第一个元素的值。不然返回 undefined。

11.findIndex():方法返回数组中知足提供的测试函数的第一个元素的索引。不然返回-1。

function findV(arr, _switch) {
	let newValue = null
	if (_switch) {
		newValue = arr.find(item => {
			return item > 20
		})
	} else {
		newValue = arr.findIndex(item => {
			return item > 20 
		})
	}
	return newValue
} 
findV([1, 3, 20, 11, 22], true) // 22
findV([1, 3, 20, 11, 22], false) // 4
复制代码

12.includes()方法用来判断一个数组是否包含一个指定的值，若是是，返回 true或 false。

13.instanceof 和 Array.isArray(): 检测数组

var arr = [1, 2, 3, 4, 5, 6]
var arr2 = {}
arr instanceof Array // true
Array.isArray(arr) // true
Array.isArray(arr2) // false
复制代码