js-數組去重的幾種方法

參考鏈接：https://blog.csdn.net/weixin_42412046/article/details/81459294

1、定義一個新數組，並存放原數組的第一個元素，然後將元素組一一和新數組的元素對比，若不同則存放在新數組中。

        function unique(arr) {
            let newArr = [arr[0]];
            for (let i = 1; i < arr.length; i++) {
                let repeat = false;
                for (let j = 0; j < newArr.length; j++) {
                    if (arr[i] === newArr[j]) {
                        repeat = true;
                        break;
                    }else{
                        
                    }
                }
                if (!repeat) {
                    newArr.push(arr[i]);
                }
            }
            return newArr;
        }
 
        console.log(unique([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 結果是[1, 2, 3, 5, 6, 7, 4]

2、先將原數組排序，在與相鄰的進行比較，如果不同則存入新數組。

        function unique2(arr) {
            var formArr = arr.sort()
            var newArr=[formArr[0]]
            for (let i = 1; i < formArr.length; i++) {
                if (formArr[i]!==formArr[i-1]) {
                    newArr.push(formArr[i])
                }
            }
            return newArr
        }
        console.log(unique2([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 結果是[1, 2, 3,  4,5, 6, 7]

3、利用對象屬性存在的特性，如果沒有該屬性則存入新數組。

        function unique3(arr) {
            var obj={}
            var newArr=[]
            for (let i = 0; i < arr.length; i++) {
                if (!obj[arr[i]]) {
                    obj[arr[i]] = 1
                    newArr.push(arr[i])
                }   
            }
            return newArr
        }
        console.log(unique3([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 結果是[1, 2, 3, 5, 6, 7, 4]

4、利用數組的indexOf下標屬性來查詢。

        function unique4(arr) {
            var newArr = []
            for (var i = 0; i < arr.length; i++) {
                if (newArr.indexOf(arr[i])===-1) {
                    newArr.push(arr[i])
                }
            }
            return newArr
        }
        console.log(unique4([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 結果是[1, 2, 3, 5, 6, 7, 4]

includes() 方法用於判斷一個字符串是否包含在另一個字符串中，根據情況返回 true 或 false。

語法

str.includes(searchString[, position])

參數

searchString

要在此字符串中搜索的字符串。

position

可選。從當前字符串的哪個索引位置開始搜尋子字符串，默認值爲0。

返回值

如果當前字符串包含被搜尋的字符串，就返回 true；否則返回 false。

描述

這個方法可以幫你判斷一個字符串是否包含另外一個字符串。

區分大小寫

includes() 方法是區分大小寫的。例如，下面的表達式會返回 false ：

'Blue Whale'.includes('blue'); // returns false

5、利用數組原型對象上的includes方法。

        function unique5(arr) {
            var newArr = []
            for (var i = 0; i < arr.length; i++) {
                if (!newArr.includes(arr[i])) {
                    newArr.push(arr[i])
                }
            }
            return newArr
        }
        console.log(unique5([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 結果是[1, 2, 3, 5, 6, 7, 4]

6、利用數組原型對象上的 filter 和 includes方法。

        function unique6(arr) {
            var newArr = []
            newArr = arr.filter(function (item) {
                return newArr.includes(item) ? '' : newArr.push(item)
            })
            return newArr
        }
        console.log(unique6([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 結果是[1, 2, 3, 5, 6, 7, 4]

7、利用數組原型對象上的 forEach 和 includes方法。

        function unique7(arr) {
            var newArr = []
            array.forEach(item => {
                return newArr.includes(item) ? '' : newArr.push(item)
            });
            return newArr
        }
        console.log(unique7([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 結果是[1, 2, 3, 5, 6, 7, 4]

8、利用數組原型對象上的 splice 方法。

splice() 方法向/從數組中添加/刪除項目，然後返回被刪除的項目。

註釋：該方法會改變原始數組。

語法

arrayObject.splice(index,howmany,item1,.....,itemX)

參數	描述
index	必需。整數，規定添加/刪除項目的位置，使用負數可從數組結尾處規定位置。
howmany	必需。要刪除的項目數量。如果設置爲 0，則不會刪除項目。
item1, ..., itemX	可選。向數組添加的新項目。

返回值

類型	描述
Array	包含被刪除項目的新數組，如果有的話。

說明

splice() 方法可刪除從 index 處開始的零個或多個元素，並且用參數列表中聲明的一個或多個值來替換那些被刪除的元素。

如果從 arrayObject 中刪除了元素，則返回的是含有被刪除的元素的數組。

        function unique8(arr) {
            var i,j,len = arr.length;
            for (i = 0; i < len; i++) {
                for (j = i + 1; j < len; j++) {
                    if (arr[i] == arr[j]) {
                        arr.splice(j, 1);
                        len--;
                        j--;
                    }
                }
            }
            return arr;
        }
        console.log(unique8([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));

9、利用數組原型對象上的 lastIndexOf 方法。

        function unique9(arr) {
            var res = [];
            for (var i = 0; i < arr.length; i++) {
                res.lastIndexOf(arr[i]) !== -1 ? '' : res.push(arr[i]);
            }
            return res;
        }
        console.log(unique9([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 結果是[1, 2, 3, 5, 6, 7, 4]

10、 利用 ES6的set 方法。

ES6 提供了新的數據結構 Set。它類似於數組，但是成員的值都是唯一的，沒有重複的值

Array.from() 方法從一個類似數組或可迭代對象創建一個新的，淺拷貝的數組實例。

console.log(Array.from('foo'));
// expected output: Array ["f", "o", "o"]

console.log(Array.from([1, 2, 3], x => x + x));
// expected output: Array [2, 4, 6]

Array.from(arrayLike[, mapFn[, thisArg]])

參數

arrayLike

想要轉換成數組的僞數組對象或可迭代對象。

mapFn 可選

如果指定了該參數，新數組中的每個元素會執行該回調函數。

thisArg 可選

可選參數，執行回調函數 mapFn 時 this 對象

        function unique10(arr) {
            //Set數據結構，它類似於數組，其成員的值都是唯一的
            return Array.from(new Set(arr)); // 利用Array.from將Set結構轉換成數組
        }
        console.log(unique10([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 結果是[1, 2, 3, 5, 6, 7, 4]