用js取出数组中重复的数据

可以使用双重循环来遍历数组，比较每个元素是否相同，如果相同则为重复元素。代码示例：

function findDup(arr) {
  var result = [];
  for (var i = 0; i < arr.length; i++) {
    for (var j = i + 1; j < arr.length; j++) {
      if (arr[i] == arr[j] && result.indexOf(arr[i]) == -1) {
        result.push(arr[i]); // 把重复元素放入结果数组中
      }
    }
  }
  return result;
}

// 测试
var arr = [1, 2, 3, 4, 5, 2, 4, 6, 7];
var dup = findDup(arr);
console.log(dup); // 输出 [2, 4]

相关问题

数组去重newset

### 回答1：
数组去重可以使用 set() 函数来实现。set() 函数可以去除数组中重复的元素。

例如：

arr = [1, 2, 3, 4, 5, 5, 6, 6, 7, 8, 8]
newset = set(arr)
print(newset)

输出结果为：

{1, 2, 3, 4, 5, 6, 7, 8}

需要注意的是，set()函数的返回值是一个集合，而不是数组，如果需要返回一个数组，可以使用 list(set(arr))。

### 回答2：
数组去重可以使用Set数据结构来实现，Set是一种不允许重复元素的集合。具体的步骤如下：

1. 创建一个新的Set对象，用来存储去重后的数组元素。
2. 遍历原始数组，取出每个元素。
3. 将每个元素添加到Set中，利用Set的特性自动去重。
4. 遍历结束后，Set中就存储了去重后的元素。
5. 将Set转为数组，即可得到去重后的新数组。

下面是使用JavaScript语言实现数组去重的例子：

// 原始数组
let arr = [1, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8];
// 创建一个新的Set对象
let newSet = new Set(arr);
// 将Set转为数组
let newArr = Array.from(newSet);
console.log(newArr); // 输出 [1, 2, 3, 4, 5, 6, 7, 8]

这样就得到了去重后的新数组newArr。可以看到，新数组中只保留了原始数组中的不重复元素。

需要注意的是，Set数据结构是ES6新加入的特性，仅在较新的浏览器或Node.js环境中可用。兼容性较差的环境可以考虑使用其他方法实现数组去重，比如使用对象来记录元素是否已经存在等方式。

### 回答3：
数组去重是指将数组中重复的元素去除，只保留其中的一个或不重复的元素。

可以使用Set数据结构实现数组去重。Set是一种无序的、不可重复的集合，可以使用它来创建一个新的数组，去除原数组中的重复元素。

具体实现步骤如下：
1. 创建一个空的Set对象，命名为newSet。
2. 遍历原数组，将每个元素添加到newSet中。
3. 完成遍历后，newSet中会自动去除原数组中的重复元素。
4. 将newSet转换为数组，得到去重后的新数组。

以下是示例代码：

def array_de_duplication(arr):
    newSet = set()
    for element in arr:
        newSet.add(element)
    newArr = list(newSet)
    return newArr

# 示例
arr = [1, 2, 3, 3, 4, 5, 5, 6]
newArr = array_de_duplication(arr)
print(newArr)

运行结果为：[1, 2, 3, 4, 5, 6]

这样就实现了数组去重，通过Set数据结构将原数组中的重复元素去除，只保留不重复的元素。

我有2个数组对象，里面有一个相同的属性，我想用js把这2个数组对象中的相同属性提取出来，去重

### 回答1：
你可以使用 JavaScript 中的 Set 数据结构来去重， Set 本质上是一个无序的且不重复的数据集合。可以将 Set 看作是数组的替代品，它具有与数组类似的 API，但是它不允许出现重复的元素。你可以这样做：

const array1 = [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}];
const array2 = [{id: 3, name: 'Charlie'}, {id: 4, name: 'Dave'}, {id: 5, name: 'Eve'}];

const commonIds = new Set();

array1.forEach(item => {
  commonIds.add(item.id);
});

array2.forEach(item => {
  if (commonIds.has(item.id)) {
    commonIds.add(item.id);
  }
});

console.log(commonIds); // Set {3}

这样就可以提取出来两个数组中相同属性的值，并且去重。

注意：这种方法仅适用于两个数组，如果你有更多的数组，你可以使用一个循环来遍历所有数组，并在 Set 中添加属性值。

### 回答2：
可以使用JavaScript中的数组方法来实现提取和去重。下面是一个简单的代码示例：

// 数组对象1
var arr1 = [
  { id: 1, name: '张三' },
  { id: 2, name: '李四' },
  { id: 3, name: '王五' }
];

// 数组对象2
var arr2 = [
  { id: 2, name: '李四' },
  { id: 3, name: '李四' },
  { id: 4, name: '赵六' }
];

// 提取相同属性
var result = arr1.filter(function(obj1) {
  return arr2.some(function(obj2) {
    return obj1.id === obj2.id && obj1.name === obj2.name;
  });
});

// 去重
var uniqueResult = Array.from(new Set(result));

console.log(uniqueResult);

以上代码首先使用`filter`方法筛选出数组对象1中与数组对象2中相同属性的对象。然后使用`Set`数据结构去重，最终得到唯一的结果。

输出结果为：`[{ id: 2, name: '李四' }, { id: 3, name: '李四' }]`。

### 回答3：
你可以使用JavaScript来提取并去重这两个数组对象中的相同属性。下面是一种实现的方法：

1. 首先创建两个数组对象，假设为arr1和arr2，并确保它们具有相同属性，例如 "name"。

2. 创建一个空数组，用于存储相同属性的值，例如同名的 "name" 值。

3. 遍历第一个数组对象arr1，在每次迭代中取出一个对象。

4. 使用Array.prototype.some()方法遍历第二个数组对象arr2，检查是否出现了相同属性的值。

5. 如果找到了相同属性的值，将其添加到空数组中。

6. 使用Set对象来去重，将空数组转换为Set对象，然后再将其转换回数组。

下面是一个示例代码：

// 创建两个数组对象
var arr1 = [{name: 'John'}, {name: 'Alice'}, {name: 'Bob'}];
var arr2 = [{name: 'Alice'}, {name: 'Bob'}, {name: 'Tom'}];

// 创建空数组用于存储相同属性的值
var sameNames = [];

// 遍历第一个数组对象
arr1.forEach(function(obj1) {
  // 检查第二个数组对象中是否存在相同属性的值
  var isSame = arr2.some(function(obj2) {
    return obj2.name === obj1.name;
  });

  if (isSame) {
    sameNames.push(obj1.name); // 将相同属性的值添加到空数组中
  }
});

// 去重
var uniqueNames = Array.from(new Set(sameNames));

console.log(uniqueNames); // 输出：["Alice", "Bob"]

在上面的示例代码中，我们使用了forEach()方法和some()方法进行遍历和检查，同时使用Set对象来去重最后的结果。最后，我们将输出["Alice", "Bob"]。