使用原型链继承:让子对象调用父对象中的方法，实现数组去重;

首先，我们可以定义一个父对象，包含一个去重的方法：

const uniqueArray = {
  removeDuplicates: function(arr) {
    return arr.filter((item, index) => arr.indexOf(item) === index);
  }
};

然后，我们可以使用原型链继承，创建一个子对象，并在子对象中调用父对象中的去重方法：

const myArray = [1, 2, 2, 3, 4, 4, 5];

const myUniqueArray = Object.create(uniqueArray);
const unique = myUniqueArray.removeDuplicates(myArray);

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

在上面的代码中，我们使用 `Object.create` 方法创建了一个新的对象 `myUniqueArray`，并将其原型指向了 `uniqueArray`，这样 `myUniqueArray` 就可以继承 `uniqueArray` 中的方法。然后我们在 `myUniqueArray` 中调用了父对象中的 `removeDuplicates` 方法，将原数组去重得到了一个新的数组。

相关问题

使用原型链继承:让子对象调用父对象中的方法，实现数组去重

首先，我们可以使用原型链继承的方式来创建一个父对象，它包含一个去重方法：

function UniqueArray() {}

UniqueArray.prototype.unique = function(array) {
  return array.filter(function(item, index, arr) {
    return arr.indexOf(item) === index;
  });
};

然后，我们创建一个子对象，并将父对象作为它的原型：

var child = Object.create(new UniqueArray());

现在，我们就可以在子对象中使用父对象的去重方法了：

var array = [1, 2, 3, 4, 2, 1];
var uniqueArray = child.unique(array); // [1, 2, 3, 4]

完整代码如下：

function UniqueArray() {}

UniqueArray.prototype.unique = function(array) {
  return array.filter(function(item, index, arr) {
    return arr.indexOf(item) === index;
  });
};

var child = Object.create(new UniqueArray());

var array = [1, 2, 3, 4, 2, 1];

var uniqueArray = child.unique(array); // [1, 2, 3, 4]

js数组中对象去重方法

可以使用`Array.filter()`和`Array.findIndex()`方法配合实现对象去重。

例如，假设我们有以下数组：

let arr = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 1, name: 'Alice' },
  { id: 3, name: 'Charlie' }
];

我们可以这样写代码来实现对象去重：

let uniqueArr = arr.filter((obj, index, self) => {
  return index === self.findIndex((o) => {
    return o.id === obj.id && o.name === obj.name;
  });
});

这里的`Array.filter()`方法会遍历数组中的每一个对象，然后根据`Array.findIndex()`方法查找这个对象在数组中的第一个索引位置，如果这个对象的索引位置等于当前遍历的索引位置，那么就说明这个对象还没有出现过，可以加入到去重后的数组中。

最终结果将会是：

console.log(uniqueArr); // [{id: 1, name: "Alice"}, {id: 2, name: "Bob"}, {id: 3, name: "Charlie"}]