关于javascript数组的题目

题目是： 对数组进行去重操作，只考虑数组中元素为数字或字符串，返回一个去重后的数组

function uniq2Array(arr) { //better 因为木有改变原来数组项的顺序 对象的隐形遍历查询属性查询？
    var result = [], obj = {}, i, len, key;
    for (i = 0, len = arr.length; i < len; i++) {
        key = arr[i];
        if (!obj[key]) {
            result.push(arr[i]);
            obj[key] = true;
        }
    }
    console.log(result);
    return result;
}

问题：
这上面的代码中创建对象并让数组值为对象的属性的方式（验证key的方式），这种方式在javascript有没有什么官方的叫法？我试了一下对于数组中存在[22,'22','33',33]经过上面的函数处理后结果为[22,'33']，对于['22',22,33,'33']返回['22',33]，这说明该方法还是有些问题大，如果要改进该方法应该如何修改？

---

function uniq2Array(arr) { 
    return arr.filter(function(v, index) { return arr.indexOf(v)=== index})
}

---

javascript 对象的 key 都是字符串，就算是给的其它类型的值，也会自动通过 toString() 转换成字符串。所以，使用这种方法来去重，是不能区别数和字符串的。

不使用对象 key 集的办法，可以用楼上 filter + indexOf 的办法。

如果想区分类型

如果还是想用对象 key 集的办法，那就要把类型放在 key 里去了，比如

注意 key 的算法

function uniq2Array(arr) { //better 因为木有改变原来数组项的顺序 对象的隐形遍历查询属性查询？
    var result = [],
        obj = {},
        i, len, key;

    for (i = 0, len = arr.length; i < len; i++) {
        key = typeof(arr[i]) + "_" + arr[i];
        if (!obj[key]) {
            result.push(arr[i]);
            obj[key] = true;
        }
    }

    console.log(result);
    return result;
}

console.log(uniq2Array([22,'22','33',33]));
console.log(uniq2Array(['22',22,33,'33']));

输出

[22, "22", "33", 33]
["22", 22, 33, "33"]

如果希望结果都是整数

那就要对数据进行一次转换：

注意 result.push()

function uniq2Array(arr) { //better 因为木有改变原来数组项的顺序 对象的隐形遍历查询属性查询？
    var result = [],
        obj = {},
        i, len, key;

    for (i = 0, len = arr.length; i < len; i++) {
        key = arr[i];
        if (!obj[key]) {
            result.push(parseInt(arr[i]));
            obj[key] = true;
        }
    }

    console.log(result);
    return result;
}

console.log(uniq2Array([22,'22','33',33]));
console.log(uniq2Array(['22',22,33,'33']));

输出

[22, 33]
[22, 33]

---

key=typeof(arr [ i ] )+arr [ i ]

---

ES3

function unique(arr) {
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        var currElem = arr[i];

        if (newArr.indexOf(currElem) < 0) {
            newArr.push(currElem);
        }
    }

    return newArr;
}   

console.log(unique([1, 2, 1, 3]));

ES5

function unique(arr) {
    return arr.filter(function (elem, index) {
        return arr.indexOf(elem) === index
    });
}

console.log(unique([1, 2, 1, 3]));

ES6

var arr = [1, 2, 1, 3];
console.log(Array.from(new Set(arr)));

ES7

var arr = [1, 2, 1, 3];
console.log([...new Set(arr)]);

我能想到的。

---

具体的有和你的在数组中放的值的类型有关系，如果元素对象的话，那么什么是相同就有不同的定义了-是对象地址相同？对象实际值相同？类型装换后相同？具体问题还是要有不同的实现;
提供一个确定一个元素唯一标识信息的函数,能够提供统一的解决方案
例如:

function uniq2Array(arr,uniqFun){
    var i=0,len=arr.length,uniqArray=[];
    var keyObj={},someItem,itemKey;
    for(i=0;i< len;i++){
        someItem=arr[i];
        itemKey=uniqFun(someItem);
        if(!keyObj[itemKey]){
            uniqArray.push(someItem);
            keyObj[itemKey]=true;
        }

    }

    return uniqArray;

}

var someArray=[22,'22','33','43','55'];
var uniqArray=uniq2Array(someArray,function(itemA){
    return parseInt(itemA,10);
});

console.log(uniqArray);

var someArray2=[{
    key:"1",
    name:"2"
},{
    key:"3",
    name:"4"
},{
    key:"1",
    name:"2",
    reverse:"999"
}];

uniqArray=uniq2Array(someArray2,function(itemA){
    return itemA.key+"_"+itemA.name
});

console.log(uniqArray);

结果为

[ 22, '33', '55' ]
[ { key: '1', name: '2' }, { key: '3', name: '4' } ]