javascript - js怎么把一个数组里面重复的数字去掉并且组成新的数组？

Question

原数组：

["100", "100", "2.3", "2.4", "101", "101", "3.6", "3.7"]

["100", "100", "2.3", "2.4", "101", "101", "3.6", "3.7",...."102","102".......每隔2个小数点就会有重复的,以此类推]

怎么改装成如下：

[
     {
        type : "100",
        a : "2.3",
        b : "2.4"
    },
    {
        type : "101",
        a : "3.6",
        b : "3.7"
    }
] 

100跟101 都重复了

Answer 1

先给你画个流程图示意，看你写得出来不

Answer 2

let s = new Set(arr);
let res = [...s];

Answer 3

给个比较简短的示例代码，注解里有写步骤123是什么:

const oldArray = ["100", "100", "2.3", "2.4", "101", "101", "3.6", "3.7", "102", "102", "4.1", "4.3"]

// 1. 去重 ["100", "2.3", "2.4", "101", "3.6", "3.7"]
// 2. 一维数组 转成 二维数组  [["100", "2.3", "2.4"], ["101", "3.6", "3.7"]]
// 3. 每个数组成员组合为对象  [{ type: "100", a: "2.3", b: "2.4" }]

const newArray = oldArray.filter((item, pos) => (
    oldArray.indexOf(item) === pos
  ))
  .reduce((rows, item, index) => (
    (index % 3 === 0
      ? rows.push([item])
      : rows[rows.length - 1].push(item)) && rows
  ), [])
  .map(item => (
    { type: item[0], a: item[1], b: item[2] }
  ))

console.log(newArray)

以下给个直觉用for语句的示例，自订弹性会比较高，JS中调用函数自然是花费高，所以for语句的效能会比较好，能好到多少就要视情况测试，当然代码量会多些。步骤与上面类似:

// 1.去重
var oneArray = [];

for(var i = 0; i < oldArray.length; i++){
    if(oneArray.indexOf(oldArray[i]) === -1){
      oneArray.push(oldArray[i]);
    }
}

console.log(oneArray)

// 2.一维数组 转成 二维数组
var twoArray = [];

for(var i = 0; i < oneArray.length; i += 3) {
    twoArray.push(oneArray.slice(i, i + 3));
}

console.log(twoArray)

// 3. 每个数组成员组合为对象
var threeArray = [];

for(var i = 0; i < twoArray.length; i++) {
    threeArray.push({ type: twoArray[0], a: twoArray[1], b: twoArray[2] });
}

console.log(threeArray)

实际上用for语句，步骤2与3可以合在一起:

// 2, 3步骤可合并
var twoAndThreeArray = [];

for(var i = 0; i < oneArray.length; i += 3) {
    twoAndThreeArray.push({ type: oneArray[i], a: oneArray[i+1], b: oneArray[i+2] });
}

console.log(twoAndThreeArray)

Answer 4

var list=["100", "100", "2.3", "2.4", "101", "101", "3.6", "3.7"];
var len=list.length;
var res=[];
for(var i=0;i<len;i++){
    if(i%4==3){
        var item={};
        item.type=list[i-2];
        item.a=list[i-1];
        item.b=list[i];
        res.push(item);
    }
}
console.log(res);

Answer 5

Array.prototype.remove=function(dx){ 
    if(isNaN(dx)||dx.length>this.length){return false;} 
    for(var i=0,n=0;i<this.length;i++) 
    { 
        if(this[i]!=this[dx]) 
        { 
            this[n++]=this[i];
        } 
    } 
    this.length-=1;
};

Answer 6

@老咸鱼 使用的es6 方法最简单

es6 太高端了，我给个es5的，思路较直观的代码

var arr = ["100", "100", "2.3", "2.4", "101", "101", "3.6", "3.7", "102", "102", "3.6", "3.7"];
var obj = {};
var res = [];
arr.filter(function (item, i) {
    if (!obj[item] && item.indexOf('.') === -1) {
        obj[item] = true;
        res.push({
            type: item
        });
        return true;
    }
    var lastOne = res[res.length - 1];
    if (item.indexOf('.') > -1 && lastOne) {
        if (!lastOne.a) {
            lastOne.a = item;
        } else {
            lastOne.b = item;
        }
    }
    return false;
});
res

Answer 7

var arr = [1,2,3,1,2,1,2,3];
for(var i=0;i<arr.length;i++){

for(var j=i+1;j<arr.length;j++){
    if(arr[i] == arr[j]){
        arr.splice(j,1);
        i--;
    }
}

}

Answer 8

你在评论中提到，可能出现带小数的也重复，filter 的时候需要跳过

这样就好了

var a = ["100", "100", "2.3", "2.4", "101", "101", "3.6", "3.7", "102", "102", "5.1", "5.1"];
a.filter((e, i) => e % 1 || a.indexOf(e) === i);

// result: ["100", "2.3", "2.4", "101", "3.6", "3.7", "102", "5.1", "5.1"]

其中 e % 1 可以用来判断是否为整数，整数返回 0，小数不返回 0。后面的 a.indexOf(e)，因为这只会返回 e 元素在 数组 a 中第一次出现的位置，所以可以用 a.indexOf(e) === i 来判断是否需要 filter

用 ES5 写就是

a.filter(function (e, i) {
    return e % 1 || a.indexOf(e) === i
})

后面的事儿就很简单了，楼上有朋友提到先弄成二维数组，个人觉得不用。。

前提是你的数据本身就是每 x 个一组。。如果不是的话，至少你得有个判断条件，比如，整数或者怎样。。

我的实现：

var result = {};
var b = ["100", "2.3", "2.4", "101", "3.6", "3.7", "102", "5.1", "5.1"];

b.map(function (e, i) {
    if (i % 3 === 0) {
        result[e] = {}
    } else {
        result[b[i - i % 3]][String.fromCharCode(i % 3 + 96)] = e
    }
});

结果如图：