数组问题集合--更新中

1. 多个数组长度相加

const arrays = [[1,2], [3,4], [5]]; // 示例数组
// 使用 reduce() 函数将所有数组的长度求和
const sumOfLengths = arrays.reduce((accumulator, currentArray) => accumulator + currentArray.length, 0);
console.log(sumOfLengths); // 输出结果为 6（[1,2]、[3,4]、[5]三个数组的长度分别为 2、2、1）

2.获取对象数组中某属性的所有值。如果是要获取具体第几个属性的值，倒是可以用arr[i].name的方法来实现。若是全部的属性的值，并返回一个新的数组嘞，思路是加循环遍历

/*一、from方法*/
var arr = [
     {id: 1,name: "小明"},
     {id: 2, name: "小红"},
     {id: 3,name: "小蓝"}
 ]
var n = Array.from(arr,({name})=>name);
console.log(n); // ["小明", "小红", "小蓝"]

/*二、map方法*/
var userName = arr.map((item)=>{
    return item.name;
})
console.log(userName); // ["小明", "小红", "小蓝"]

/*map方法抽取成公共方法*/
function getAttrs(array,attr) {
    var result = array.map((item)=>{
        return item[attr];
    })
    return result;
}
console.log(getAttrs(arr,'id')); //  [1, 2, 3]
console.log(getAttrs(arr,'name')); // ["小明", "小红", "小蓝"] 
                         
/*三、forEach 方法*/
var userName = [];
arr.forEach((item)=>{
    userName.push(item.name);
})
console.log(userName); //  ["小明", "小红", "小蓝"]

 3.遍历数组的常见几种方式

/*一、普通for循环*/
for(var i = 0; i < arr.length;i++  ){ ... }

/*二、forEach循环
forEach接收一个回调函数作为参数,而这个回调函数有接受三个参数,作为参数。item是每个元素,index元素在数组中的下标,arr数组本身。没有返回值！*/
arr.forEach((item,index,arr)=>{ ... })
   
/*三、map循环   
map的用法和forEach差不多。但是map是有返回值的。他的返回值是一个新数组  arr---->[1,2,3]，brr---->[2,4,6] */
var brr= arr.map((item,index,arr)=>{ return item * 2; })
    
/*四、filter
接受一个回调函数作为参数,返回值是一个新数组*/
var arr = [  {name:'张三',age:'20'}, {name:'李四',age:"50"} ]
arr.filter(item=>{
        return item.name; //返回值是 arr本身，所以元素的name都为true
})
arr.filter(item=>{
        return item.age>30; //[{name:"李四",age:"50"}]
})

/*五、every遍历
every()是对数组中的每一项运行给定函数，如果该函数对每一项返回true,则返回true。(全部符合条件)*/
var arr=[50,6,70,80];
arr.every((item,index,arr)=>{
        return item > 50; //每一项数据都要大于50
}) //false 

/*六、some遍历
some()是对数组中每一项运行指定函数，如果该函数对任一项返回true，则返回true。(只要有一个符合)*/
var arr=[50,6,70,80];
arr.some((item,index,arr)=>{
        return item > 50; //只要有一项数据都要大于50
}) //true

/*七、reduce*/
//reduce()方法接收一个函数作为累加器,数组中每个值(从左往右)开始缩减,最重为一个值
var arr= [1,2,3];
arr.reduce((a,b) => {
        return a + b;//6   
})
arr.reduce((previousValue,currentValue,index,arr)=>{
        return previousValue + currentValue;
})
//reduce还有第二个参数，我们可以把这个参数作为第一次调用callback时的第一个参数，上面这个例子因为没有第二个参数，所以直接从数组的第二项开始，如果我们给了第二个参数为5
arr.reduce((previousValue,currentValue,index,arr)=>{
        return previousValue + currentValue;
},5)
// 6, 8 ,11。第一次调用的previousValue的值就用传入的第二个参数代替

