双重for循环

  1. let arr = [1, 2, 3, 4, 5, 6, 4, 3, 8, 1]
  2. // 创建一个新数组
  3. let newArr = []
  4. // 使用双重for循环
  5. for (let i = 0; i < arr.length; i++) {
  6.     let flag = true; // 设置一个开关，如果为TRUE则存进去，否则不存
  7.     for (let j = 0; j < newArr.length; j++) {
  8.         // 如果新数组中值等于旧数组中值则返回false，否则返回true
  9.         arr[i] === newArr[j] ? flag = false : flag
  10.     }
  11.     // 返回TRUE将数组存到newArr
  12.     flag ? newArr.push(arr[i]) : newArr
  13. }
  14. console.log(newArr)

for+indexOf()

主要利用findIndex 的特性，查找元素找不到就返回-1， 接下来就需要判断，如果是-1，说明没找到，就往新数组里面添加元素

  1. let arr = [1, 2, 3, 4, 5, 6, 4, 3, 8, 1]
  2. function newArrFn(arr) {
  3.     let newArr = []
  4.     for (let i = 0; i < arr.length; i++) {
  5.         newArr.indexOf(arr[i]) === -1 ? newArr.push(arr[i]) : newArr
  6.     }
  7.     return newArr
  8. }
  9. console.log(newArrFn(arr))
  10. // [1, 2, 3, 4, 5, 6, 8]

sort排序

首先利用 sort 方法进行排序。进行循环，如果原数组的第 i 项和新数组的i - 1项不一致，就push进去。

  1. let arr = [1, 2, 3, 4, 5, 6, 4, 3, 8, 1]
  2. function newArrFn(arr) {
  3.     arr = arr.sort() // 排序
  4.     let newArr = []
  5.     for (let i = 0; i < arr.length; i++) {
  6.         arr[i] === arr[i - 1] ? newArr : newArr.push(arr[i])
  7.     }
  8.     return newArr
  9. }
  10. console.log(newArrFn(arr)); // // [1, 2, 3, 4, 5, 6, 8]

Set

ES6中新增了数据类型Set，Set的一个最大的特点就是数据不重复。Set函数可以接受一个数组（或类数组对象）作为参数来初始化，利用该特性也能做到给数组去重。

  1. let arr = [1, 2, 3, 4, 5, 6, 4, 3, 8, 1]
  2. function newArrFn(arr) {
  3.     // .new Set方法，返回是一个类数组，需要结合 ...运算符，转成真实数组
  4.     return ([...new Set(arr)])
  5. }
  6. console.log(newArrFn(arr)); // [1, 2, 3, 4, 5, 6, 8]

set + Array.from

利用 set方法数据不重复的特点，结合 Array.from

  1. let arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1]
  2. function newArrFn (arr) {
  3.     // new Set方法，返回是一个类数组，需要结合 Array.from ，转成真实数组
  4.     return (Array.from(new Set(arr)) )
  5. }
  6. console.log(newArrFn(arr)); // [1, 2, 3, 4, 5, 6, 8]

filter + indexOf

indexOf，可以检测某一个元素在数组中出现的位置，找到返回该元素的下标，没找到返回 -1

  1. let arr = [1, 2, 3, 4, 5, 6, 4, 3, 8, 1]
  2. function newArrFn(arr) {
  3.     // 利用indexOf检测元素在数组中第一次出现的位置是否和元素现在的位置相等，
  4.     // 如果相等，说明数组中没有重复的
  5.     return Array.prototype.filter.call(arr, function(item, index) {
  6.         return arr.indexOf(item) === index
  7.     })
  8. }
  9. console.log(newArrFn(arr)); // [1, 2, 3, 4, 5, 6, 8]

includes

利用 includes 检查新数组是否包含原数组的每一项。 如果不包含，就push进去

  1. let arr = [1, 2, 3, 4, 5, 6, 4, 3, 8, 1]
  2. function newArrFn(arr) {
  3.     // 利用includes 检查新数组是否包含原数组的每一项
  4.     // 如果不包含，就push进去
  5.     let newArr = []
  6.     for (let i = 0; i < arr.length; i++) {
  7.         newArr.includes(arr[i]) ? newArr : newArr.push(arr[i])
  8.     }
  9.     return newArr
  10. }
  11. console.log(newArrFn(arr)); // [1, 2, 3, 4, 5, 6, 8]

for + object

利用对象属性名不能重复这一特点。如果对象中不存在，就可以给 push 进去

  1. let arr = [1, 2, 3, 4, 5, 6, 4, 3, 8, 1]
  2. function newArrFn(arr) {
  3.     // 利用对象属性名不能重复这一特点
  4.     // 如果对象中不存在，就可以给 push 进去
  5.     let newArr = []
  6.     let obj = {}
  7.     for (let i = 0; i < arr.length; i++) {
  8.         if (!obj[arr[i]]) {
  9.             newArr.push(arr[i])
  10.             obj[arr[i]] = 1
  11.         } else {
  12.             obj[arr[i]]++
  13.         }
  14.     }
  15.     return newArr
  16. }
  17. console.log(newArrFn(arr)); // [1, 2, 3, 4, 5, 6, 8]

for + splice

利用 splice 进行切割

  1. let arr = [1, 2, 3, 4, 5, 6, 4, 3, 8, 1]
  2. // 利用 splice 进行切割。
  3. function newArrFn(arr) {
  4.     for (let i = 0; i < arr.length; i++) {
  5.         for (let j = i + 1; j < arr.length; j++) {
  6.             if (arr[i] === arr[j]) {
  7.                 arr.splice(j, 1);
  8.                 j--
  9.             }
  10.         }
  11.         ;
  12.     }
  13.     return arr
  14. }
  15. console.log(newArrFn(arr)); // [1, 2, 3, 4, 5, 6, 8]

filter + indexOf

利用 filter 过滤 配合 indexOf 查找元素

  1. let arr = [1, 2, 3, 4, 5, 6, 4, 3, 8, 1]
  2. // filter 过滤 配合 indexOf 查找元素
  3. function newArrFn(arr) {
  4.     return arr.filter((item, index) => {
  5.         return arr.indexOf(item) === index
  6.     })
  7. }
  8. console.log(newArrFn(arr)); // [1, 2, 3, 4, 5, 6, 8]

Map

利用数据结构存值的特点

  1. let arr = [1, 2, 3, 4, 5, 6, 4, 3, 8, 1]
  2. function newArrFn(arr) {
  3.     let newArr = []
  4.     let map = new Map()
  5.     for (let i = 0; i < arr.length; i++) {
  6.         // 如果 map里面不包含，就设置进去
  7.         if (!map.has(arr[i])) {
  8.             map.set(arr[i], true)
  9.             newArr.push(arr[i])
  10.         }
  11.     }
  12.     return newArr
  13. }
  14. console.log(newArrFn(arr)); // [1, 2, 3, 4, 5, 6, 8]

reduce

使用reduce方法判断是否包含，如果不包含的话就将数据追加进去

  1. let arr = [1, 2, 3, 4, 5, 6, 4, 3, 8, 1]
  2. function newArrFn(arr) {
  3.     let newArr = []
  4.     return arr.reduce((prev, next, index, arr) => {
  5.         // 如果包含，就返回原数据，不包含，就把新数据追加进去
  6.         return newArr.includes(next) ? newArr : newArr.push(next)
  7.     }, 0)
  8. }
  9. console.log(newArrFn(arr)); // [1, 2, 3, 4, 5, 6, 8]