数组
Array.from()
Array.from([1,2,3]) // [1,2,3] 可以用于数组浅拷贝，可以将有length属性的伪数组转为数组
// Array.from 第二个参数是一个回调函数，如果指定了该函数，每一个元素都会执行这个函数
Array.from([{age: 18}], x => ({...x, name: 'li'})) // [{age: 18, name: 'li'}]
利用Array.from 将set 对象 转为数组，利用set 特性不能重复，将数组去重
function combin() {
console.log(arguments) // [] 返回函数的传入参数，是一个数组
let arr = [].concat.apply([], arguments)
// 也可以用call let arr = [].concat.call([], ...arguments)
return Array.from(new Set(arr))
}
let m = [1,2,3]
let n = [1,2,3,4]
comnin(m,n) // [1,2,3,4]
Array.isArray()
// 实现原理
function isArray(arg) {
return Object.prototype.toString.call(arg) === '[object Array]'
}
filter()
const arr = [{age: 18,name: 'zhangsan'},{age: 18,name: 'lisi'},{age: 19,name: 'wangwu'},{age: 20,name: 'zhaoliu'}]
const result = arr.filter(item=> {
if (item.name === 'lisi' || item.name === 'wangwu') {
return item
}
})
// result : [{age: 18,name: 'lisi'},{age: 19, name: 'wangwu'}]
result.map(item => item.age)
// [18,19]
// 利用filter 进行数组过滤搜索
const searchInput = (query) => {
return obj.filter((item)=>{
return item.name.toLowerCase().indexOf(query.toLowerCase()) > -1
})
}
searchInput('z') // [{age: 18, name: "zhangsan"},{age: 20, name: "zhaoliu"}]
forEach()
相当于for 循环
const list = [1,2,3,4]
const copylist = [];
for (let i= 0; i< list.length; i++) {
copylist.push(list[i])
}
list.forEach(item => copylist.push(item * 2))
map()
// 返回数组，处理数组对象
const arrs = [{name:'zhang',age:25},{name:;'li', age:18},{name:'wang',age: 16}]
arrs.map(item=>({
...item,
name: '666',
sex: item.age
}))
// [{name:'666',age:25, sex: 25},{name:;'666', age:18, sex:18},{name:'666',age: 16, sex:16}]
arrs.map(item=> {
let obj = {};
obj[item.name] = item.age;
return obj;
})
// [{zhang: 25},{li: 18},{wang: 16}]
reducer() reducerRight()
归并将数组元素前一个后一个相加，可以计算数组合
const list = [1,2,3]
list.reducer((pre, prv)=>{
return pre +prv
}) // 6
// reducerRight 可以从右往左加
var a = ['1', '2', '3', '4', '5'];
var left = a.reduce(function(prev, cur) { return prev + cur; });
var right = a.reduceRight(function(prev, cur) { return prev + cur; });
console.log(left); // "12345"
console.log(right); // "54321"
every() some() includes()
返回一个布尔值
every 和 some 都是里面传一个函数
find() findIndex()
// 可以设置查找的条件。 indexof 和lastIndexOf 只能是值
里面传一个函数，返回查找到的第一个元素，findIndex 是返回查找到元素的下标，找不到为-1
注意：只返回找到的第一个
const list = [1,2,3,4,5,6,7]
list.find(ite =>ite>2) // 3
list.findIndex(ite => ite > 4) // 4
indexOf()
查找某个元素，找到为第一个元素的下标，找不到为-1
lastIndexOf()
找最后一个元素所在的下标，找不到为-1
slice()
截取数组，不改变原数组，若截取的值大于数组长度，返回空数组
不包含开始，包含结束
可以实现浅拷贝
arr.slice()
fill()
填充数组元素，有三个参数
let arr = [1,2,3,4]
arr.fill(要填充的元素，从哪里开始填充，到哪里结束(不包含结束))
arr.fill('x',1,3) // [1,x, x, 4]
[1, 2, 3].fill(4); // [4, 4, 4]
flat()
数组扁平化 flat(Infinity) 可以展开任意深度的嵌套数组
join()
将数组转为字符串，如果传了参数，就按参数依次将各个元素连接起来，如果数组是undefined或者null，将转为空串
toString()
将数组转为字符串，如果数组是undefined或者null，将转为空串
concat()
let n = [1,2]
let m = [3,4]
let s = m.concat(n) // [3,4,1,2] // 不会改变原数组 返回新数组
let g = [].concat(s) // [3,4,1,2] //数组拷贝
push() unShift()
后增，前增，改变原数组，返回新增后的数组长度
pop() shift()
后删，前删，改变原数组，返回删除的元素
reverse()
将数组反转 改变原数组， 返回反转后的数组
let arr = [1,2,3]
arr.reverse() // [3,2,1] 改变原数组，返回反转后的数组
splice()
改变原数组， 返回删除后的数组，没有删除返回空数组
splice(从哪里开始，删除几个，新增几个)
sort()
改变元素组，返回排序后的数组
var numbers = [4, 2, 5, 1, 3];
numbers.sort((a, b) => a - b); // [1,2,3,4,5]
numbers.sort((a, b) => b - a); // [5,4,3,2,1]