/*八、reduceRight
reduceRight()方法的功能和reduce()功能是一样的，不同的是reduceRight()从数组的末尾向前将数组中的数组项做累加。
reduceRight()首次调用回调函数callbackfn时，prevValue 和 curValue 可以是两个值之一。如果调用 reduceRight() 时提供了 initialValue 参数，则 prevValue 等于 initialValue，curValue 等于数组中的最后一个值。如果没有提供 initialValue 参数，则 prevValue 等于数组最后一个值， curValue 等于数组中倒数第二个值。*/
var arr = [0,1,2,3,4];
arr.reduceRight(function (preValue,curValue,index,array) {
        return preValue + curValue;
}); // 10 --- 7 = 4 + 3第一次；9 = 2 + 7第二次； 10 = 9 + 1第三次； 10 = 10 + 0第四次 

/*九、find
find()方法返回数组中符合测试函数条件的第一个元素。否则返回undefined */
var stu = [
    {name: '张三',gender: '男',age: 20},
    {name: '王小毛',gender: '男',age: 20},
    {name: '李四',gender: '男',age: 20}
]
function getStu(element){
    return element.name == '李四'
}
 stu.find(getStu)  //返回结果为 {name: "李四", gender: "男", age: 20} 

/*十、findIndex
对于数组中的每个元素，findIndex 方法都会调用一次回调函数（采用升序索引顺序），直到有元素返回 true。只要有一个元素返回 true，findIndex 立即返回该返回 true 的元素的索引值。如果数组中没有任何元素返回 true，则 findIndex 返回 -1。findIndex 不会改变数组对象!!!!!*/
var arr= [1,2,3];
arr.findIndex(function(x) { x == 2; }); //1
arr.findIndex(x => x == 4);//-1

/*十一、keys,values,entries
 ES6 提供三个新的方法 —— entries()，keys()和values() —— 用于遍历数组。它们都返回一个遍历器对象，可以用for...of循环进行遍历，唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历*/
for (let index of ['a', 'b'].keys()) {
    console.log(index);
} // 0 // 1
for (let elem of ['a', 'b'].values()) {
    console.log(elem);
} // 'a' // 'b'
for (let [index, elem] of ['a', 'b'].entries()) {
    console.log(index, elem);
} // 0 "a" // 1 "b"

/*十二、for...of...循环*/
for(let item of arr){ ... }

4.对象遍历

/*一、Object.keys()遍历 
返回一个数组,包括对象自身的(不含继承的)所有可枚举属性(不含Symbol属性).*/
var obj = {'0':'a','1':'b','2':'c'};
Object.keys(obj).forEach(function(key){
     console.log(key,obj[key]);
});//输出结果： 0 a  1 b  2 c

/*二、使用for…in…遍历
循环遍历对象自身的和继承的可枚举属性(不含Symbol属性).*/
var obj = {'0':'a','1':'b','2':'c'};
for(var i in obj) {
     console.log(i,":",obj[i]);
};//输出结果： 0 : a  1 : b  2 : c

/*三、Object.getOwnPropertyNames(obj)遍历
返回一个数组,包含对象自身的所有属性(不含Symbol属性,但是包括不可枚举属性).*/
var obj = {'0':'a','1':'b','2':'c'};
Object.getOwnPropertyNames(obj).forEach(function(key){
    console.log(key,obj[key]);
});//输出结果： 0 : a  1 : b  2 : c

/*四、Reflect.ownKeys(obj)遍历
返回一个数组,包含对象自身的所有属性,不管属性名是Symbol或字符串,也不管是否可枚举.*/
var obj = {'0':'a','1':'b','2':'c'};
Reflect.ownKeys(obj).forEach(function(key){
    console.log(key,obj[key]);
});//输出结果： 0 : a  1 : b  2 : c

/*五、使用for…of…遍历*/
const searchObj = {
  title: 'javascript',
  author: 'Nicolas',
  publishing: "O'RELLY",
  language: 'cn',
};
for(let key of searchObj){
      console.log(key)
}