https://jsfiddle.net/2w0k5tz8/

function remove_duplicates(array_){
    var ret_array = new Array();
    for (var a = array_.length - 1; a >= 0; a--) {
        for (var b = array_.length - 1; b >= 0; b--) {
            if(array_[a] == array_[b] && a != b){
                delete array_[b];
            }
        };
        if(array_[a] != undefined)
            ret_array.push(array_[a]);
    };
    return ret_array;
}

console.log(remove_duplicates(Array(1,1,1,2,2,2,3,3,3)));

循环、删除重复项并创建克隆数组占位符，因为不会更新数组索引。

向后循环以获得更好的性能（循环不需要一直检查阵列的长度）

aLinks是一个简单的JavaScript数组对象。如果在索引显示已删除重复记录的元素之前存在任何元素。我重复以取消所有重复。一个通道阵列取消更多记录。

var srt_ = 0;
var pos_ = 0;
do {
    var srt_ = 0;
    for (var i in aLinks) {
        pos_ = aLinks.indexOf(aLinks[i].valueOf(), 0);
        if (pos_ < i) {
            delete aLinks[i];
            srt_++;
        }
    }
} while (srt_ != 0);

如果您自己创建数组，可以在插入数据时进行检查，从而为自己保存一个循环和额外的唯一过滤器；

var values = [];
$.each(collection, function() {
    var x = $(this).value;
    if (!$.inArray(x, values)) {
        values.push(x);
    }
});

您只需在JavaScript中使用filter方法的第二个-index参数即可：

var a = [2,3,4,5,5,4];
a.filter(function(value, index){ return a.indexOf(value) == index });

或在短手

a.filter((v,i) => a.indexOf(v) == i)

通用功能方法

以下是ES2015的通用和严格功能方法：

//小型、可重复使用的辅助功能常量应用=f=>a=>f（a）；常量flip=f=>b=>a=>f（a）（b）；常量未修正=f=>（a，b）=>f（a）（b）；常量push=x=>xs=>（xs.push（x），xs）；常量foldl=f=>acc=>xs=>xs.reduce（uncurry（f），acc）；常量some=f=>xs=>xs.some（apply（f））；//实际的重复数据消除功能常量uniqueBy=f=>foldl(acc=>x=>一些（f（x））（acc）? 应收账款：推（x）（acc）) ([]);//比较器常量eq=y=>x=>x===y；//字符串相等不区分大小写：D常量seqCI=y=>x=>x.toLowerCase（）===y.toLowerCase（）；//模拟数据常量xs=[1,2,3,1,2,3,4]；常量ys=[“a”、“b”、“c”、“a”、“b”、“c”、“D”]；console.log（uniqueBy（eq）（xs））；console.log（uniqueBy（seqCI）（ys））；

我们可以很容易地从unqiueBy中派生出唯一的，或者使用Sets更快地实现：

const unqiue = uniqueBy(eq);

// const unique = xs => Array.from(new Set(xs));

此方法的优点：

使用单独比较器函数的通用解决方案声明性和简洁的实现其他小型通用函数的重用

性能注意事项

uniqueBy不如具有循环的命令式实现快，但由于它的泛型性，它更具表现力。

如果您确定uniqueBy是应用程序中具体性能损失的原因，请用优化的代码替换它。也就是说，首先以功能性、声明性的方式编写代码。之后，如果您遇到性能问题，请尝试在导致问题的位置优化代码。

内存消耗和垃圾收集

uniqueBy利用隐藏在其体内的突变（push（x）（acc））。它重用累加器，而不是在每次迭代后丢弃它。这减少了内存消耗和GC压力。由于这种副作用被包装在函数内部，所以外部的一切都保持纯净。

VanillaJS：使用像Set这样的Object删除重复项

您可以始终尝试将其放入对象中，然后遍历其关键点：

function remove_duplicates(arr) {
    var obj = {};
    var ret_arr = [];
    for (var i = 0; i < arr.length; i++) {
        obj[arr[i]] = true;
    }
    for (var key in obj) {
        ret_arr.push(key);
    }
    return ret_arr;
}

Vanilla JS：通过跟踪已经看到的值来删除重复项（订单安全）

或者，对于订单安全版本，使用一个对象来存储所有以前看到的值，并在添加到数组之前检查值。

function remove_duplicates_safe(arr) {
    var seen = {};
    var ret_arr = [];
    for (var i = 0; i < arr.length; i++) {
        if (!(arr[i] in seen)) {
            ret_arr.push(arr[i]);
            seen[arr[i]] = true;
        }
    }
    return ret_arr;

}

ECMAScript 6：使用新的Set数据结构（顺序安全）

ECMAScript 6添加了新的Set Data Structure，它允许您存储任何类型的值。Set.values按插入顺序返回元素。

function remove_duplicates_es6(arr) {
    let s = new Set(arr);
    let it = s.values();
    return Array.from(it);
}

示例用法：

a = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];

b = remove_duplicates(a);
// b:
// ["Adam", "Carl", "Jenny", "Matt", "Mike", "Nancy"]

c = remove_duplicates_safe(a);
// c:
// ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Carl"]

d = remove_duplicates_es6(a);
// d:
// ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Carl"]