我可能会在过滤过程中使用标志对象，如下所示：

var flags = {};
var newPlaces = places.filter(function(entry) {
    if (flags[entry.city]) {
        return false;
    }
    flags[entry.city] = true;
    return true;
});

这使用Array#filter了 ECMAScript5 (ES5)，它是 ES5 中可以填充的添加项之一（搜索“es5 shim”以获得多个选项）。

你可以不用filter，当然，它只是更冗长一点：

var flags = {};
var newPlaces = [];
var index;
for (index = 0; index < places.length; ++index) {
    if (!flags[entry.city]) {
        flags[entry.city] = true;
        newPlaces.push(entry);
    }
});

以上都假设应该保留给定城市的第一个对象，而其他所有对象都应丢弃。

注意：正如 user2736012 在下面指出的那样，我的测试if (flags[entry.city])对于名称恰好Object.prototype与toString. 在这种情况下不太可能，但有四种方法可以避免这种可能性：

• （我通常首选的解决方案）创建没有原型的对象：var flags = Object.create(null);. 这是 ES5 的一个特性。请注意，对于像 IE8 这样过时的浏览器，这不能被填充（除非该参数的值为 ，否则的单参数版本Object.create可以是）。null

• 使用hasOwnProperty的测试，例如，if (flags.hasOwnProperty(entry.city))

• 在您知道任何Object.prototype属性不存在的前缀上添加前缀，例如xx：

  var key = "xx" + entry.city;
  if (flags[key]) {
      // ...
  }
  flags[key] = true;
  

• 从 ES2015 开始，您可以使用 aSet代替：

  const flags = new Set();
  const newPlaces = places.filter(entry => {
      if (flags.has(entry.city)) {
          return false;
      }
      flags.add(entry.city);
      return true;
  });
  

es6 的最短但不是最佳性能（请参阅下面的更新）解决方案：

function unique(array, propertyName) {
   return array.filter((e, i) => array.findIndex(a => a[propertyName] === e[propertyName]) === i);
}

性能：https : //jsperf.com/compare-unique-array-by-property

https://lodash.com/docs#uniqBy

https://github.com/lodash/lodash/blob/4.13.1/lodash.js#L7711

/**
 * This method is like `_.uniq` except that it accepts `iteratee` which is
 * invoked for each element in `array` to generate the criterion by which
 * uniqueness is computed. The iteratee is invoked with one argument: (value).
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Array
 * @param {Array} array The array to inspect.
 * @param {Array|Function|Object|string} [iteratee=_.identity]
 *  The iteratee invoked per element.
 * @returns {Array} Returns the new duplicate free array.
 * @example
 *
 * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
 * // => [2.1, 1.2]
 *
 * // The `_.property` iteratee shorthand.
 * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
 * // => [{ 'x': 1 }, { 'x': 2 }]
 */

我对@IgorL 解决方案进行了一些扩展，但扩展了原型并为其提供了一个选择器函数而不是一个属性，以使其更加灵活：

Array.prototype.unique = function(selector) {
   return this.filter((e, i) => this.findIndex((a) => {
      if (selector) {
        return selector(a) === selector(e);
      }
      return a === e;
    }) === i);
};

用法：

// with no param it uses strict equals (===) against the object
let primArr = ['one','one','two','three','one']
primArr.unique() // ['one','two','three']

let a = {foo:123}
let b = {foo:123}
let fooArr = [a,a,b]
fooArr.unique() //[a,b]

// alternatively, you can pass a selector function
fooArr.unique(item=>item.foo) //[{foo:123}] (first "unique" item returned)

绝对不是执行此操作的最高效方法，但只要选择器简单且数组不是很大，它应该可以正常工作。

在typescript中

Array.prototype.unique = function<T>(this: T[], selector?: (item: T) => object): T[] {
   return this.filter((e, i) => this.findIndex((a) => {
      if (selector) {
        return selector(a) === selector(e);
      }
      return a === e;
    }) === i);
};

您可以filter使用 a Setby 仅包含具有尚未添加到 的属性值的元素Set（之后应将其添加到Set）。这可以使用逻辑和运算符 ( &&)在一行中完成。

下面是一个通用函数，用于根据对象数组 ( prop) 中的特定属性 ( )获取唯一对象数组arr。请注意，在重复的情况下，只会保留具有属性值的第一个对象。

const getUniqueBy = (arr, prop) => {
  const set = new Set;
  return arr.filter(o => !set.has(o[prop]) && set.add(o[prop]));
};

演示：

var places = [{
  lat: 12.123,
  lng: 13.213,
  city: 'New York'
}, {
  lat: 3.123,
  lng: 2.213,
  city: 'New York'
}, {
  lat: 3.123,
  lng: 4.123,
  city: 'Some City'
}];
const getUniqueBy = (arr, prop) => {
  const set = new Set;
  return arr.filter(o => !set.has(o[prop]) && set.add(o[prop]));
};
console.log(getUniqueBy(places, 'city'));