封装一个方法,找出数组中重复数大于n的元素集合

例如 [1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4],封装一个数组原型上的方法,方法返回 重复数目大于2 的子元素集合,结果为[1, 2, 3]数组

初看并不难,循环一下就能够搞定数据结构

var arr = [1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4]
var obj = {}
var result = []
for(var i = 0; i<arr.length; i++){
   // 经过对象属性方式,来记录数组每一项出现的次数 
   obj[arr[i]] = obj[arr[i]] ? obj[arr[i]] + 1 : 1
}

Object.keys(obj).forEach(item => {
  if(obj[item] > 2){
    result.push(item)
  }
})
console.log(result) // ['1', '2', '3']
复制代码

不过获得的结果却有些改变 ,由于结果中的值都为字符串,原数组中类型为数字。 其实稍加修改便可 result.push(item) 改成 result.push(+item) 这样result结果符合要求了,即 [1, 2, 3]函数

有没有别的写法?是否是瞬间看起来高大上了一些呢?this

var arr = [1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4]
var result = arr.reduce((pre,cur)=>{
  const index = pre.findIndex(o => o.value === cur)
  if (index <= -1) {
  	pre.push({
  		value: cur,
  		count: 1
  	})
  } else {
  	pre[index].count ++
  }
  return pre
},[])
.filter(i => i.count > 2)
.map(i => i.value)
console.log(result)
复制代码

思路解析 1由于对象属性的key值会自动转为字符串类型,那么若是能转换为以下的类型,就避免了key值的转换spa

[
  {	
    value: 1,
    count: 3
  },
  {	
    value: 2,
    count: 3
  },
  {
    value: 3,
    count: 4
  },
  {
     value: 4,
     count: 2
  }
]
复制代码

若是能转换为这样的数据结构,那再filter后map一下,就能得出咱们须要的结果。 2 利用reduce转换本来数据 reduce函数第一次执行 pre === [] cur === 1 index === -1 因此 pre === [{value: 1, count:1}] reduce函数第二次执行 pre === [{value: 1, count:1}] cur === 1 index === 0 因此 pre === [{value: 1, count: 2}]prototype

...code

依次执行,最终就能获得上面数据结构对象

对新获得的数据依次执行filter和map filter 对数组 瘦身 ,剔除不知足条件的 map 对数组每一项都进行一个操做,返回新数据组成的数组字符串

那么到这,这道题写完了吗? 答案是否认的,注意审题封装一个数组原型上的方法,那么须要对上面方法进行改造原型

Array.prototype.myfun = function(n) {

var result = this.reduce((pre,cur)=>{
  const index = pre.findIndex(o => o.value === cur)
  if (index <= -1) {
  	pre.push({
  		value: cur,
  		count: 1
  	})
  } else {
  	pre[index].count ++
  }
  return pre
},[])
.filter(i => i.count > 2)
.map(i => i.value)

return result
}

var arr = [1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4]
var rusult = arr.myfun(2) //[1, 2, 3]复制代码
相关文章
相关标签/搜索