封裝一個方法，找出數組中重複數大於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]

有沒有別的寫法？是否是瞬間看起來高大上了一些呢？

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值的轉換

[
  {	
    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}]

...

依次執行，最終就能獲得上面數據結構

對新獲得的數據依次執行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]複製代碼