总结的一些数组算法

//fill     
const arr = new Array(100).fill(0).map(function(item,index)
         {
             return index + 1 
        })
         console.log(arr);[1....100]
// Array.from() 
const arr = Array.from(Array(100), (v, k) => k + 1)

//下面使用...的方式生成的
const ary = [...Array(100).keys()] 

这可以生成一个用于大量测试数据的数组

通常情况下

new Array(100)也会生成一个位数为100给空位的数组 这个数组是不能够被

比如map()，forEach方法使用的

但是[...new Array(4)]可以给空位设置默认值undefined 从而可以使用上面的这些方法

比如map()，forEach(),every()等等

 

数组的浅拷贝

     const arr = [1,2,3]
     const arrClone = [...arr]
     对象也可以这样浅拷贝
     const obj = {a:1}
     const objClone = {...obj}
     console.log(arrClone);
     console.log(objClone);

这里也是使用es6...符比之前的浅拷贝更好用 不用单独写方法 但是深拷贝可不是这样的

深拷贝要更难 ，以后会写这两个拷贝

// 数组合并
        // const arr1 = [1, 2, 3]
        // const arr2 = [4, 5, 6]
        // const arr3 = [7, 8, 9]
        // const arr = [...arr1,...arr2,...arr3]
        // console.log(arr);[1,2,3,4,5,6,7,8,9]

这里使用的是concat方法实现的合并

几个不同的数组去重复的办法

第一个是个人认为最简单和快捷的

使用的Set这个新的数据结构处理一个数组的话会自动的去从

坦率说，就是set()生成的对象里面只能有一个

    const arr = [1,1,2,2,3,4,5,6,'123']
    const newArr = [...new Set(arr)]
      也可以使用
    const aa = new Set(arr)
    const abc = Array.from(aa)

第二个数组去重的办法遍历

        function arrayUnique(array)
        {
            var result = [];
            for(var i = 0;i <array.length;i++)
            {
                if(result.indexOf(array[i]) === -1)
                {
                    result.push(array[i])
                }
            }
            return result
        }
        var array = [1,4,5,7,4,8,1,10,4] //[1,4,5,7,8,10]

这种一般是最简单也是最普遍的办法

第三个办法就是使用到了对象的键值对来实现去重

主要思想是新建一个JS对象以及一个新的数组，对传入的数组进行遍 历，判断当前遍历的值是否为JS对象的键。如果是，表示该元素已出现过，则不 做处理；如果不是，表示该元素第一次出现，则给该JS对象插入该键，同时插入 新的数组，最终返回新的数组。 这里使用的是对象的[]的方法 object[key]如果存在这个对象 则object[key]内部存在就会为true 我们需要不存在 不存在则把建名也就是原来的数组元素存入新数组 也就是被去重之后的数组

function arrayUnique2(array) {
 var obj = {}, result = [], val, type;
 for (var i = 0; i < array.length; i++) {
 val = array[i];
 if (!obj[val]) {
 obj[val] = 'yes'; //这里可以作为存入的效果 每次执行之后都会往obj中存入一个{array[i]:yes,array[i+1]:yes}以此类推达到判断存在过不的效果
 result.push(val);
 }
 }
 return result;
}
var array = [1, 4, 5, 7, 4, 8, 1, 10, 4];
console.log(arrayUnique2(array));1, 4, 5, 7, 8, 10]

 

第四个办法 和上面的set有点像使用es新的map数据结构进行去重

这里使用的是map这个数据结构的特性

他的本质是一堆键值对组合 他和其他键值对的最大区别就是他的建可以是字符串 也可以其他类型的数值

这里最牛的地方就是 在遍历中 其他键值对会把1 ,'1'看成一样的 而map则不会

map中和set的作用可以去重一样 map其实也是带了去重的效果的，就是所有的建只有唯一性

set(key, value)：set()函数设置键名key对应的键值为value，set()函数返回的是当 前Map对象，因此set()函数可以采用链式调用的写法。

· has(key)：has()函数返回一个布尔值，表示某个键是否在当前Map对象中。

       function arrayUnique(array)
       {
        var map = new Map()
        return array.filter(function(item)
        {
            return !map.has(item) && map.set(item,1)
        })
       }
       var arr = [1,4,5,7,4,8,1,10,4,'1']
       console.log(arrayUnique(arr));
//进行分解 会更好理解
    var map = new Map()
    var arr = [1,4,5,7,4,8,1,10,4,'1']
    const abc = arr.filter(function(item){
        return !map.has(item)&&map.set(item,1)
    })
    console.log(map);
    console.log(abc);

数组如何取交集

 数组取交集
const a = [0,1,2,3,4,5]
const b = [3,4,5,6,7,8]
const hebinshuzu = [...new Set(a)].filter(function(item)
{
       return  b.includes(item)
})
console.log(hebinshuzu);

使用到了set去重的办法先给a去重 如何在使用filter过滤 满足b数组中包括a中的元素的话就会返回一个true 返回数组中

数组如何取差集

