Javascript数组排序和唯一性

我有一个JavaScript数组，如下所示：

var myData=['237','124','255','124','366','255'];

我需要数组元素是唯一的并进行排序：

myData[0]='124';
myData[1]='237';
myData[2]='255';
myData[3]='366';

尽管数组的成员看起来像整数，但它们不是整数，因为我已经将它们转换为字符串：

var myData[0]=num.toString();
//...and so on.

---

有没有办法在JavaScript中完成所有这些任务？

恐怕您不能将这些功能组合在一起，即，您必须执行以下操作：-

myData.unique().sort();

或者，您可以实现一种sortedset（在其他语言中也可以使用），它可以根据需要执行排序和删除重复项的概念

希望这有帮助

参考资料：-

---

尝试使用外部库，如

这有赖于,

现场观看

它在做什么？

我们需要一个函数，该函数接受一个数组，然后返回一个已排序的数组，并删除非唯一项。这个函数需要做两件事，排序和使数组唯一

这是一项很好的合成工作，因此我们一起合成了unique&sort函数

\uuq.uniq

只能用一个参数应用于数组，因此它只传递给

\uq.compose

sortBy函数需要一个排序条件函数。它需要一个返回值的函数，数组将根据该值进行排序。因为我们对它进行排序的值是数组中的值，所以我们可以只传递u.identity函数

我们现在有一个组合函数（接受数组并返回唯一数组）和一个函数（接受数组并返回排序数组，按其值排序）

---

我们只需在数组上应用组合，就得到了唯一排序的数组。

这实际上非常简单。如果先对值进行排序，则更容易找到唯一值：

function sort_unique(arr) {
  if (arr.length === 0) return arr;
  arr = arr.sort(function (a, b) { return a*1 - b*1; });
  var ret = [arr[0]];
  for (var i = 1; i < arr.length; i++) { //Start loop at 1: arr[0] can never be a duplicate
    if (arr[i-1] !== arr[i]) {
      ret.push(arr[i]);
    }
  }
  return ret;
}
console.log(sort_unique(['237','124','255','124','366','255']));
//["124", "237", "255", "366"]

函数排序\u唯一（arr）{
如果（arr.length==0）返回arr；
arr=arr.sort（函数（a，b）{返回a*1-b*1；}）；
var-ret=[arr[0]]；
对于（var i=1；i

我想我会发布一些不同的答案。这种清除重复项的技术是我在大约一个月前的Flash项目中学习的

您要做的是创建一个对象，并利用每个数组项用一个键和一个值填充它。因为重复的关键点被丢弃，所以重复的关键点被删除

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;
}

var nums=[1,1,2,3,3,4,5,5,6,7,7,8,9,9,10]；
var newNums=purgeArray（nums）；
函数purgeArray（ar）
{
var obj={}；
var-temp=[]；
对于（var i=0；i在无法预先定义函数的情况下（如在bookmarklet中），这可能足够了：

对于两个以上的重复值，此函数不会失败：

function unique(arr) {
    var a = [];
    var l = arr.length;
    for(var i=0; i<l; i++) {
        for(var j=i+1; j<l; j++) {
            // If a[i] is found later in the array
            if (arr[i] === arr[j])
              j = ++i;
        }
        a.push(arr[i]);
    }
    return a;
};

功能唯一性（arr）{
var a=[]；
var l=阵列长度；
对于（var i=0；i一种使用自定义排序函数的方法

//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;
    }

函数sort（）仅在数字相同时有效，例如：

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

将返回

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

这里是Monkington先生对功能的改进

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

没有冗余的“返回”阵列，没有ECMA5内置（我很确定！），并且易于阅读

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;
}

功能移除副本（目标数组）{
target_array.sort（）；
var i=0；
while（i
那么：

array.sort().filter(function(elem, index, arr) {
  return index == arr.length - 1 || arr[index + 1] != elem
})

这类似于@loostro answer，但不是使用indexOf来重复每个元素的数组以验证是否是第一个找到的元素，而是检查下一个元素是否与当前元素不同。
以下是我的（更现代）方法，使用：


编辑：评论中指出的更高性能版本：

arr.sort().filter((x, i, a) => !i || x != a[i-1])

这是一个简单的单行程序，带有
O（N）
，不需要复杂的循环

> Object.keys(['a', 'b', 'a'].reduce((l, r) => l[r] = l, {})).sort()
[ 'a', 'b' ]

解释

原始数据集，假设它来自外部函数

const data = ['a', 'b', 'a']

作为重复数据消除方法，我们希望将所有值分组到一个对象上作为键。因此，我们使用reduce并将一个对象作为默认值：

[].reduce(fn, {})

下一步是创建一个reduce函数，将数组中的值放到对象上。最终结果是一个具有唯一键集的对象

const reduced = data.reduce((l, r) => l[r] = l, {})

我们设置
l[r]=l
，因为在javascript中，赋值表达式的值在赋值语句用作表达式时返回。
l
是累加器对象，
r
是键值。您也可以使用
object.assign（l，{[r]：（l[r]| 0）+1}）
或类似的方法获取每个值的计数，如果这对您很重要

接下来，我们要获取该对象的关键点

const keys = Object.keys(reduced)

然后简单地使用内置排序

console.log(keys.sort())

这是原始数组的唯一值集，已排序

['a', 'b']

现在，您只需一行代码即可获得结果

用于将数组缩减为唯一的值集。
在排序字符串值后应用方法

var myData=['237','124','255','124','366','255']

var uniqueAndSorted = [...new Set(myData)].sort() 

更新了自提出问题以来在JavaScript中引入的较新方法。
O[N^2]解决方案不好，特别是当数据已经排序时，不需要执行两个嵌套循环来删除重复项。一个循环并与前一个元素进行比较将非常有效

一个带有sort（）的O[]的简单解决方案就足够了。我的解决方案是：

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（）方法：

此外，如果比较，可以修改sort（）以删除第二个元素
const reduced = data.reduce((l, r) => l[r] = l, {})

const keys = Object.keys(reduced)

console.log(keys.sort())

['a', 'b']

var myData=['237','124','255','124','366','255']

var uniqueAndSorted = [...new Set(myData)].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.prototype.sortUnique = function(compareFunction) {return sortUnique(this, compareFunction); }

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
}