JavaScript数组排序和去重

使用自定义排序函数的方法

//func has to return 0 in the case in which they are equal
sort_unique = function(arr,func) {
        func = func || function (a, b) {
            return a*1 - b*1;
        };
        arr = arr.sort(func);
        var ret = [arr[0]];
        for (var i = 1; i < arr.length; i++) {
            if (func(arr[i-1],arr[i]) != 0) 
                ret.push(arr[i]);
            }
        }
        return ret;
    }

例子：对于一个对象数组进行降序排列

MyArray = sort_unique(MyArray , function(a,b){
            return  b.iterator_internal*1 - a.iterator_internal*1;
        });

function removeDuplicates(target_array) {
    target_array.sort();
    var i = 0;

    while(i < target_array.length) {
        if(target_array[i] === target_array[i+1]) {
            target_array.splice(i+1,1);
        }
        else {
            i += 1;
        }
    }
    return target_array;
}

var nums = [1, 1, 2, 3, 3, 4, 5, 5, 6, 7, 7, 8, 9, 9, 10];
var newNums = purgeArray(nums);

function purgeArray(ar)
{
    var obj = {};
    var temp = [];
    for(var i=0;i<ar.length;i++)
    {
        obj[ar[i]] = ar[i];
    }
    for (var item in obj)
    {
        temp.push(obj[item]);
    }
    return temp;
}

已经有其他5个答案了，所以我不认为需要发布一个排序函数。

// Another way, that does not rearrange the original Array 
// and spends a little less time handling duplicates.

function uniqueSort(arr, sortby){
    var A1= arr.slice();
    A1= typeof sortby== 'function'? A1.sort(sortby): A1.sort();

    var last= A1.shift(), next, A2= [last];
    while(A1.length){
        next= A1.shift();
        while(next=== last) next= A1.shift();
        if(next!=undefined){
            A2[A2.length]= next;
            last= next;
        }
    }
    return A2;
}
var myData= ['237','124','255','124','366','255','100','1000'];
uniqueSort(myData,function(a,b){return a-b})

// the ordinary sort() returns the same array as the number sort here,
// but some strings of digits do not sort so nicely numerical.

O[N^2]的解决方案很糟糕，特别是当数据已经排序时，没有必要进行两个嵌套循环来删除重复项。一个循环并与前一个元素进行比较就可以很好地解决问题。

使用O[]的sort()函数的简单解决方案就足够了。我的解决方案如下：

function sortUnique(arr, compareFunction) {
  let sorted = arr.sort(compareFunction);
  let result = sorted.filter(compareFunction
    ? function(val, i, a) { return (i == 0 || compareFunction(a[i-1], val) != 0); }
    : function(val, i, a) { return (i == 0 || a[i-1] !== val); }
  );
  return result;
}

顺便说一下，可以这样做来实现Array.sortUnique()方法：

Array.prototype.sortUnique = function(compareFunction) {return sortUnique(this, compareFunction); }

var array = [2,5,4,2,5,9,4,2,6,9,0,5,4,7,8];

var unique_array = [...new Set(array)]; // [ 2, 5, 4, 9, 6, 0, 7, 8 ]

var uniqueWithSorted = unique_array.sort();

console.log(uniqueWithSorted);
output = [ 0, 2, 4, 5, 6, 7, 8, 9 ]

这里，我们只使用了Set来从数组中删除重复项，然后使用sort按升序对数组进行排序。

sort() 函数只有在数字具有相同的位数时才有效，例如：

var myData = ["3","11","1","2"]

将返回;

var myData = ["1","11","2","3"]

这里是mrmonkington对函数的改进

myData.sort().sort(function(a,b){return a - b;}).filter(function(el,i,a){if(i==a.indexOf(el) & el.length>0)return 1;return 0;})

上述函数还将删除空数组，您可以在下面查看演示

http://jsbin.com/ahojip/2/edit

完成此任务的最快且最简单的方法。

const N = Math.pow(8, 8)
let data = Array.from({length:  N}, () => Math.floor(Math.random() * N))
let newData = {}
let len = data.length

// the magic
while (len--) {
    newData[data[len]] = true
}

很抱歉，您不能将这些函数组合在一起，即您必须像这样做：

myData.unique().sort();

或者你可以实现一种类似于其他语言中可用的sortedset - 它同时具有排序和删除重复项的概念，正如你所需。

希望这可以帮助到你。

参考资料：-

Array.sort

Array.unique