数组相关常用计算方法

var arr = [1, 12, 23, 45, 1, 23, 5, 34, 2, 3, 1]

数组从小到大排序

arr.sort((a, b) => { return a - b })
// [1, 1, 1, 2, 3, 5, 12, 23, 23, 34, 45]

数组去重

let result = arr.sort().reduce((init, current) => {
  if (init.length === 0 || init[init.length - 1] !== current) {
    init.push(current)
  }
  return init
}, [])
console.log(result)
// [1, 12, 2, 23, 3, 34, 45, 5]

数组对象去重

let person = [
     {id: 0, name: "小明"},
     {id: 1, name: "小张"},
     {id: 2, name: "小李"},
     {id: 3, name: "小孙"},
     {id: 1, name: "小周"},
     {id: 2, name: "小陈"},   
]

let obj = {}
let peon = person.reduce((cur,next) => {
    obj[next.id] ? "" : obj[next.id] = true && cur.push(next)
    return cur
},[]) //设置cur默认类型为数组，并且初始值为空的数组
console.log(peon)
// [{id: 0, name: "小明"}, {id: 1, name: "小张"}, {id: 2, name: "小李"}, {id: 3, name: "小孙"}]

求和

let list = [
	{ count:1 },
	{ count:2 },
	{ count:3 }
]
let total = 0
total= list.reduce((a, b) => { return a + (b.count- 0 || 0) }, 0)

冒泡排序

function bsort (arr) {
	let len = arr.length
	for (let i = 0; i< len; i++) {
		for (let j = 0; j < len - 1 - i; j++) {
			if (arr[j] > arr[j+1]) {
				var temp = arr[j]
				arr[j] = arr[j+1]
				arr[j+1] = temp
			}
		}
	}
	return arr
}
 var arr = [3,5,1,4,9,2,7,8,6]
console.log(bsort(arr))
// [1, 2, 3, 4, 5, 6, 7, 8, 9]

多维数组遍历(递归)

// 已知：某个商品的categoryId, 所有分类列表为多维数组，categoryId为任意级别的id,
// 求对应的categoryName = ?
getCategoryName(category) {
	this.itemList.map(item => {
		if (item.id === categoryId) {
			return item.name
		} else {
			if (item.childs && item.childs.length) {
				var loopChilds = function(childs) {
					childs.map(child => {
						if (child.id === categoryId) {
							return item.name
						} else {
							if (child.childs && child.childs.length ) {
								loopChilds(item.childs)
							}
						}
					})
				}
				loopChilds(item.childs)
			}
		}
	})
}

Array.from()

Array.from()方法将两类对象转为真正的数组：类似数组的对象（array-like onject）和可遍历的对象（包括ES6新增的数据结构Set和Map）。

let arrayLike = {
	'0': 'a',
  '1': 'b',
  '2': 'c',
  length: 3
}
// Es5写法
var arr1 = [].slice.call(arrayLike) // ['a', 'b', 'c']
// es6
var arr2 = Array.from(arrayLike)

实际应用中，常见的类似数组的对象是DOM操作返回的NodeList集合，以及函数内部的arguments对象，Array.from都可以将他们转为真正的数组。

Array.from({length: 3}) // [undefined, undefined, undefined]

const toArray = (() => {
  Arrat.form ? Array.from : obj => [].slice.call(obj)
})

Array.from(arrayLike, x => x * x)
// 等同于
Array.from(arrayLike).map(x => x * x)

Array.from([1, 2, 3], (x) => x * x)

Array.of()

Array.of()方法用于将一组值，转换为数组。

Array.of(2,4,6) // [2, 4, 6]
Array.of(3) // [3]
Array.of(3).length // 1
Array.of() // []

Array() // []
Array(3) // [ , , ,]
Array(1,2) // [1, 2]
Array(5,7,3) // [5, 7, 3]

上面代码中，Array方法没有参数、一个参数、三个参数时，返回结构都不一样，只有当参数个数不少于2个时，Array()才会返回有参数组成的新数组，参数个数只有一个时，实际上是指定数组的长度。

Array.of总是返回参数值组成的数组。如果没有参数，就返回一个空数组。

Array.find()和Array.findIndex()

find()方法用于找出第一个符合条件的数组成员。他的参数是一个回调函数所有数组成员一次 执行回调函数，直到找出第一个返回值为true的成员，然后返回该成员，如果没有符合条件的成员，则返回undefined。

finIndex()返回第一个符合条件的数组成员的位置，如果所有成员都不满足则返回-1。

[2, 5, 10, 15].find((value, index, arr) => {
  return vlaue > 9
}) // 10

[2, 5, 10, 15].findIndex((value, index, arr) => {
  return value > 9
}) // 2

上面两个方法都可以接受第二个参数，用来绑定回调函数的this对象。

function f (v) {
  return v > this.age
}
let person = {name: 'John', age: 20}
[10, 12, 34, 15].find(f, person) // 34

另外这两个方法都可以发现NaN，弥补了数组的indexOf方法的不足。

[NaN].indexOf(NaN) // -1
[NaN].findIndex(y => { Object.is(NaN, y)}) // 0

Array.includes()

Array.prototype.includes方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes的方法类似，ES6引入了该方法。

[1, 3, 5].includes(3) // true
[1, 2, NaN].includes(NaN) // true

该方法的第二个参数表示搜索的起始位置，默认为0，如果第二个参数为负数，则表示倒数的位置，如果他大于数组长度（比如第二参数为-4，但数组成都为3），则会重置为从0开始。

[1, 2, 3].includes(3, 3) // false
[1, 2, 3].includes(3, -1) // true
[1, 2, 3].includes(3, -4) // true

[NaN].indexOf(NaN) // -1
[NaN].includes(NaN) // true

下面代码用来检查是否支持该方法，如果不支持，部署一个简易的替代版本

const contains = ((arr, value) => {
  Array.prototype.includes ? (arr, value) => {arr.includes(value)} : 
  (arr, value) => {arr.some(el => {return el === value})}
})
contains(['foo', 'bar'], 'baz')

Object.create()

Object.create()方法创建一个新对象，使用现有的对象来提供新创建的对象的__ proto __。

const person = {
  isHuman: false,
  printIntroduction: function () {
    console.log(`My name is ${name}, Am I human? ${isHuman}`)
  }
}
const me = Object.create(person)
me.name = 'Job'
me.isHuman = true
me.printIntroduction() // My name is Job, Am I human? true