啥意思 你有的我没有 我有你没有 这些东西合并成一个集合 交集的对对立面

const a = [0,1,2,3,4,5]
const b = [3,4,5,6,7,8]
const diffValues = [...new Set([...a,...b])].filter(item => !b.includes(item) || !a.includes(item))

和上面的有些类似

数组转对象
const arr = [1,2,3,4]
const newObj = {...arr}// {0: 1, 1: 2, 2: 3, 3: 4}
console.log(newObj);
const obj = {0:0,1:1,2:2,length:3}
有个办法转数组
对象转数组不能用展开操作符，因为展开操作符必须用在可迭代对象上
 let newArr = [...obj] //obj is not iterable
因此只能用from
let newArr = Array.from(obj)
 console.log(newArr);

数组常用遍历方法

forEach、every、some、filter、map、reduce、reduceRight、find、findIndex

这里挑几个说

every
some()函数与every()函数的相似之处在于都用于数组遍历的过程中，判断数
组是否有满足条件的元素，满足条件则返回“true”，否则返回“false”。some()函数
与every()函数的区别在于some()函数只要数组中某个元素满足条件就返回“true”，
不会对后续元素进行判断；而every()函数是数组中每个元素都要满足条件时才返
回“true
function isBigEnough(element,index,array)
{
    return element > 4
}
var passed1 = [1,2,3,4].some(isBigEnough)
var passed2 = [1,2,3,4,5].some(isBigEnough)
console.log(passed1);
console.log(passed2);

var passed3 = [2,3,4].every(isBigEnough)
var passed4 = [5,6].every(isBigEnough)
console.log(passed3);
console.log(passed4);

基于find()函数的方法
var value = [1, 5, 10, 15].find(function (element, index, array) {
 return element > 9;
});
var value2 = [1, 5, 10, 15].find(function (element, index, array) {
 return element > 20;
});
console.log(value); // 10
console.log(value2); // undefined

找到第一个符合条件的元素/下标
const arr = [1,2,3,4,5]
const findItem = arr.find(item => item === 3)//返回符合项
const findIndex = arr.findIndex(item => item === 3)//返回符合项的下标

reduce的强大之处

reduce()函数最主要的作用是做累加处理，即接收一个函数作为累加器，将数 组中的每一个元素从左到右依次执行累加器，返回最终的处理结果。

array.reduce 遍历并将当前次回调函数的返回值作为下一次回调函数执行的第一个参数。

利用 array.reduce 替代一些需要多次遍历的场景，可以极大提高代码运行效率。

我们先简单温习一下用法

arr.reduce(callback[, initialValue]);

callback是自己定义的一个函数 通常这里面的第一个参数和第二个参数是必填的

这个函数也有四个参数

• previousValue：上一次调用 callbackFn 时的返回值。在第一次调用时，若指定了初始值 initialValue，其值则为 initialValue，否则为数组索引为 0 的元素 array[0]。
• currentValue：数组中正在处理的元素。在第一次调用时，若指定了初始值 initialValue，其值则为数组索引为 0 的元素 array[0]，否则为 array[1]。
• currentIndex：数组中正在处理的元素的索引。若指定了初始值 initialValue，则起始索引号为 0，否则从索引 1 起始。
• array：用于遍历的数组。

initialValue是一个初始值 如果需要的时候可以给 你可以理解为一开始就有的previousValue

比如这里 我需要把里面的字符串中的s给去掉 如何再给剩下的数字比大小

这里是传统写法 需要多次遍历

const arr = ['s0', 's4', 's1', 's2', 's8', 's3'] //substring（1）只截取前面一个字符
const newArr = arr.map(item => item.substring(1)).map(item => Number(item)) //先分离 删除所有的s先 然后再把所有的字符串改成number
const maxS = Math.max(...newArr)

利用 array.reduce 替代一些需要多次遍历的场景，可以极大提高代码运行效率。

const maxS = arr.reduce((prev,cur)=>
{
     const curIndex = Number(cur.replace('s',''))
     return curIndex > prev ? curIndex : prev
},0)
console.log();

利用reduce输出一个数组/对象 这里是为偶数

传统写法
const arr = [1,2,3,4,5]
const value = arr.filter(item => item % 2 === 0).map(item => ({value:item}))

使用reduce

console.log(value);
const value = arr.reduce((prev,curr)=>{
return curr % 2 === 0 ?[...prev,{value : curr}] : prev
},[])

统计数组中每个元素出现的次数

var countOccurrences = function(arr)
{
    return arr.reduce(function(accumulator,currentValue)
    {
        accumulator[currentValue] ? accumulator[currentValue]++: //如果重复出现过 accumulator[currentValue] 会为true 
        // 用来计数的对象属性会 ++ 没有的话 则计数回永远为1这里和上面的一个差重的很像 都用到了这个方法 
    
        accumulator[currentValue]=1
        return accumulator
    },{})
}
console.log(countOccurrences([1, 2, 3, 2, 2, 5, 1]));//[1:2,2:3,3:1,5:1]